A reusable C++23 coding-agent runtime with one event stream for context, replay, resume, and recovery.

_{A reproducible TUI recording: Ava finds four failing tests, edits the implementation, and verifies the fix. The deterministic local provider keeps each take identical. Click for 1080p.
More TUI recordings: ship a backward-compatible feature · resume a session}

Milestones

Ava's release history highlights the capability added at each stage. See the full Changelog and GitHub Releases for all user-facing changes and release artifacts.

• [2026/09] 🔥 Ava adds a task-ready LLVM 22 coding image for Docker and Podman.
• [2026/09] Ava v0.1.0 launches with durable sessions, provider-neutral models and tools, a TUI, one-shot CLI, and Web UI (release).

About Ava

Most coding agents are Python or TypeScript. Embedding one in a native product or running it as a long-lived worker means shipping an interpreter and keeping a second copy of the conversation state. Ava makes the harness a systems component instead: one owner for every stream, process, and durable write, with explicit behavior under cancellation, crash, and restart. See Why C++? for the tradeoffs.

Ava is a headless agent runtime with a streaming terminal UI, one-shot CLI, and Web UI. It supports Anthropic, OpenAI-compatible endpoints such as DeepSeek and llama-server, and Codex using existing Codex CLI credentials. Provider adapters feed normalized events into the same agent loop, tool registry, and session format.

Use Ava as a coding agent, embed one of its C++ modules in a native product, or run the headless runtime as a container worker. The append-only session log drives model context, UI replay, resume, compaction, and crash recovery. Those views are rebuilt from recorded events instead of maintained as separate conversation stores.

[!IMPORTANT] Ava is an alpha release with evolving APIs and formats. Coding-agent use is available through the published container image; embedding Ava's C++ modules still requires a native build toolchain.

Design highlights

• Session files are compressed and repairable. Events are written as concatenated Zstandard frames with decoded-size limits and checksums. A complete corrupt frame is an error; an incomplete final frame is treated as a torn tail and repaired at its last valid boundary.
• Cancellation crosses the whole runtime. Boost.Asio coroutines, executors, cancellation slots, and timers cover HTTP/SSE streams, model adapters, durable writes, and child processes. RAII and move-only handles carry resource ownership across co_await boundaries.
• Interrupted turns have recorded state. Follow-up, steering, pause, abort, compaction, and tool progress are session events. Recovery restores control state and durable ordinals, and detects tool calls that stopped before their result was recorded.
• Limits and package boundaries are tested. HTTP bodies, SSE frames, tool output, records, and decoded batches have explicit limits. Provider wire types stay inside adapters, UI code stays outside the headless runtime, and installed-consumer tests link each component in isolation.

Architecture at a glance

_{One headless runtime, four installable CMake components, and a shared session event stream.}

TUI and Web UI

_{The TUI driven through the built-in local-model provider.}

_{The same headless runtime and session stream projected into the Web UI.}

Link one component or the full agent

Ava installs four CMake components. A worker, service, IDE, or native developer tool can link only the layer it needs without adopting Ava's CLI or frontends.

find_package(Ava CONFIG REQUIRED COMPONENTS agent)
target_link_libraries(my_worker PRIVATE Ava::agent)

Read Architecture for the package contracts and component boundaries.

Get started

• Quick start and usage guide — configure a provider and use the TUI, one-shot CLI, session resume, and Web UI.
• Container quick start: run installed Ava in an LLVM 22 coding environment with Docker or Podman.
• Native build and installation — install the toolchain, build Ava, and install an optimized binary.
• Local models — connect Ava to a local llama.cpp server.
• Architecture and C++ modules — embed Ava's reusable components.
• Documentation index — browse all user and developer guides.

Project status

The public API and on-disk formats may still change before 1.0. Please open an issue for bugs and focused feature proposals. Security reports should follow SECURITY.md.

License

MIT © 2026 Min Liu.