Building local-first, intelligent home automation for Home Assistant.

Heima Labs is an open-source organization dedicated to making homes genuinely smart. Not merely programmable, but adaptive: a home that observes what happens, learns recurring patterns, proposes useful automations, and keeps acting only when the behavior still makes sense.

The goal is not to replace Home Assistant's flexibility. The goal is to reduce the amount of brittle manual automation authoring required for everyday behavior.

Home automation today is still largely manual. You write rules. You maintain them. You fight them when they break. The home does exactly what you told it, nothing more and nothing less.

Heima takes a different approach: it builds a local behavioral model of the home, detects patterns over time, asks for approval before turning learned behavior into automation, and keeps monitoring whether those automations still match reality.

Everything is designed to run locally. No cloud learning service. No external ML runtime. No home telemetry sent away for inference.

The core project: an intent-driven home intelligence engine for Home Assistant.

• Deterministic domain pipeline for presence, occupancy, house state, lighting, heating, calendar, and security.
• Local behavioral learning that detects patterns, generates proposals, and applies them after user approval.
• Reactive behavior engine that fires pre-conditioned actions based on learned or admin-authored policies.
• Proposal lifecycle management, including grouping, replacement, retirement, maintenance, and temporal review bundles.
• Manual-hold framework for respecting user overrides across automation domains.
• Camera privacy policy support for security-driven privacy switch control.
• Structural invariant checks and diagnostics for cross-domain consistency.
• Outcome tracking that verifies whether fired reactions produced the expected result.
• No cloud service dependency for learning or inference.

Status: Active development · v2 in progress · installable via HACS

Heima v2 is no longer only a design exercise. Several core architectural pieces are already implemented in the development branch.

• Domain pipeline and DAG evaluation Built-in runtime domains are evaluated in dependency order, with explicit support for domain plugins declaring depends_on.

• Plugin-oriented internal architecture Heima has internal domain, learning, reaction, and admin-authored policy registries with diagnostics. This is not yet a general third-party dynamic plugin system, but the internal contracts are in place.

• Behavior analyzer contracts Pattern, anomaly, lifecycle, composite, and cross-domain analyzers produce typed findings and proposals through shared runtime contracts.

• Structural invariant checks Per-cycle consistency checks detect impossible or suspicious cross-domain states, such as presence/security mismatches.

• Contextual inference House state, occupancy, weekday, room-context, and cross-domain inference modules use local observations and confidence models to reason about context without external ML.

• Proposal lifecycle management Proposals can be grouped, accepted, rejected, retired, replaced, and reviewed through temporal bundles to reduce review noise.

• Outcome tracking Fired reactions are tracked against expected outcomes, and observed success can feed confidence back into the learning system.

• Manual hold Automations can defer to explicit user intervention through a shared manual-hold framework.

• Camera privacy policies Security policies can turn camera privacy controls on or off based on alarm state and house-state conditions.

• External plugin model The current plugin architecture is internal and built-in. A stable third-party extension model is still future work.

• Broader domain coverage Ventilation, energy, irrigation, and other specialized domains are natural candidates once the plugin surface is stable.

• Richer admin tooling More domain-specific policy editors are planned so complex configuration can be generated without hand-authoring YAML or JSON.

• Deeper contextual reasoning The current system uses local statistical confidence models. More expressive multi-signal reasoning can be added while keeping inference local and deterministic.

Most of the code is written with LLM tools under human architectural direction. The human contribution is specification, product judgment, architecture, review, and real-world validation.

This is partly a deliberate experiment in LLM-assisted software development and partly practical: the specs exist before code is written, and implementation is continuously checked against them.

That changes what "contributing" means here. The most valuable input is real-world testing, architectural feedback, and domain knowledge, exactly the parts that LLMs cannot reliably provide on their own.

• Try it — install via HACS and report what happens in your environment.
• Test real homes — Heima is most useful when tested against messy, real behavior rather than idealized examples.
• Contribute — Python and Home Assistant async patterns are required.
• Discuss — open an issue with logs, diagnostics, use cases, or architectural feedback.

The success metric is invisibility. If the people living in the home never notice the system and things simply happen at the right moment, it is working.