OpenViSTAI · Agents · Blockchain · Crypto
Submit a project
Menu
Agent Infrastructure

Kheish

Kheish is a self-hosted Rust runtime and control plane for persistent, tool-using AI agents. Its daemon separates run execution from the caller, journals session state, and supports restart recovery, approvals, user-question flows and multi-agent orchestration.

Explore the practical guide ↓

Independent OpenViST project profile, based on linked sources.

Kheish — OpenViST project profile in Agent Infrastructure.
OpenViST project illustration. See the linked sources for product details.
Understand the project

Practical overview

When it fits

Use Kheish when agent execution needs a durable daemon-owned lifecycle separate from the application or caller that submits it, especially where interruption recovery or approval and question gates matter.

Who it is for

  • Developers integrating long-running agent tasks into applications, webhooks or other callers.
  • Operators who need agent runs to continue independently of the submitting process and recover from interruptions.
  • Teams coordinating tool-using agents with sessions, approval gates, tasks or sidechains.

Documented uses

  • Submit agent work that continues after the caller disconnects or exits.
  • Keep session and run state journaled so the daemon can recover it after a restart.
  • Observe runs through the CLI by listing, waiting for or streaming run events.
  • Coordinate multi-agent work using sidechains, tasks, schedules and mailboxes.
  • Pause work for approvals or structured user questions.
Before you choose

Requirements & limits

The project is open source under the Apache-2.0 license. Its README documents building and running the daemon locally; no pricing information is provided.

  • Kheish is a daemon-managed execution layer: callers submit and observe work rather than hosting the run.
  • Agent input requires at least one provider key configured in the daemon environment; status and session inspection have a documented no-provider path.
  • The README documents local defaults of 127.0.0.1:4000 for the listener and ./.kheish-daemon for journaled state.
  • The project is implemented in Rust and identifies Anthropic and OpenAI as supported model ecosystems; its quickstart also lists Google and xAI provider-key options.

Check current requirements in the official documentation. Source-based guidance does not mean OpenViST has run or independently tested this project.

Source-based practical guide

Build and start the Kheish daemon

Build the daemon binary and start the documented local control plane.

Before you start

  • A Rust build environment capable of running the documented Cargo command.
  • At least one provider key in the daemon environment to run agents; the documented options are ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY or XAI_API_KEY.

Steps

  1. Build the daemon with the command below.

    Documented command
    cargo build -p kheish-daemon

  2. Set at least one documented provider key in the daemon environment if you intend to run an agent.

  3. Start the service with ./target/debug/kheish-daemon serve.

Expected outcome

The daemon starts as the server and CLI client, binding by default to 127.0.0.1:4000 and journaling state under ./.kheish-daemon.

Guide limitations

  • Starting the daemon without a provider key does not enable agent input; the README documents status and session inspection as a no-provider path.
Documentation 1 ↗
Source-based practical guide

Submit and observe a durable agent run

Create a session, submit agent input, and inspect or follow the resulting run.

Before you start

  • A running Kheish daemon.
  • At least one supported provider key configured in the daemon environment.

Steps

  1. Create a session with ./target/debug/kheish-daemon sessions create demo.

  2. Submit input with ./target/debug/kheish-daemon sessions input demo "Inspect this repo and summarize it.".

  3. List session runs with ./target/debug/kheish-daemon runs list --session-id demo.

  4. Wait for a terminal state with ./target/debug/kheish-daemon runs wait or stream events with ./target/debug/kheish-daemon runs stream .

Expected outcome

The input command returns a run ID while execution continues in the daemon; the run can then be listed, awaited or streamed.

Guide limitations

  • Submitting input requires a configured provider key.
  • The guide describes the documented CLI flow and does not establish behavior for other deployment environments.
Documentation 1 ↗
COMPARE OPTIONS

Compare options for Agent orchestration

These projects document a common task and share a project role. This is a source-based comparison, not an execution benchmark or a guarantee of interchangeability.

ProjectDocumented purposePlatformAccess and requirements
KheishSubmit agent work that continues after the caller disconnects or exits.Self-hosted, ServerThe project is open source under the Apache-2.0 license. Its README documents building and running the daemon locally; no pricing information is provided.
Agentfm CoreRun a containerized agent in a Podman sandbox on a worker machineDesktop, Docker, Self-hostedThe README lists desktop installers for macOS and Linux; it says the Windows app is in progress. Its desktop quick start says the bundled node connects to the public mesh. The README notes that the v1 installers are unsigned and macOS may block the first launch.
PlanoRoute incoming requests to agents based on their declared roles.Self-hosted, ServerPlano is public source code under the Apache-2.0 license. The README describes hosted Plano models free of charge in the US-central region for a first-run developer experience; for production scale it points to running models locally or contacting the project for API keys.
Evidence and transparency

Sources & review

Official repository ↗
Source record details
Source availability
Active
Sources checked
12 October 2026
Original website title
graniet/kheish · Official homepage title · retained in its source language
How we review sourcesSuggest a correction