Skip to main content

What Is Holon

Holon is a desktop-first expert automation workbench for turning human intent into reliable outcomes. It combines guided orchestration, bounded execution, policy-gated tools, and clear evidence of what happened.

The problem​

Complex software work -- coding, research, documentation, planning, verification -- requires more than a chat interface with a language model. A model alone cannot:

  • Remember policy across sessions without drift.
  • Keep authority and accountability explicit at every step.
  • Prevent unsafe tool use or out-of-scope actions.
  • Produce durable evidence that supports review and trust.
  • Stay honest about what it cannot do rather than hallucinating a plausible result.

Holon exists because the harness around the model matters at least as much as the model itself.

Core posture​

Holon draws a hard line between model narration and host truth. The model suggests, the host governs. Evidence, policy, approvals, and persisted runtime state always outrank what a model claims.

Every major design decision flows from this posture.

Key decisions​

1. Desktop-first, not cloud-only​

Holon runs on your machine. The Rust runtime lives in-process inside the Tauri desktop shell. The CLI is a lightweight entrypoint to the same runtime. This means:

  • Workspace state, secrets, and evidence stay local by default.
  • No cloud dependency for core orchestration.
  • Policy and approval are host-owned, not provider-owned.

The desktop surface (HolonDesktop) bundles the runtime and a React renderer into a single application. The CLI (holon) exposes the same runtime capabilities from a terminal.

2. Host-owned orchestration, not model-driven flow​

Holon does not hand the model a tool loop and hope for the best. Every turn follows an explicit lifecycle:

  1. Framing -- interpret intent, surface assumptions, ask clarifying questions.
  2. Planning -- produce a bounded, revisable execution plan.
  3. Capability selection -- choose tools deliberately, not implicitly.
  4. Guarded execution -- validate, approve, execute, capture evidence.
  5. Verification -- prove outcomes, not just produce them.

The model participates at each stage, but it does not own the loop.

3. Evidence is part of completion, not an afterthought​

Every step that produces a result also produces evidence: what ran, with what inputs and outputs, under what policy, producing what outcome. Evidence persists across sessions and supports audit, review, and trust.

This means Holon can say "I don't know" or "this is blocked" with provenance, rather than silently producing a wrong answer.

4. Bounded execution with explicit gates​

Tools are classified by side-effect class. Write operations, destructive operations, and credential-sensitive operations require explicit approval. Read operations have workspace containment. Unknown or unsupported execution lanes fail closed.

The tool catalog is the authority for what can run, under what conditions, with what evidence.

5. Capabilities come from packages, authority stays in the runtime​

Elegy defines portable contracts (skills, capabilities, workflows). Holon imports them, governs them, and executes them under host policy. A portable contract cannot grant itself execution authority -- that stays with the runtime.

Plugin packages, MCP tools, frozen tools, and adapter-backed capabilities all surface through the same governed discovery and execution surfaces.

6. Rust runtime, TypeScript desktop​

The runtime core is Rust for reliability, performance, and strong correctness guarantees. The desktop shell uses Tauri (Rust) plus React/Vite (TypeScript) for responsive cross-platform UI. The CLI exposes the same runtime for terminal-first workflows.

This split keeps execution authority in a compiled, type-safe runtime while keeping the UI layer iterative and fast to develop.

Implementation status​

Holon is in active pre-release development (0.1.0). The architecture described here is the design intent; the current implementation covers the foundations. For a detailed breakdown of what is implemented, partially implemented, and planned, see:

In summary as of 0.1.0: the Rust runtime core, SQLite persistence, workspace tools, skill/capability import, structured output validation, frozen-tool proposals, and basic workflow execution are implemented. Full agent lanes, broad function calling, parallel child execution, deep model routing, and live MCP execution remain planned or partially implemented.

What Holon is not​

  • Not a chat app with tools. Holon has chat, but chat is a surface, not the architecture.
  • Not a model-agnostic proxy. Holon governs execution, not provider abstraction.
  • Not a cloud service. The runtime runs locally. Remote registries and providers are integrated where useful, but they are not the system of record.
  • Not a no-code platform. Holon is for experts who want automation with evidence and control.

Where to go next​