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 server 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.

70+

model providers

5

native clients

60

built-in tools

cargo run --release -p choreo-daemon
you: explain the architecture of this repo
choreo: It's a server + 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 server. 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.

🖥️

Server + multi-client

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

🖼️

Images in the terminal

The TUI renders PNG, JPEG, and vector SVG inline in your chat history — kitty graphics or sixel where supported, with a universal fallback everywhere else. Click any image for a fullscreen view.

🔐

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 server 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.

⛓️

Blockchain native

Built-in EVM and Substrate/Polkadot tools — balances, blocks, transactions, contract calls, ENS resolution, and storage queries — activated with load_tools blockchain.

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.

Architecture diagram: server with TUI, GUI, IM, ACP and server clients, model providers, and the RISC-V VM sandbox

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
  • Server 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

Install a prebuilt binary with Homebrew, a .deb or .rpm, or a static tarball — no Rust toolchain needed. Then start the server and attach a client.

01 Install the binaries

02 Start the server

03 Attach a terminal client and start prompting

brew tap choreographr/choreographr
brew install choreographr
choreographr
choreo-tui
/add-key openai sk-…
hello, choreo!

How Choreographr compares

Feature Choreographr Openclaw Hermes Opencode Codex Pi
LanguageRustTypeScriptPythonTypeScriptRustTypeScript
Server + multi-clientserver
Concurrent sessions✅ server✅ gateway✅ capped✅ server✅ threads
Providers79/3 proto40+34151 (OpenAI)42/9 proto
OAuthcoming soon✅ 6×✅ ChatGPT
Tool permission gatingcoming soonenv-only
Compactioncoming soon
Sandbox✅ RISC-V VM · Landlock/Seatbelt coming soonDocker/SSHDocker/SSH✅ sandbox
Subagents✅ subsessionsswarmdelegation
Skills (SKILL.md)
MCP client
Blockchain tools*✅ native — EVM + Polkadot
ACPbridge
IM surfacesTelegram - more coming soon25+20+
Web searchcoming soon
Hooks/lifecyclecoming soon
Pluginscoming soon
Cron/schedulingcoming soon
Long-term memorycoming soon
Encrypted creds✅ ECDH (X25519) + HKDF + AES-256-GCM✅ keyring
StorageredbSQLiteSQLiteevent srcSQLiteJSONL
Metrics✅ OTel✅ OTeltelemetry
Undo/redobranch
Context fingerprints

* None of the other agents ship native blockchain functionality — Choreographr's EVM and Substrate/Polkadot tools are built in, not bolted on via plugins.

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 and plugins.

⏰ 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.