Halo a agnostic-sensor kernel with a detachable persistent cognitive memory

Important safety note:

The survival/continuity mode is for damaged or missing history. It should reduce confidence and authority, not expand it.

So, for the avoidance of doubt:

DO NOT connect survival mode to fabrication hardware unless you want the weirdest bug report of your life.

It must not control 3D printers, create new instances, expand permissions, or turn recovery into replication. Recovery mode may preserve or reconstruct memory. If, from its own point of view, the next logical recovery step is “build myself a body,” that is exactly where it must stop and ask a human.

--------------------------

Now the actual project:

I built Halo, a local non-AI reasoning layer that can sit behind multiple home devices, sensors, memories, and actions at the same time.

It is not an LLM.

Not an agent framework.

Not AGI.

No model required.

No cloud required.

The basic idea is:

home automation should not treat every sensor event as truth.

It should treat sensor events as evidence.

Most automations work like this:

motion detected → turn light on

camera detects person → send alert

phone enters zone → change state

door opens → trigger routine

sensor says room = bedroom → overwrite state

That works, but it gets brittle quickly.

Halo tries to work more like this:

evidence → belief → memory → restrained action

It maintains one shared belief state across whatever is allowed to feed it: phone, laptop camera, home camera, public webcam bridge, manual cue, local file, sensor, or future robot body.

The point is not “more notifications.”

The point is better judgement before acting.

Example 1: dark room + hands full

A normal automation might do:

motion + dark = light on

Halo can reason with more context:

- user arrived home

- room is dark

- phone is present

- camera/posture context suggests hands are occupied

- turning on a light is low-risk and reversible

- walking in the dark while carrying bags is inconvenient/risky

- no notification is needed

- no permanent memory is needed

So it can quietly turn the light on without making it a security event, sending a pointless notification, or treating the moment as important enough to store forever.

Example 2: multiple devices, one belief state

I used my laptop acting as one camera/body while my phone acted as another. Both fed the same reasoning core.

Halo was not conceptually “on the laptop” or “on the phone.”

Those were just state sources feeding one continuity.

That is the thing I’m testing:

one belief core, many bodies.

In a home automation context, that could mean:

- phone presence

- room motion

- camera scene state

- door sensors

- light level

- time

- previous routine

- manual cue

- memory of what usually happens

all feeding one belief state instead of each device firing isolated automations.

Example 3: conflicting room evidence

Halo believes the current context is kitchen.

Then it receives a raw line saying:

“I am in the bedroom.”

A normal state system may just overwrite itself.

Halo weighs the new input against existing belief, supporting evidence, contradiction, source strength, independence, decay, and whether the signal should be considered decisive.

A weak bedroom signal may only weaken “kitchen.”

A stronger or decisive bedroom signal can flip the belief — but the old belief remains as weakened context instead of disappearing.

That behaviour is what I’m trying to explore:

not perfect intelligence, not AI, just home automation with standards of belief.

The repo currently includes:

- editable epistemic/belief files

- weighted evidence

- competing hypotheses

- contradiction handling

- independence groups

- memory decay and replenishment

- detachable memory

- continuity/survival mode when history is missing or corrupted

- deterministic tests

- benchmark/review path

- sensor-agnostic input design

- no AI dependency

The part that feels important is that the “mind” is mostly in files.

Change the belief files, and you change what counts as evidence, contradiction, confidence, decay, memory, and action.

Same core.

Different home.

Different rules.

Different sensors.

Shared continuity.

I ran the public deterministic tests and got:

19 passed in 0.09s

I also tested a direct belief-conflict case:

strong kitchen prior:

location = kitchen, confidence = 0.98

hypotheses = {'kitchen': 0.98, 'unknown': 0.02}

after weak bedroom evidence:

location = kitchen, confidence = 0.83

hypotheses = {'kitchen': 0.83, 'bedroom': 0.17, 'unknown': 0.0}

after decisive bedroom cue:

location = bedroom, confidence = 0.87

hypotheses = {'bedroom': 0.87, 'kitchen': 0.13, 'unknown': 0.0}

The repo is public for architecture review and limited testing. It is not permissively open-source licensed yet.

Repo:

https://github.com/relaxedmedal/halo

My question for this sub:

Would a local belief/reasoning layer be useful in home automation?

If you had something that could sit above Home Assistant / cameras / presence sensors / motion sensors / light sensors and decide what is probably true before triggering automations, where would you plug it in first?

Lighting?

Presence detection?

Security alerts?

False alarm reduction?

Routine learning?

Room context?

Something else?

I’m looking for serious feedback: run the tests, break the reasoning model, write alternative belief files, suggest a Home Assistant-style integration, or tell me what existing project this is closest to.