100% Rust Apache-2.0 v0.1 · early preview

Your all-purpose AI agent,
written in Rust.

Choreographr is an extensible AI agent system with a daemon at its heart and a client for every surface — terminal, desktop, chat apps, and your editor. LLM-generated code runs in a sandboxed RISC-V VM, and 70+ model providers work out of the box.

Get started GitHub Join the Telegram ↗

70+

model providers

4

native clients

0

unsandboxed shell by default

cargo run --release -p choreo-daemon
you: explain the architecture of this repo
choreo: It's a daemon + multi-client agent.
  One server runs every session; the TUI,
  GUI, IM bridge and editor all connect to it.
you: summarize it into a markdown file
choreo: Reading Cargo.toml, ARCHITECTURE.md…
  (run_riscv) sandboxed VM · 42,310 cycles
  wrote docs/architecture-summary.md ✓
you: and ping me on Telegram when it's done
choreo: done — sent to @you via choreo-im

One daemon. Every surface.

Choreographr was designed from the ground up with a separation of concerns: a single server owns your sessions, and clients come and go as they please. Run it on your desktop, on your home server, or in the cloud — then talk to your agent from anywhere.

🖥️

Daemon + multi-client

Sessions live in the server. Connect, disconnect and reconnect — from a terminal, a desktop app, Telegram, or an ACP-compatible editor.

🔐

Sandboxed RISC-V VM

LLM-generated code is compiled to RISC-V and executed in an isolated ckb-vm sandbox. A complete replacement for the shell tool — full control and observability.

🧠

70+ model providers

OpenAI-compatible, Anthropic Messages and Google Gemini — OpenAI, Anthropic, Mistral, DeepSeek, xAI, Groq, Ollama, OpenRouter and many more.

🌳

Hierarchical sessions

Break work into subsessions that run their own agent loop and report back. Pause them, re-prompt them, and even spawn subsessions of subsessions.

↩️

Undo / redo, per session

If an agent mis-steps, remove the prompt instead of prompting more. Sessions support undo and redo — and multiple sessions run simultaneously.

🔑

Encrypted keystore

Credentials are encrypted per-credential with ECDH (X25519) + HKDF + AES-256-GCM. The daemon starts locked; keys are only decrypted in memory after unlock.

🔌

MCP client

Speaks the Model Context Protocol — spawn MCP subprocess servers, discover their tools, and call them from any session.

✏️

ACP bridge

Drive Choreographr sessions from ACP-compatible editors like Claude Code and Cline over JSON-RPC, right from your IDE.

💾

Agent databases

Persistent, session-scoped key-value stores the agent can write to and read back later. Survives restarts in the embedded redb database.

Architecture at a glance

A small, high-performance core written in idiomatic Rust — OS threads, message passing, no async runtime — with everything else plugging in as clients, tools and providers.

CLIENTS choreo-tui terminal UI · ratatui choreo-gui desktop · dioxus choreo-im telegram bridge choreo-acp editors · JSON-RPC choreographr daemon · the core engine persistent sessions tool-call loop · undo/redo lock/unlock · credentials MCP subprocess servers tools over stdio JSON-RPC RISC-V VM sandbox ckb-vm · 4 MB flat memory redb database sessions · credentials · KV MODEL PROVIDERS OpenAI-compatible 60+ providers Anthropic Messages Claude & more Google Gemini Generative AI API Clients connect over a local Unix socket, or Noise-IK encrypted TCP from anywhere. Sessions are stored in the embedded redb database and survive daemon restarts.

Pick your surface

All clients talk to the same daemon, so you can switch mid-conversation — start in the terminal, continue on your phone.

choreo-tui

primary

A full-screen terminal UI with O(1) scrolling and streaming, markdown rendering, syntax highlighting, and a model selector. Built with ratatui + crossterm.

choreo-gui

in development

A desktop GUI built with Dioxus. Targets Linux, macOS, Windows, Android and iOS.

choreo-im

in development

An instant-messaging bridge — chat with your agent on the go from Telegram (more platforms coming).

choreo-acp

in development

An Agent Communication Protocol bridge so ACP-compatible editors — Claude Code, Cline — can drive Choreographr sessions.

Security is not an afterthought

Giving an LLM direct shell access is risky. Choreographr gives it a sandbox instead: generated code is compiled to RISC-V and executed in an isolated VM with a 4 MB flat memory space and a configurable cycle budget. Every tool access goes through the same registry as the host agent — no host memory, no raw syscalls, no escape hatch.

  • ▸ OS-level sandboxing (Landlock / Seatbelt) planned for tools run outside the VM
  • ▸ Credentials encrypted per-credential with X25519 ECDH + AES-256-GCM
  • ▸ Daemon starts locked — credentials decrypted only in memory after unlock
  • ▸ Remote connections use the Noise IK protocol with X25519 key agreement
# run_riscv: run LLM-generated code in a VM
choreo> read a file, transform it, write it back

# sandboxed — the guest can only call
# registered tools through the VM syscalls

[VM] exited with code 0 in 12,408 cycles
✓ result written to /tmp/out.txt

Up and running in minutes

Requires a Rust toolchain (MSRV 1.91). Build once, then start the daemon and attach a client.

01 Build the workspace

02 Start the daemon

03 Attach a terminal client and start prompting

Read the quick start Clone from GitHub 
git clone git@github.com:ethernomad/choreographr.git
cd choreographr && cargo build --release
cargo run --release -p choreo-daemon
cargo run --release -p choreo-tui
/add-key openai sk-…
hello, choreo!

How Choreographr compares

A quick look at where Choreographr sits in the agent landscape. Maintained alongside the codebase in the README.

Feature Choreo zero goose pi opencode hermes
Daemon + multi-client✅—server———
SandboxRISC-V VMseccomp eng.———Docker/SSH
Providers~70 / 3 proto3635+38/9 proto1529+
Subagentssubsessionsspecialists———delegation
MCP client✅✅✅—✅—
ACPbridge—server———
Encrypted creds✅ unique✅✅ keyring———
Undo/redo✅rewind—branch——
Storageredbfs JSONLSQLiteJSONLevent srcSQLite

Table maintained in README.md. Not exhaustive — see the repo for the full comparison.

On the roadmap

Choreographr is under active development. A taste of what's planned:

🧩 Extensions

Hook into the server over a local socket to expose new tools — including blockchain extensions for EVM, Solana and Polkadot.

⏰ Cron

Run programs automatically at designated times.

🌿 Git worktree support

Parallel subsessions on their own branches with CoW filesystems to avoid rebuilding gigabytes of artifacts.

🔄 Looping

Automate the "review → fix → review" loop until a goal is met, unattended.

🧠 Advanced context management

Permanent vs temporary context to maximise cache hit rate and cut token spend.

🖥️ OS-level sandboxing

Landlock on Linux, Seatbelt on macOS — for tools that must run outside the VM.

Build with us

Choreographr is open source and early. Star the repo, file issues, or join the Telegram community for announcements and development chatter.

Star on GitHub Join the Telegram community