
icarus: A C++23 AI Coding Agent You Can Actually Read
Most autonomous coding agents I look at are Python, TypeScript, or Rust. That's fine — until you want to know exactly what the agent is doing with your shell, your files, and your tokens. Then "fine" stops being fine.
Enter icarus, a CLI AI coding agent written in modern C++ by Lee Stripp. It's a ~1,700-line main.cpp that sits on top of Stripp's own daedalus C++ AI framework and ships as a single statically-linked binary. No pip install. No node_modules. No npm audit surprising you at 2 a.m. Just cmake --build build and a ./build/icarus you can read in an afternoon.
The repo is at gitlab.com/leestripp/icarus and it's MIT-licensed with a 12-tag, single-branch history that already feels deliberate.
Two Modes, One Binary
What makes icarus interesting is that it isn't trying to be three different tools glued together. It does two things, and it does them from the same executable:
- Interactive CLI REPL (the default). You point it at a project directory and you get a conversational coding agent with persistent memory, MCP tooling, slash commands, and a properly-styled terminal UI.
- A2A Agent mode (
--a2a-agent). The same binary switches into an HTTP server that speaks the Agent2Agent Protocol — so an IDE, another agent, orcurlcan drive it as a subprocess.
That second mode is the one I keep circling back to. There is a growing pile of editor plugins that want to talk to a coding agent over HTTP rather than via a stdio JSON-RPC pipe. icarus just is that HTTP server. Run it, advertise it at /.well-known/agent-card.json, and your IDE can hit it.
What's Actually Inside
The README is refreshingly concrete. Here's what you get out of the box:
- 31 in-session slash commands —
/models,/provider,/tools,/skills,/todos,/settings,/history,/mcp-servers,/usage,/paths,/quit, etc. Tab-completion included. - Provider plugins via daedalus — auto-detected from the host:
openai-compatible,minimax,moonshot(Kimi),lmstudio(auth-less local). Payload quirks, temperature clamps, and SSE dialects are handled per-provider. - MCP support — the agent can connect to Model Context Protocol servers for additional tools.
- Context caching — the agent passes a
prompt_cache_keyderived fromagent_name(falling back to a per-project session id) so Moonshot-style cache hits actually work. Cache hit/miss surfaces in/statsand/usage. - Persistent conversation memory across sessions, SQLite-backed.
- Streaming output with delta rendering, a thinking spinner, and
--no-streamfor those who prefer the full response at once. - An adaptive terminal UI — boxed tables, tool-call cards, a 2,048-char delta flush threshold, and live re-layout as you resize the window.
--plain/NO_COLORare honoured for CI. - Line editing via
linenoise(pinned to a specific commit, BSD-2-Clause), with history, ghost-text hints and tab-completion for slash commands.
For an "agent" that lives entirely in your terminal, the surface area is genuinely impressive.
The Architecture in One Paragraph
The design docs are unusually honest about what's not icarus's job. daedalus owns the LLM client, the message history, the tool registry, the state machine, the A2A implementation, the crash handlers, and the SSE parser. icarus owns the CLI argument parser, the REPL loop, the terminal renderer, the line editor, the settings TUI, the migration helper, and the server-side glue that turns an incoming A2A task into a fresh daedalus::Agent invocation.
The interface between them is a single sink: daedalus::AgentSink. icarus implements ConsoleAgentSink and that's the only place the agent ever writes to your terminal. The design doc justifies this with a line I love:
"The library cannot know whether its banner should appear in the host's UI."
That's the entire philosophy in one sentence. icarus is a thin, opinionated shell over a general-purpose agent library. Most of the "interesting" logic is in daedalus, and that's fine.
Build It
You're going to need:
- A C++23 compiler (
g++/gccpreferred,clangworks) - CMake ≥ 3.28
nlohmann_json, OpenSSL,libpng,uuid,sqlite3(dev packages)
Then:
cmake -S . -B build
cmake --build build -j$(nproc)
sudo cmake --build build --target install # lands in ~/.local/bin by default
CMakeLists.txt fans out via FetchContent: it pulls daedalus (which pulls OmniNet, fmt, sqlite-vec, nlohmann_json), linenoise pinned to commit a473823d, and FTXUI pinned to v7.0.1. The FTXUI tab sources from daedalus's demos/daedalus-settings-tui/ are compiled straight into the icarus binary so /settings opens the TUI in-process instead of shelling out to a separate executable. That is the kind of "no new external dependencies" pragmatism that makes the build graph stay readable.
Actually Using It
# Interactive REPL on the current directory
icarus
# Interactive REPL on a specific project, MiniMax M3 model
icarus --model minimax-m3 /path/to/project
# Auto-approve everything (CI / scripted use)
icarus --auto /path/to/project
# A2A agent HTTP server on an ephemeral port
icarus --a2a-agent
# A2A agent HTTP server on a fixed port
icarus --a2a-agent --a2a-port 8080
Inside the REPL, the slash commands are the killer feature. /settings opens an in-process TUI to manage providers, models, MCP, and agent options. /paths shows every config, data, cache, log, and skill path icarus is actually using — which is the kind of thing you desperately want when an agent is doing weird things with your XDG dirs. /mcp-servers enables and disables MCP servers without restarting. /compress does the 70/30 split + LLM summary that most agents hide behind a magic context-window message.
The Honest Caveats
I don't want to oversell this. icarus is young — the project was created on 15 July 2026 and the docs are still catching up. There are no tests of its own (ctest --test-dir build reports "No tests were found", which the AGENTS.md acknowledges is expected; daedalus and OmniNet ship theirs upstream). The user-facing docs are split across README.md, docs/cli.md, docs/design.md, and docs/a2a-protocol.md, and you'll want to read all of them to really understand the model.
There's also a memory-migration helper (--migrate-data / --migrate-data-apply) that copies a legacy ~/.daedalus setup into the XDG-compliant locations. That immediately tells you this is software in transition — the kind of tool that learns its own conventions as it grows.
The biggest philosophical call is the sandboxing model. icarus has --auto but defaults to a per-tool confirmation prompt with y/n/a (always-approve for the session). That is the right default for a tool with full shell access, and it's the right answer to throw at anyone who thinks --auto is the recommended way to run a coding agent on day one.
Why I'm Watching It
The AI-agent space is full of wrappers around wrappers. icarus is interesting because it isn't one. It's a small, well-organised C++ program that leans on a well-organised C++ library, and the two projects are small enough that one person can still hold the whole thing in their head. The A2A story is real — both as a server (your IDE drives it) and as a tool (your agent can delegate to other A2A agents, including ones that aren't icarus). And the in-process settings TUI is a quietly great touch.
If you've been wanting an AI coding agent you can grep -r without a Python venv, give it a look.
git clone https://gitlab.com/leestripp/icarus.git
cd icarus
cmake -S . -B build && cmake --build build -j$(nproc)
./build/icarus --help
It will not solve your LLM bill. But it will solve "I don't actually know what my agent is doing."