Cersei

The complete Rust SDK for building coding agents.

Every building block of a production coding agent — tool execution, LLM streaming, sub-agent orchestration, persistent memory with an embedded graph database, skills, MCP integration — shipped as composable library functions. Build a Claude Code replacement, embed an agent in your app, or create something new.

use cersei::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let output = Agent::builder()
        .provider(Anthropic::from_env()?)
        .tools(cersei::tools::coding())
        .permission_policy(AllowAll)
        .run_with("Fix the failing tests in src/")
        .await?;

    println!("{}", output.text());
    Ok(())
}

Why Cersei

Claude Code and OpenCode are closed, monolithic CLI apps. You can't embed them in your own application, swap the memory backend, or customize the tool pipeline. Cersei gives you the same capabilities as decomposed library functions.

Performance at a Glance

Numbers from run_tool_bench_claude.sh and run_tool_bench_codex.sh. Apple Silicon, release builds.

Startup Time

Peak Memory (RSS)

Memory Recall — The Largest Gap

Both Claude Code and Codex call an LLM every turn to rank memory files. Cersei's embedded graph database does indexed lookups in 98 microseconds — no LLM call, no API cost. Note the log scale.

Sequential Throughput

10 consecutive prompts, per-request average:

Graph ON vs OFF

Enabling the graph database adds zero overhead to scan and context building, and makes recall 92.5% faster:

The recall bar drops from 1359us to 103us with graph enabled. There's no reason to turn it off.

Tool Dispatch (SDK-level)

50 iterations per tool, in-process — no IPC, no subprocess:

Grep and Bash latency is dominated by subprocess spawn. Everything else is pure in-process I/O.

vs General Agent Frameworks

Cersei also competes directly with the Python agent stack — Agno, PydanticAI, LangGraph, CrewAI. Every number below is measured on the same Apple M1 Pro via the harness at bench/general-agents/. Methodology mirrors Agno's own performance cookbook: real agent constructors, no LLM invocation, no stub models. Full methodology →

Agent Instantiation

μs to construct one ready-to-use agent with one tool attached (1000 samples, log scale):

Per-Agent Memory

Bytes per agent held live. Cersei uses jemalloc::stats::allocated; Python uses tracemalloc — both count real bytes allocated by framework code:

Max Concurrent Agents — The Capacity Story

How many live agents can you build and hold on one host? Cersei sweeps to 10k; Python frameworks sampled at N=100 and N=500. Log scale on both axes:

At N=500: Cersei holds them in 8.5 MB / 4.4 ms. CrewAI needs 1 739 MB / 50 697 ms — 204× more memory, 11 500× more wall time, for the same number of agents. Cersei's ramp continues cleanly to 10k agents in 22 MB of total RSS.

What's Inside

Quick Start

use cersei::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let output = Agent::builder()
        .provider(Anthropic::from_env()?)  // reads ANTHROPIC_API_KEY
        .tools(cersei::tools::coding())
        .permission_policy(AllowAll)
        .run_with("What files are in the current directory?")
        .await?;

    println!("{}", output.text());
    Ok(())
}

use cersei::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let output = Agent::builder()
        .provider(OpenAi::from_env()?)  // reads OPENAI_API_KEY
        .model("gpt-4o")
        .tools(cersei::tools::coding())
        .permission_policy(AllowAll)
        .run_with("Explain the architecture of this project")
        .await?;

    println!("{}", output.text());
    Ok(())
}

use cersei::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let provider = OpenAi::builder()
        .base_url("http://localhost:11434/v1")
        .model("llama3.1:70b")
        .api_key("ollama")
        .build()?;

    let output = Agent::builder()
        .provider(provider)
        .tools(cersei::tools::coding())
        .permission_policy(AllowAll)
        .run_with("Refactor this function for readability")
        .await?;

    println!("{}", output.text());
    Ok(())
}

With Streaming

let agent = Agent::builder()
    .provider(Anthropic::from_env()?)
    .tools(cersei::tools::coding())
    .permission_policy(AllowAll)
    .build()?;

let mut stream = agent.run_stream("Fix the failing tests");
while let Some(event) = stream.next().await {
    match event {
        AgentEvent::TextDelta(t) => print!("{t}"),
        AgentEvent::ToolStart { name, .. } => eprintln!("\n[{name}]"),
        AgentEvent::ToolEnd { name, duration, .. } => {
            eprintln!("[{name} done in {}ms]", duration.as_millis());
        }
        AgentEvent::Complete(output) => {
            eprintln!("\n--- {} turns, {} tool calls ---", output.turns, output.tool_calls.len());
            break;
        }
        _ => {}
    }
}

With Graph Memory

use cersei::memory::manager::MemoryManager;

let mm = MemoryManager::new(project_root)
    .with_graph(Path::new("./agent.grafeo"))?;

// Store facts the agent discovers
let id = mm.store_memory("User prefers functional patterns", MemoryType::User, 0.9);
mm.tag_memory(&id.unwrap(), "coding-style");

// Later — recall in 98 microseconds, no LLM call
let results = mm.recall("coding style", 5);

Install

[dependencies]
cersei = { git = "https://github.com/pacifio/cersei" }
tokio = { version = "1", features = ["full"] }
anyhow = "1"

For graph memory:

cersei-memory = { git = "https://github.com/pacifio/cersei", features = ["graph"] }

For the Abstract CLI (complete coding agent) — one-line install on macOS or Linux (detects OS, installs Rust if needed, builds from source, drops the binary on your PATH):

curl -fsSL https://cersei.pacifio.dev/install-abstract.sh | bash

Or install directly via cargo if you already have a Rust toolchain:

cargo install --git https://github.com/pacifio/cersei abstract-cli

Explore