Status and roadmap#

Hekma is becoming the control plane for agent workloads: one way to run, see and steer any agent, from a laptop to a fleet, without ever being the reason prod stops. Hekma 0.11.0, released on 17 October 2026, is the first part of that: it supervises, meters and budgets AI agents on macOS, Linux and Windows, from the CLI or from your own Rust program. Its main limit is that supervision lasts only as long as a process holds the engine open; a long-running host that removes that limit is on the main branch and ships in the next release. This page lists what ships, what is on main, the roadmap for the rest of the control plane, which platforms are supported, and how versions and deprecations work.

What ships in 0.11.0#

Area	What you get
Agents	Run any ACP agent with `--kind acp` (verified with OpenCode and Hermes Agent's `hermes-acp`), or any program through an `adapter.toml` manifest. The `hermes` kind still works but is deprecated.
Lifecycle	Register, start, stop, pause, resume and remove agents. Each agent gets its own process group (Unix) or Job Object (Windows) and its own Agent Home.
Supervision	Crash detection with an automatic restart policy, `--detach` to keep agents running between commands, adoption by the next command, and a Supervision column in `list` and `show`. See Supervision and detached runs.
Metering	Self-reported usage lines, or an engine-observed proxy that reads OpenAI-style and Anthropic usage from the wire, over HTTP or HTTPS, streaming included. Cached tokens are tracked everywhere. See Meter token usage.
Budgets	Token and dollar budgets, per run or cumulative, with `pause`, `stop` or `warn`, checked in the same step that records usage. See Budgets and cost.
Config	Validated config keys with source layers, `agent.*` pass-through, `secret:NAME` references masked everywhere, and memory backings.
Scripting	Versioned JSON output, stable exit codes, and `logs --follow` that streams a detached agent's new output.
Embedding	`hekma-engine` 0.7.0 on crates.io: the full API, an event stream, catch-up after a crash, and a diagnostic sink. See Embed the engine.
Adapters	A frozen adapter contract at 1.0.0 and a conformance kit to test any adapter against it.

Two limits matter most in 0.11.0, and both come from supervision being tied to a running process:

Between commands, a detached agent has no crash handling, no budget enforcement and no metering. Keep hekma agent logs NAME --follow running, or embed the engine.
From the CLI alone, hekma agent send and ACP prompt turns have no usable target, and engine-observed agents cannot be detached. These work from a program that embeds the engine.

On main, unreleased#

These are merged on Hekma's main branch and ship in the next release. Everything in this list is Unreleased: after 0.11.0.

Feature	What it does
`hekma serve` and `hekma-host`	A long-running host that adopts every agent in a state directory and supervises it until told to stop, with a lock against a second host and a graceful drain on SIGTERM. See Run Hekma as a service.
Control API v0	An optional local HTTP and JSON API on `hekma serve`, bearer-token protected, with lifecycle, config, fleet reads and live events. It has no `send` route. See Control API.
Outbox export	One durable, acknowledged journal of every event across all agents, read through the Control API. See Export.
Log capture modes	`--log-capture full`, `metadata` (hashes instead of content at rest) or `off` for every agent a host supervises.
Static Linux build	An `x86_64-unknown-linux-musl` archive with `hekma`, `hkm` and `hekma-host`, and a container recipe that runs it `FROM scratch`.
Follow backlog	`hekma agent logs NAME --follow` starts with the last 200 raw lines a detached agent wrote while no command was running, instead of only new ones. Change the number with `HEKMA_LOGS_BACKLOG_LINES`.
The wire fence	`budget.breach_action = block`, never a default, on agents whose usage is read off the wire. On a breach, the agent's metering listener refuses further model calls with HTTP 402 and a typed, non-retryable error while the agent keeps running, and the fence lifts when the Run ends. It is cooperative: an agent that calls its provider directly is not fenced. See Policies and the warn default.
Consistent state on log failure	If Hekma changes an agent's state but cannot write the matching line to `instance.log`, it puts the state back, so the database never disagrees with the log.

The engine on main is hekma-engine 0.8.0. It adds the host's options and the export methods, and two RegistryError variants and a SpawnSpec field that code matching or building those types needs to handle; Release notes lists them.

Roadmap#

The rest of the control plane is designed and being built in the open. Every item below is not in 0.11.0 or on main yet, and its names, commands and defaults may change before it ships. Each docs page about it carries an in development or planned tag.

In development: being built now, in roughly this order.
Planned: designed, and next once the work it depends on lands.
Later: agreed direction, not yet designed in detail.

In development#

Feature	What it gives you	Docs
The long-running host	`hekma serve` supervises all the time (already on main, above). The CLI will start a local one on demand and route every change through it, so agents outlive your terminal.	Run Hekma as a service
Runs	Every supervised agent becomes a Run with an id, labels, a status and a Control Depth, including child Runs a Host opens for its own units of work. Runs Hekma did not start are planned, below.	Runs, Control Depth, ps and top
`hekma ps`, Selectors and `hekma label`	An exception-first list of Runs, and Selectors on every verb, so you act on `flow=claims,env=prod` instead of one agent at a time.	Runs, Control Depth, ps and top
Policies and the `warn` default	Standing limits by label. A breach signals loudly by default instead of pausing; pausing and stopping stay opt-in.	Policies and the warn default
The wire fence for Policies	The `block` Breach Action, on main per agent (above), applies to every Run a Policy matches on the Metering Proxy, and raising a ceiling lifts the fence on a live Run. Never a default.	Policies and the warn default

Planned#

Feature	What it gives you	Docs
Run Keys and key custody	A per-Run key in the agent’s API-key slot; the real provider key never leaves Hekma. Scent-Check Modes and bypass detection build on it.	Run Keys and key custody
One shared Metering Proxy	One proxy per host for every Run, with endpoint bindings, in place of today’s per-agent proxy.	Attach and wire control
Attach	Framework flows and plain clients become Runs through the proxy, a self-announce header or inbound OpenTelemetry, with Leases instead of process ownership.	Attach and wire control
Wire hold, reroute and reject	Hold a Run’s next model call with its state intact, then release, reroute or reject it.	Attach and wire control
`hekma top`	A live terminal view of Runs with hotkeys.	Runs, Control Depth, ps and top
Never the reason prod stops	Agents survive host restarts, upgrades and crashes, through one small shim per supervised process, and every surface holds at a million Runs.	Status and roadmap

Later#

Nodes and a hub: one view and control across many machines.
Policy as data: versioned, audited Policies with shadow mode and canary rollout.
Customer safety at the wire: checking each Run’s customer and application binding on every tool call and outbound message.
Proof and compliance: a tamper-evident Run ledger and approval gates on high-impact tools.

Platform support#

Platform	Prebuilt binary	Pause	Notes
macOS, Apple Silicon (`aarch64-apple-darwin`)	yes	guaranteed (`SIGSTOP`)
macOS, Intel (`x86_64-apple-darwin`)	yes	guaranteed (`SIGSTOP`)
Linux x86_64, glibc (`x86_64-unknown-linux-gnu`)	yes	guaranteed (`SIGSTOP`)
Linux x86_64, static musl	from the next release	guaranteed	Unreleased: after 0.11.0. Includes `hekma-host`.
Windows x86_64 (`x86_64-pc-windows-msvc`)	yes	best effort	Graceful stop waits for the agent to exit by itself; a forced stop of an adopted agent reaches only the agent, not its children.
Linux on ARM, other targets	no	guaranteed on Unix	Build with `cargo install hekma`.

macOS, Linux and Windows are each built and tested on every change. Building from source needs Rust 1.96.1 or newer. Which capabilities an agent has also depends on its adapter's capability declaration; Architecture explains the per-OS details.

Versions and deprecations#

Hekma follows semantic versioning. These are compatibility surfaces, covered by the policy below:

the CLI's commands, flags and behaviour;
the JSON documents and their schema_versions;
the exit codes;
the adapter contract, currently 1.0.0.

The policy: additions can come in any release. A change that removes or alters something is announced in the release notes and these docs at least one minor release before it takes effect, and the removal itself happens only in a major release. Tests check each documented JSON field and exit code, and every change is compared with the previous release's public Rust API, so an unannounced break fails the build.

The live example is the hermes kind. It was deprecated in 0.11.0 in favour of --kind acp with Hermes Agent's hermes-acp. It keeps working unchanged, hekma agent register --kind hermes still works, and it will not be removed before a major release. Supported agents explains how to move.

Hekma is 0.x#

Hekma has not reached 1.0. Within 0.x, a minor release of a library crate can include breaking changes, and hekma-engine uses that: 0.7.0 added variants to exhaustive error enums, which is why embedders pin "0.7" and read the upgrade notes. The CLI, JSON, exit codes and adapter contract follow the stricter policy above even before 1.0.

Licence and contributions#

Hekma is open source under the Apache License 2.0, free for commercial use, with an explicit patent grant. Contributions are made under a Contributor License Agreement that assigns copyright in the contribution to the project owner and licenses it back to you; opening a pull request means you accept it. See Contributing.