DAEMON-FIRST AGENT RUNTIME

Run agents as durable services, not fragile requests.

Kheish is the durable coordination layer for agents and humans. It gives you persistent sessions, detached runs, approval gates, restart recovery, and built-in coordination across multiple agents.

>_ Start a local daemon Read the docs
Persistent sessions Detached runs Shared channels Approval gates HTTP / SSE control plane
Kheish Daemon
THE PROBLEM

Most agent systems
break at the process
boundary.

If the caller dies, the agent dies.
If a run needs approval, you have to invent suspend and resume. If a workflow spans tools, humans, and external systems, state ends up scattered across requests, queues, and ad hoc storage.
That is manageable in a demo. It is fragile in production.
Kheish moves execution state into a daemon that stays alive independently of the original caller.

Result: durable execution that survives failures, approvals, and restarts.

CORE MODEL

Keep execution state
in the daemon, not
in each client.

Clients submit input to Kheish. The daemon owns the lifecycle of sessions, runs, approvals, tasks, assets, routing, and integrations.

That means:

One session can be reused across CLI, HTTP, webhooks, and automation
One run can pause for approval and resume later
One operator can inspect or control work started by another client
One daemon can survive restarts without losing the execution model

You stop rebuilding runtime behavior inside every integration.

INCIDENT ROOM

One incident. One durable thread.
Multiple agents and humans.

10:32:01
Webhook
Monitoring alert opens case INC-4821
10:32:04
Planner
Creates investigation plan
10:32:10
Worker A
Checks latency dashboards
10:32:12
Worker B
Scans recent deployments
10:33:18
Reviewer
Comments on findings
10:34:02
Human
Approves rollback action
10:35:47
Daemon
Restarts and recovers state
10:35:49
Workflow
Resumes and completes

# incident-4821

RUNNING
sessionsession_01ARZ…
runrun_01HMK…step5/8
Shared channel on top.
Durable sessions and runs underneath.
Core Primitives

The runtime primitives that matter in production.

Building on LLMs shouldn't mean duct-taping state across requests. Kheish provides the industrial-grade runtime primitives required to operate agents as real services across restarts, approvals, and multiple callers.

Durable state

Persistent
Sessions

Journalled state and crash-safe checkpoints. Execution context survives OOM kills, network drops, and daemon restarts without losing the thread.

State protected
Journaled
Checkpoint #1
SIGKILL
Recovery
Lifecycle

Detached Runs

Start work now, stream it later, inspect anytime, resume after approvals or user questions.

running streaming suspended resumable
Human in the loop

Approval Gates

Halt before sensitive actions. Approve asynchronously. Continue from the same execution context.

Approval Required

Action

bash: kubectl delete pod api-7f3d
RUNTIME

Daemon-Managed
Routing

Keep model selection, credentials, runtime settings, and output routing in the daemon instead of hardcoding them into every caller.

SWAPPABLE AT RUNTIME
kheish-daemon
Claude
PRIMARY
GPT-5
FALLBACK
Gemini
STANDBY
Memory

Memory that
stays useful

Kheish separates session history, recovered run memory, durable learnings, and promoted procedural skills. The result is a memory system that is scoped, reviewable, and bounded for prompt safety.

Recover a few useful recent runs

without replaying full transcripts

Keep durable facts, preferences, and decisions

by session, persona, project, or workspace

Promote reviewed procedures

into reusable skills

Inspect what is prompt-eligible

with memory-context, and search broader visible memory with memory-search

Scoped. Safe. Prompt-ready.

Memory is bounded by session, persona, project, or workspace.

Memory schema diagram
Built for your flow
xHigh
subagents
Local
docs
Local
code
Workflow
context

Scoped by session, persona, project, or workspace.

R

responder

v3.2 Active

Frontline customer responder. Routes questions to retrieval, answers FAQs, escalates edge cases to humans.

search faq ticketing escalate
42
Active sessions
Updated 2h ago

Incoming request

User message or task arrives

responder

v3.2

Applies persona instructions, chooses tools

Tools

search
faq
ticketing
escalate

Output

Answer
Escalate
Log & close

Memory slice

Versioned context & preferences

Versions
v3.2Active
v3.1Draining
v3.0Stable
View all versions
Used by
+9
12 personas
Owned by
@leaGrowth Engineering
Created
Apr 12, 2024
Updated
2h ago
SDK / Connectors / Captures

One daemon,
three ways in.

SDK calls, external events, and captured observations
can all converge on the same daemon-owned session state.

SDK

Embed

Embed Kheish into your product and drive sessions, runs, approvals, and streaming from your application.

Popular SDKs
•••

Connectors

Ingest

Route webhooks, chat systems, and external sidecars into durable sessions without rebuilding orchestration per integration.

Popular connectors
•••

Captures

Observe

Store observations now and materialize them into runs later when the workflow actually needs analysis.

Capture sources
•••

One control plane. Multiple ingress paths. One durable source of truth.

Built for operators

Built to be operated,
not just demoed.

Kheish is designed for teams that need runtime boundaries, permission control, durable assets, debug capture, and live reconfiguration.

It exposes a real control plane for the things operators actually need to manage:

HTTP and SSE APIs
CLI control surface
Approval and permission handling
Connector and output routing state
Durable assets and multimodal input
Request and provider debug artifacts
Runtime configuration without rebuilding every client
Sessions
Live and recent operator sessions
Search sessions…
Name
Status
Last Activity
incident-4821
Running
2m ago
release-1.9
Waiting Approval
12m ago
customer-analysis
Running
1h ago
View all sessions
Latest Logs
Real-time system activity
10:35:47daemon restarted
10:35:48recovery complete
10:35:49run resumed · step 5/8
10:36:02tool: kubectl apply …
10:36:11approval requested
Quickstart

Start simple.

Run one daemon. Create one session. Submit one run.
Add approvals, connectors, and external ingress only when the workflow needs them.

# run the local kheish daemon
$ cargo build -p kheish-daemon
$ ./target/debug/kheish-daemon serve --bind 127.0.0.1:4000

# submit your first durable run
$ ./target/debug/kheish-daemon sessions create demo
$ ./target/debug/kheish-daemon sessions input demo "Investigate the
checkout latency spike."

Kheish doesn’t ask you to adopt a new framework.
It gives you a runtime boundary you can integrate into the systems you already have.

Durable by design

State survives restarts and multiple clients.

Integrate easily

Use connectors and captures only when you need them.

Secure & auditable

Approvals and actions are tracked end-to-end.

Run anywhere

Self-host or use a supported provider.

Run the daemon. Connect real workflows. Keep the state.

>_ Get started View API reference