Kheish v0.1.0

A ground-up re-architecture: Kheish is now a persistent agent runtime and control plane for long-lived, tool-using AI agents.

v0.0.2 was a multi-role LLM agent — Proposer/Reviewer/Validator/Formatter roles driven by YAML task files — aimed at code audits and file search. v0.1.0 is a different product built around one invariant: an agent's execution is durable, scoped, and accountable, independently of any caller, process, or human reachability. Instead of an agent loop living inside your application, a daemon owns execution as a first-class resource — like a database row or a workflow execution. Callers (a CLI, a webhook, Slack, your code) submit and observe; they do not host the run. Kubernetes is a control plane for containers, Temporal is a control plane for workflows — Kheish is a control plane for AI agents.

Highlights

• Runs outlive their callers. Submitting input returns a run id immediately and the daemon keeps executing. The caller can disconnect, crash, log out, or get rate-limited; the run continues and stays observable over HTTP/SSE.
• Durable by default. Session state is an append-only JSONL journal with checkpoints. Restart the daemon or reboot the host and runs list reflects journaled state — including approval and user-question gates that paused mid-run.
• Human-in-the-loop without blocked threads. Approvals and structured user-questions are journaled suspension points, not threads waiting on stdin; they can be resolved later by any client, even across a restart.
• Brokered runtime auth instead of root secrets. Runs and sidechains resolve revocable, short-lived leases scoped per session and per agent; external actions are written to a signed, append-only audit ledger (ed25519 + aes-gcm-siv).
• Multi-agent orchestration in the daemon. Sidechains, session and project tasks, cron schedules, and mailboxes — composition stays in your app, execution moves into the daemon.
• Capture as durable observations. Daemon-owned sources for screen, webcam, and microphone (plus connector payloads) with retention, sensitivity, and materialization policy, gated by per-source upload leases.
• One self-hosted binary, no hosted backend. The same kheish-daemon binary is both the server and the CLI client; multi-provider LLM routing is swappable at runtime; runs on a laptop, a VM, or k8s.

What's in 0.1.0

Durability & sessions

• Append-only JSONL session journal covering conversation events, checkpoints, metadata, permission audit, and output records.
• Checkpoints and compaction for long-running sessions; on restart the daemon rebuilds runtime state — root session/agent mapping, pending approvals and questions, active skills and control state, schedulers, delivery queues, and daemon-managed connectors.
• Recovered run memory rebuilt from daemon-owned records and a session-scoped index, not the journal itself.

Detached runs, approvals & questions

• Submit returns a run id; the run executes detached in the daemon. Observe with runs list, runs wait, and runs stream over HTTP and Server-Sent Events.
• Approval gates and structured user-question flows pause a run mid-execution and resume when answered — asynchronously, by a different client, and safely across daemon restarts.

Multi-agent orchestration

• Agent hierarchy with parent agents and sidechains.
• Session tasks with ownership, status, and dependencies; projects and project tasks spanning multiple sessions; cron schedules; mailboxes.
• Channels for shared public conversations, backed by their own durable message and reaction log instead of collapsing agents into one session.

Brokered auth & audit

• Long-lived credentials stay in daemon-owned auth slots (auth_ref). Runs and child sidecars resolve brokered, short-lived, revocable leases rather than receiving root secrets.
• Per-session and per-agent subjects, with CredentialScope narrowing so delegated work can keeting connector or MCP credentials by default.
• Signed, append-only external-action audit ledger; broker revocation state for issued grants and leases is persisted in the state root. Crypto: ed25519 signatures, aes-gcm-siv for secret slots.

Capture & observations

• Daemon-owned observation sources — screen_snapshot, webcam_snapshot, microphone_segment ads) — carrying retention, sensitivity, and materialization policy.
• Ingest gated by per-source upload tokens with leases, expiration, and one-command revocation; raw payloads stored alongside optional canonical text, caller metadata, stream_id, and seq_no.
• Capture-group correlation across screen/webcam/audio legs, and audio canonical_text derivatiiption backend (OpenAI or OpenRouter).
• kheish-capture host-local reference runtime with fixture and live screen/webcam/microphone drivers and macOS onboarding. See docs/capture.md.

Extensibility

• Built-in coding and web tools; lifecycle hooks; a large reusable skills library shipped under via rmcp; daemon-managed ingress connectors; and generic, routed output plugins.

Operator control plane

• Control plane over HTTP/SSE with runtime reconfiguration — routes, auth slots, models, and permissions can be changed live without rebuilding or redeploying callers.
• Built-in bearer auth, debug capture, and a single binary that serves both the API and the CLI.rfileand an nginx reverse-proxy config underdeploy/`.

Providers

• Native drivers for Anthropic, OpenAI, Google, and xAI, plus an OpenRouter aggregator route for additional vendor models.
• Routes bind a route_id, a default/current model, and an auth_ref; sessions can be moved acruntime without a redeploy. Any provider reachable over HTTP works.
• Multimodal input throughout; image generation/editing, native web search, and audio/transcription are available where the provider supports them.

Breaking changes & migration

v0.1.0 is a complete re-architecture and is not an in-place upgrade from v0.0.2.

• The v0.0.2 model is gone: no Proposer/Reviewer/Validator/Formatter roles, no YAML task definitions, no fs / sh / rag / ssh / memories modules, no built-in RAG store, and no single kheish --task-config <file>.yaml invocation.
• Old YAML role/task workflows do not carry over and there is no automated migration. Treat this as a new product: model your work as sessions and runs against the daemon, starting from the quickstart below.
• The on-disk state format is new (daemon state root under ./.kheish-daemon); there is nothingall.