Agentic Daemon Runtime

Daemon-first AI environment

A fully agentic environment where the daemon owns work, goals, memory, approvals, and tool execution beyond any client connection.

Get started Architecture
Daemon-firstState lives in the daemon, not the UI.
WorkspacesJira-style task boards over threads and goals.
Goal runnersDurable autonomy for multi-step work.
Governed executionApprovals and provenance built in.

What it is

Zorai is a shared execution environment where the daemon owns terminal sessions, agent threads, workspace tasks, execution queue state, goal-run state, approvals, memory, and telemetry. Electron, the TUI, the CLI, MCP clients, and chat gateways all reconnect to the same durable runtime.

Mental model: an autonomous operating environment with terminal surfaces, not a disposable prompt window.

Capabilities

Daemon as source of truth

The daemon owns sessions, threads, workspace tasks, approvals, goal runs, transcripts, memory, and operational state. Clients are views into that state.

Workspace task boards

Workspaces organize threads and goals into Todo, In Progress, In Review, and Done with assignees, reviewers, history, and local mirrors.

Durable goal runners

Goal runs accept long-running objectives, create plans, dispatch child execution items, survive disconnects, and record reflections and reusable skills.

PTY and workspace control

Manages panes, surfaces, terminals, command history, transcripts, and terminal-native execution while keeping agent actions visible.

Layered memory

Identity, durable facts, operator profile, structured runtime state, recall, skills, and provenance-backed memory.

Governed autonomy

Risk is evaluated structurally. Approvals are scope-bound and can go stale. Risky actions are critiqued before execution.

Runtime plugin system

Plugins add components, commands, YAML views, assistant tools, and executors for domain-specific workflows.

Multiple operator surfaces

Electron for desktop, TUI for SSH, CLI for automation, MCP for external agents, gateways for chat platforms.

Self-orchestrating runtime

The daemon delegates, checkpoints, detects stuck states, recovers, learns from traces, and escalates when blocked.

Note: The daemon/runtime is the most complete layer today. Public clients expose goal, approval, and inspection workflows.

Architecture

Operator
|
+--> Electron / React UI
+--> TUI
+--> CLI
+--> MCP clients
+--> Slack / Discord / Telegram via gateway
         |
         v
    Zorai daemon
         |
         +--> PTY session management
         +--> Agent runtime
         +--> Workspace tasks
         +--> Execution queue
         +--> Goal runners
         +--> Approval flow
         +--> Persistence + telemetry

The fundamental boundary: once the daemon is running, the rest of the platform becomes interchangeable surfaces over the same long-lived state.

Next steps

Operator guides

Installation, first-run flow, daily habits, and scenario-based workflows.

Best practices

How to use Zorai well: threads, goals, compaction, approvals, and model roles.

Technical deep dive

Daemon ownership, workspace tasks, execution queue, self-orchestration layers, and component breakdowns.

Workspaces

How board-owned tasks wrap threads and goals with assignment, review, history, and local JSON mirrors.

Goal runners

How durable autonomy works, when to use it, and how it fits the goal surfaces.

Memory architecture

How layered memory, provenance, recall, skills, and durable writes actually work.

Security

How approvals, critique, containment, provenance, and governance protect autonomous work.

Plugins

How Zorai is extended through runtime-installed or in-tree plugins.

Reference

Paths, providers, build/run commands, packaging, notifications, and publishing.

Who it's for

  • Developers who want long-running AI work to survive closing the UI.
  • Operators who need a visible, governed control plane rather than invisible automation.
  • Teams exploring multi-agent workflows, plugins, workspace boards, execution queues, and domain-specific mission layers.
  • People who want terminal-native workspaces but do not want to give up modern orchestration and memory.