[ art.ans · 120×33 · ANSI/256 ]

a native C++ AI agent runtime and CLI harness█

Built as a native C++17 runtime, not a collection of scripts around an API.
Extensible providers, tools and capabilities through one plugin architecture.
Interactive TUI or headless CLI, running on Linux and macOS.

./try github.com/jtrefon/amber ./architecture

Beta

Amber is usable today, but still evolving. If you try it, feedback is genuinely useful, especially things that feel confusing, incomplete or broken.

What is Amber?

Amber is a native C++17 AI agent runtime and CLI harness for building and running tool-using agents.

Its core is deliberately extensible: providers, tools and UI capabilities use the same plugin architecture, allowing Amber to grow without hardcoding every integration into the runtime.

Use the interactive terminal UI, run the headless CLI in automation, or embed the native runtime in another C++ project.

What Amber can do

Work with code and files

Read and modify files
Search project trees
Semantic / local search
Work inside a confined workspace

Execute and automate

Run shell commands
Track jobs
Apply approval gates to side-effecting operations
Run headless from scripts and automation

Connect

Multiple LLM / provider implementations
MCP servers
Provider-specific dialects
Extensible provider plugins

Delegate

Sub-agents
Parallel / serial delegation
Shared runtime infrastructure

Manage long-running sessions

Context compression
Memory / skill mechanisms
Context integrity protections
Runtime telemetry

Extend

Plugin / capability architecture
Provider capabilities
Tool capabilities
UI / status / panel capabilities

Everything is a capability

Amber's core does not need to know every provider, tool or extension that exists. Capabilities are contributed through the plugin architecture and installed by the runtime. Providers, tools and UI extensions use the same underlying mechanism, so new integrations do not require special cases throughout the agent core.

Plugins can be enabled, disabled and unwound cleanly, with contributions tracked by owner.

Build a plugin →

Why C++?

Amber is compiled C++17 from the runtime up. The agent loop, context management, tools, plugin system and clients share the same native core.

The result is a small, explicit runtime with no Python or Node dependency, while the core remains usable as a library rather than being tied to a single interface.

flowchart TB
    hosts["Hosts<br/>amber TUI · amber-cli · amber-bench"]

    subgraph kernel["libagent_core: microkernel"]
        runtime["PluginRuntime<br/>capability ledger"]
        registries["Contribution registries<br/>tools · providers · commands · status · panels"]
        agent["Agent loop + Context"]
        events["Typed EventBus"]
        transport["LLM transport<br/>openai protocol"]

        runtime -->|install / unwind| registries
        registries --> agent
        agent --> events
        agent --> transport
    end

    bundled["Bundled plugins: compiled in<br/>providers · core tools · status segments · panels"]
    external["External plugins<br/>separate process · JSON-RPC over stdio<br/>tools only"]
    endpoint["OpenAI-compatible endpoint"]

    bundled -->|declare Capability| runtime
    external -->|tool.call| registries
    transport --> endpoint
    hosts -->|AgentHooks| agent

The microkernel: hosts above, plugin contributions installed into the core registries through the ledger.

One runtime, multiple clients

libagent / core runtime

the engine

Native agent runtime containing the agent loop, context, tools, plugin runtime and supporting infrastructure. It can be linked into another C++ application rather than requiring the interactive Amber client.

amber

interactive terminal UI

The primary interactive client with the retro IRC/BitchX-inspired multi-window interface, sessions, slash commands, jobs, plugin controls, approval dialogs and runtime telemetry.

amber-cli

headless agent

For scripts, CI, automation, scheduled jobs and environments where an interactive TTY is unnecessary.

amber-bench

evaluation harness

Runs repeatable scenarios against the same agent engine and produces measurable results using scenario / oracle scoring.

Bring your model. Keep the runtime.

Amber separates the agent runtime from the model provider. Provider integrations live behind the same plugin architecture, allowing the harness to work with different vendors and OpenAI-compatible endpoints without changing the agent loop.

Bundled provider plugins: Anthropic, Gemini, OpenRouter, DeepSeek, KiloCode, OpenCode, CommandCode, Custom, and OpenAI-compatible endpoints.

MCP

Connect Amber to MCP servers over the supported transports and extend the agent with external tools and services.

Sub-agents

Delegate work to sub-agents through the same runtime, with support for serial and parallel execution.

Agents should not get a blank cheque

Amber treats model output as untrusted input. Filesystem operations are confined to the workspace, side-effecting operations can require approval, shell execution is gated, and jobs are isolated and bounded.

The goal is not to pretend an agent is safe by default. The goal is to make its trust boundaries explicit.

Measure the harness, not the demo

Amber includes its own benchmark and evaluation harness so changes to the runtime can be tested against repeatable scenarios rather than judged from a few impressive demos.

Full results and methodology →

Where it runs

macOS

Apple Silicon binaries available. Install via Homebrew.

brew install jtrefon/homebrew-amber/amber-agent

Linux

Prebuilt Linux binaries and build-from-source options.

# .deb / .rpm / tarball
# or build from source:
git clone https://github.com/jtrefon/amber
cd amber && make

Get Amber → · Build from source

Try it. Break it. Contribute.

Amber is open source (Apache 2.0) and currently beta. The project is ready for people to try, inspect and contribute to.

./try github.com/jtrefon/amber

Found something broken, or have an idea?Report a bug · Request a feature · All the ways to contribute