Kheish
Open-source daemon runtime that runs AI agents as durable services with crash recovery and approval gates.
Kheish is worth real attention if you have already felt an agent die because the caller disconnected, or you have hand-rolled suspend-and-resume for an approval step. The journaled checkpointing, detached runs, and async approval gates are the exact primitives most agent frameworks make you rebuild, and keeping model routing and credentials in the daemon is a clean separation. The honest trade-off is ecosystem: this is early, open-source, and self-hosted, so expect to wire your own tools and operate the daemon yourself. If you want plug-and-play integrations or a managed cloud, look at hosted agent platforms instead.
Verified 1d ago · liveness 43/100 · cite: rightaichoice.com/tools/kheish
- Platform engineers building durable agent infrastructure
- Incident response teams automating multi-tool triage with human oversight
- Developers deploying long-running tool-using agents in production
- Teams needing stateful agent sessions across multiple callers (CLI, HTTP, webhooks)
- End users or non-developers looking for a turnkey chatbot
- Teams wanting a batteries-included agent framework with pre-built integrations
- Simple single-turn Q&A use cases where daemon overhead outweighs benefit
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Kheish if you want a hosted, managed agent platform with pre-built integrations and no daemon to operate yourself.
Self-hosting means you pay in engineer time and infrastructure: someone has to run, upgrade, and monitor the daemon on your own VM or cluster.
Kheish is free and open source under a community edition: $0/mo gets all core features including durable sessions, detached runs, approval gates, and checkpointing. That undercuts hosted agent platforms charging per-seat or per-run, but the real cost is operational—you supply the VM or cluster and the engineering time to run the daemon. It fits individual developers and platform teams already comfortable operating services; it fits poorly teams that would rather pay a vendor for a managed
In short
Kheish — Open-source daemon runtime that runs AI agents as durable services with crash recovery and approval gates. Best for Platform engineers building durable agent infrastructure, Incident response teams automating multi-tool triage with human oversight, Developers deploying long-running tool-using agents in production. Free to use.
Viability Score
How well maintained and how widely used is Kheish? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: September 2026
How we score →Key Features
- Durable persistent sessions with journalled state and crash-safe checkpoints
- Journaled checkpointing that recovers after SIGKILL, OOM kills, network drops, and daemon restarts
- Detached runs — start work now, stream it later, inspect anytime, suspend and resume
- Async approval gates that halt before sensitive actions and continue from the same execution context
- Multi-agent shared channels (incident rooms) with humans and agents on one durable thread
- Daemon-managed routing of models, credentials, runtime settings, and outputs
- Runtime-swappable model providers (primary, fallback, standby slots) without redeploying callers
- Scoped memory split into session history, recovered run memory, durable learnings, and procedural skills
- memory-context command for view of prompt-eligible memory; memory-search for broader visible memory
- Persona-based versioned identities carrying instructions, tools, and memory, upgradeable across active sessions
- Callable code blocks (xHigh subagents) for workflow context
- Local docs and local code integration for tool use
- Captures for persisting raw observations into durable sessions
- HTTP and SSE control plane plus CLI for session and run management
- SDK for embedding Kheish into your own application
About Kheish
Kheish is an open-source, daemon-first agent runtime for platform engineers who need agents to survive the process boundary. Instead of bundling execution state into the client, Kheish keeps sessions, runs, approvals, tasks, assets, and routing inside a persistent daemon that stays alive independently of whatever caller started the work. That means one session can be reused across CLI, HTTP, webhooks, and automation, a run can pause for human approval and resume later, and an operator can inspect or control work started by another client. Core primitives include journaled checkpointing that recovers after SIGKILL, OOM kills, network drops, and daemon restarts; detached runs you can start now, stream later, suspend, and resume; async approval gates that halt before sensitive actions like a kubectl delete; and shared channels that give a single incident one durable thread for multiple agents and humans. Memory is separated into session history, recovered run memory, durable learnings, and promoted procedural skills so prompts stay scoped and bounded, with memory-context for inspection and memory-search for recall. Personas act as versioned identities carrying instructions, tools, and memory, so shipping an upgrade benefits every active session without breaking in-flight work. The daemon manages model routing, credentials, and output routing, so you can swap providers without redeploying callers. You drive it through an SDK, a CLI, or an HTTP/SSE control plane, and it runs as a single binary on a laptop, VM, or cluster with no hosted backend required. It is a runtime, not a framework and not a turnkey chatbot.
Behind the Verdict
Kheish's core insight is architectural rather than algorithmic: most agent systems break at the process boundary, not at the model. The daemon holds the execution model—sessions, runs, approvals, tasks, assets, routing, integrations—so a caller dying, a network dropping, or the daemon itself restarting does not lose the thread. The feature that best demonstrates this is journaled checkpointing with SIGKILL recovery; the feature that best demonstrates operator empathy is the approval gate, where an action like a shell command is held until a human approves or denies, then execution continues from the same context. Shared channels are the underrated piece: in the incident-room model, a planner, two workers, a reviewer, and a human all post to one durable thread pinned to a session and run, and a daemon restart at step five of eight resumes and completes. Memory design is deliberately conservative—session history, recovered run memory, durable learnings, and promoted procedural skills are kept separate and scoped by session, persona, project, or workspace, with memory-context narrowing what is prompt-eligible and memory-search widening recall. Personas solve a real drift problem: a versioned identity carries instructions, tools, and memory, and upgrading once updates every active session rather than leaving stale copies in each integration. Where Kheish is weaker: the scraped material names no pre-built integrations, so the connector story is bring-your-own despite connectors being a headline capability, and self-hosting means you own uptime, upgrades, and log retention. There is no managed cloud offering described. It is also explicitly not a plug-and-play chatbot, and for single-turn Q&A the daemon overhead is pure cost. Fit-wise this is strongest for platform teams running long-horizon, tool-using agents with human sign-off—incident response, code review assistants that pause for feedback, multi-hour research agents, and escalation workflows that span channels. It is the wrong pick for non-developers or anyone in a serverless-only environment where a persistent daemon is not feasible.
Researching Kheish? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Kheish actually fits — and what changes day-one when you adopt it.
A monitoring webhook opens an incident, a planner agent drafts an investigation plan, two workers check latency dashboards and recent deployments, and the workflow halts at an approval gate before a rollback command runs.
Outcome: The daemon restarts mid-incident at step five, recovers journaled state, and the workflow resumes and completes without anyone re-running the investigation.
A review agent inspects a diff, posts findings to a shared channel, and pauses for a human reviewer to comment before continuing.
Outcome: The reviewer replies hours later and the run resumes from its checkpoint with the diff context intact, so no re-analysis is needed.
An agent collects data over several hours, periodically pausing to answer a user query, with durable learnings and procedural skills kept separate from the session transcript.
Outcome: Memory-context keeps prompts bounded while memory-search retrieves earlier findings, and the run continues across disconnects.
Use Cases
- Run a multi-agent incident response workflow that survives a daemon restart mid-investigation and requires human approval before rollback.
- Build a persistent code review assistant that pauses for human feedback and resumes from checkpoint.
- Orchestrate a research agent that collects data over hours, pauses for user queries, and continues from scoped memory.
- Deploy a durable customer support escalation agent using versioned personas that maintain context across channels.
- Create a workflow where a planner agent delegates to worker agents and a reviewer agent verifies actions asynchronously.
- Operate a long-running data pipeline agent that calls external APIs, stores intermediates, and recovers from failure.
- Run an incident room where planner, workers, reviewer, and human share one durable session thread.
Models Under the Hood
as of 2026-09-01
Limitations
- Kheish is a daemon-first runtime, so you self-host it: single binary on a laptop, VM, or cluster, with no managed cloud offering described in the scraped material.
- You own uptime, upgrades, log retention, and daemon operations.
- Documentation centers on the README and docs site, and while connectors and captures are headline capabilities, no specific pre-built connector list is published, so expect to wire your own webhooks, chat systems, and sidecars.
- It is explicitly a runtime rather than a framework, so it won't hand you a curated tool library or opinionated agent patterns.
- For single-turn Q&A the coordination layer is pure overhead.
as of 2026-09-13
Verification history
We have re-verified Kheish 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Kheish tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source (Community)
$0/mo
Ideal for
Platform engineers and small teams comfortable self-hosting a daemon on their own laptop, VM, or cluster and wiring their own connectors.
What this tier adds
Starting tier and only published tier: $0/mo for all core features including durable sessions, detached runs, approval gates, and checkpointing, with community support via GitHub.
Where the pricing makes sense
The company stage and team size where Kheish's pricing actually pencils out — and where peers do it cheaper.
Kheish is free and open source under a community edition: $0/mo gets all core features including durable sessions, detached runs, approval gates, and checkpointing. That undercuts hosted agent platforms charging per-seat or per-run, but the real cost is operational—you supply the VM or cluster and the engineering time to run the daemon. It fits individual developers and platform teams already comfortable operating services; it fits poorly teams that would rather pay a vendor for a managed
Setup time & first value
How long it actually takes to get something useful out of Kheish — broken out by persona, not the marketing-page minute.
For a developer already running services, expect under an hour to first value: start the local daemon from the single binary, run a session through the CLI, then add an approval gate. Platform teams deploying to a shared VM or cluster should budget a day for daemon deployment, SDK wiring, and connector setup, since connector specifics are not published and must be wired by hand.
Switching to or from Kheish
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From hand-rolled request-response agent code: move session and run state into the daemon and let the SDK drive sessions, runs, and streaming.
- →From an agent framework with client-side state: replace suspend-and-resume logic with detached runs and approval gates.
- →From queue-and-database glue: consolidate scattered state into daemon-owned sessions, assets, and routing.
- →From a hosted agent platform: self-host the single binary and repoint your callers at the CLI or HTTP/SSE control plane.
- ↗To a hosted agent platform: export session history and durable learnings, then rebuild orchestration on the vendor's managed runtime.
- ↗To an agent framework: extract persona instructions, tools, and skills, and re-implement durability in application code.
- ↗To a workflow engine: map shared channels and approval gates onto the engine's task and human-task primitives.
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “Kheish”, and we withheld 6: 6 could not be judged, because “Kheish” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Kheish.
Official links
Tools that pair well with Kheish
Common stack mates teams adopt alongside Kheish, with the specific reason each pairing earns its keep.
Featured Head-to-Head Comparisons
Kheish vs Spider Cloud
Choose Kheish if you need to run AI agents as durable, long-running services with crash recovery and human oversight. Choose Spider Cloud if you need fast, reliable web data extraction for LLMs or RAG pipelines. They solve different problems—one is a runtime for agentic workflows, the other is a data retrieval API.
Kheish vs Temporal Ai
Choose Temporal AI if you need a battle-tested, general-purpose durable execution platform with broad SDK support and cloud scalability, or if you're orchestrating complex microservices with Saga patterns. Choose Kheish if your primary focus is deploying long-running, tool-using AI agents with minimal overhead and you value built-in approval gates and detached run semantics. Both are open-source, but Temporal offers a cloud service while Kheish is entirely self-hosted.
Kheish vs Presto Voice
Presto Voice and Kheish serve entirely different needs. Presto Voice is purpose-built for QSR drive-thru automation with proven revenue lift, while Kheish is an infrastructure tool for developers building durable AI agents. Choose Presto Voice if you run a QSR chain and want to boost order value; choose Kheish if you engineer production agent systems that must survive crashes.
Alternatives to Kheish
View all
Temporal AI
Open-source durable execution platform that keeps long-running workflows and AI agents alive through crashes, retries, and flaky APIs.
Popular in Agent Frameworks & Orchestration
Frequently Asked Questions
Best-of guides
Topics
Used Kheish? Help shape our editorial sentiment research.