Agents as processes, with a kernel underneath

Astrid takes a literal stance most agent projects only gesture at: it is a user-space microkernel that treats AI agents the way Linux treats processes. There is a kernel with a boot sequence, a virtual filesystem with a copy-on-write overlay, ed25519 capability tokens, an IPC event bus, WASM process isolation, and a cryptographic audit trail where each entry hashes the previous. If you have ever wanted agent infrastructure that looks like an OS rather than a Python script with a while-loop, this is the project built on that premise.

The organizing idea is the capsule. The kernel is fixed; everything above it, providers, orchestrators, tools, frontends, interceptors, is a swappable WASM capsule described by a Capsule.toml manifest with typed [imports] and [exports]. The kernel resolves dependencies by topological sort and boots them in order. You do not fork Astrid to customize it, you compose a different set of capsules. As the README puts it, this is not a plugin system bolted onto an application, it is the application’s architecture.

What the capsule model unlocks

Because the boundary is the kernel, swapping behavior does not mean editing core code:

  • Run offline by swapping the provider capsule for one that talks to Ollama or vLLM; the orchestrator neither knows nor cares.
  • Novel orchestration as a capsule: a debate system, a tree-search planner, a chain-of-verification loop, with sandboxing, budget enforcement, and audit already solved.
  • Transparent caching as a middleware capsule between orchestrator and provider, with no change to either.
  • Self-modifying agents that write a new capsule (Rust plus Capsule.toml plus tests), build it with astrid-build, install it with capsule install, and extend their own OS at runtime within the capability sandbox.

Install

It ships on crates.io as a set of binaries:

cargo install astrid
ANTHROPIC_API_KEY=sk-... astrid chat

cargo install astrid installs both astrid (the CLI frontend) and astrid-daemon (the kernel process); astrid-build compiles capsules. Running astrid chat auto-starts the daemon in the background, connects over a Unix domain socket, and renders streaming events. You can also clone the repo and cargo build --release.

Agency for the agent, authority for the human

Astrid is explicit that it inverts traditional computing: the agent operates and acts, the human supervises and steers. The kernel enforces boundaries so the agent can act freely within them, and approval gates keep the human in the loop at the moments that matter rather than every step. How much rope you give it is a setting: mode = "safe" asks before every action outside the workspace, guided auto-allows reads and asks for writes, autonomous removes the guardrails, and yolo is exactly what it sounds like. The capability system lets trust expand as the agent proves reliable, and the hash-chained audit trail gives you accountability after the fact. That graduated-trust model is itself a design statement: it assumes you will not hand an agent full autonomy on day one, and gives you a dial rather than a single on-off switch, with the kernel, not goodwill, enforcing whichever setting you choose.

How early it is, stated plainly

This is the part to weigh hardest. Astrid is at v0.5.0, runs in user space, and its only frontend today is the built-in CLI. The README is honest that the architecture is real, the kernel, IPC bus, capsule manifest system, and dependency resolver all exist and are tested, but that what varies is how many capsules have been built on top so far. So you are adopting a well-designed foundation with a young ecosystem, not a turnkey platform. With 201 open issues as of 2026-06 and a small fork count, it is best seen today as infrastructure for researchers and builders who want to write capsules, not as a finished agent you install and use. If the capsule abstraction excites you, that is the reason to engage now; if you want a working assistant out of the box, it is too early.

For the JavaScript path to writing capsules, see its companion sdk-js. For a finished, always-on personal agent rather than an OS to build on, see Hermes Agent. For more of the Rust ecosystem, see Rust trends, and for what else is climbing, the daily digest and weekly report.

FAQ

What does “operating system for AI agents” mean here? A user-space microkernel that runs agents like processes: WASM isolation, capability tokens, IPC, a virtual filesystem, budget enforcement, and a cryptographic audit trail, with everything above the kernel as a swappable capsule.

How do I install it? cargo install astrid, then ANTHROPIC_API_KEY=sk-... astrid chat, or build from source with cargo build --release.

Can I run it without a hosted model? Yes. Swap the provider capsule for one targeting Ollama or vLLM; the rest of the system is unchanged.

Is it ready for production? It is v0.5.0 with a CLI-only frontend and a young capsule ecosystem. The kernel is tested, but treat it as a foundation to build on, not a finished product.