moo

An AI agent, written in C.

moo is a small, self-contained AI agent runtime written in C — plus the
foundation libraries it rides on. It ships as a terminal app you build from
source and run against any OpenAI-compatible endpoint (Kimi, GLM, DeepSeek,
OpenAI itself, …), with a streaming REPL, tool calls, token budgeting,
sidecar queries, and a layered memory design. An Anthropic-compatible backend
is on the roadmap — the provider layer is a vtable, adding one is a contained
change.

• Designed and reviewed by @mivinci
• Coded by CodeBuddy (VSCode plugin) with claude-opus-4.7 and GLM-5.1

Status. Active development. macOS and Linux are first-class; Windows is
on the roadmap but not a near-term priority.

Highlights

• Agent core in C — xAgent + xAgentSession + xAgentQuery +
  xAgentBudget wired together into a non-blocking, single-loop runtime.
  No GC, no green threads, no hidden allocations on the hot path.
• Streaming-first — SSE is decoded incrementally; every token reaches
  on_text the moment it leaves the wire.
• Tool calls with confirmation — ships with a shell tool out of the
  box; the REPL prompts for confirmation before anything is executed, and
  a sidecar query watches long-running commands and can talk to them
  (stdin injection) if they stall.
• Token budget that self-calibrates — xAgentBudget estimates prompt
  size before each round, trims old turns under TruncateOldest, and
  learns a correction factor from the provider's real usage reports.
• Multi-model registry — one models.json declares every backend;
  /model <id> flips the active backend mid-conversation without tearing
  the agent down. Today every entry is "provider": "openai" (covers any
  OpenAI-compatible API); "provider": "anthropic" is planned.
• Layered memory (in design) — conversation · session · agent tiers,
  with JSONL persistence wired into each session. See
  docs/design/layered-memory.md.

Quick Start

# 1. Configure + build the app (cli/ is off by default)
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
      -DMOO_BUILD_APPS=ON -DX_BUILD_TESTS=OFF -DX_BUILD_BENCHMARKS=OFF
cmake --build build --parallel

# 2. First run scaffolds a models.json template into the data dir
#    (defaults to the current working directory; pass --data-dir to
#    point somewhere else, e.g. ~/.moo)
./build/cli/moo --data-dir ~/.moo
# moo will write ~/.moo/models.json on first launch, then exit with a
# "please configure me" hint. Edit the file in place.

The scaffolded models.json looks like this — fill in the angle-bracket
placeholders to enable chat:

{
  "default": "kimi",
  "max_turns": 64,
  "budget": { "context_window": 8192 },
  "models": [
    { "id": "kimi", "provider": "openai",
      "model": "kimi-k2.6",
      "api_key": "<your-api-key>",
      "base_url": "https://api.moonshot.cn/v1",
      "budget": { "context_window": 131072 } },
    { "id": "glm",  "provider": "openai",
      "model": "glm-4.5",
      "api_key": "<your-api-key>",
      "base_url": "https://open.bigmodel.cn/api/paas/v4",
      "budget": { "context_window": 131072 } }
  ]
}

Run again once models.json is filled in:

./build/cli/moo --data-dir ~/.moo

Inside the REPL, slash commands are available:

Tab completes slash commands. Ctrl-R is a reverse-search over history.
Ctrl-C cancels an in-flight run without killing the REPL.

Here's what a session looks like:

Architecture

                     ┌─────────────────────────┐
                     │   cli  (the `moo`      │
                     │         REPL)           │
                     └────────────┬────────────┘
                                  │
                     ┌────────────▼────────────┐
                     │   xagent — the agent    │ ← the core
                     │  agent / session /      │
                     │  query / tool / budget  │
                     │  provider(openai)       │
                     └────────────┬────────────┘
                                  │
  ┌─────────┬─────────┬───────────┴────────┬─────────┬─────────┬─────────┐
  │ xbase   │ xbuf    │ xnet / xhttp       │ xline   │ xlog    │ xtui    │
  │ loop,   │ linear, │ DNS, TCP, TLS,     │ CJK-    │ async   │ stream  │
  │ timer,  │ ring,   │ HTTP/1.1, HTTP/2,  │ aware   │ MPSC    │ md →    │
  │ task,   │ chain   │ SSE, WebSocket     │ line    │ logger  │ ANSI    │
  │ atomic… │ bufs    │                    │ editor  │         │         │
  └─────────┴─────────┴────────────────────┴─────────┴─────────┴─────────┘

   plus xcrypto (hashes/HMAC), xjs (QuickJS-ng), xp2p / xfer
   (WebRTC + DataChannel file transfer) — supporting infra.

The agent (libx/x/agent)

See libx/x/agent/agent.h for the entry point, and
docs/design/ for the design notes
(context budget, layered memory, three-layer conversation model).

The foundation libraries

Everything in libx/x/ outside agent/ is shared, reusable, and independently
testable — you can link any of them into your own C project without
pulling in the agent.

libx++/xpp/ is an optional C++14 RAII layer over libx — Own<T>,
NonNull<T>, Option<T>, Result<T, E>, and a few thin wrappers around
the C event/timer/task primitives. The C side stands on its own; pull in
libx++ only if you want the C++ ergonomics. See
libx++/xpp/.

Prerequisites

Transitive deps (libcurl, llhttp, nghttp2, cJSON, usrsctp, QuickJS-ng,
libuv for benches, GoogleTest, Google Benchmark) are fetched via CMake
FetchContent when not found on the system — no manual setup required
for a first build.

Build

# Everything, Debug, with tests
cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build --parallel

# App only, Release
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release \
      -DMOO_BUILD_APPS=ON -DX_BUILD_TESTS=OFF -DX_BUILD_BENCHMARKS=OFF
cmake --build build --parallel

Useful options:

Test

Local (macOS / Linux)

ctest --test-dir build --output-on-failure --parallel 4

To test both TLS backends in one session, configure two build dirs and
run ctest in each:

cmake -S . -B build-openssl -DX_TLS_BACKEND=openssl && \
  cmake --build build-openssl --parallel && \
  ctest --test-dir build-openssl --output-on-failure --parallel 4

cmake -S . -B build-mbedtls -DX_TLS_BACKEND=mbedtls && \
  cmake --build build-mbedtls --parallel && \
  ctest --test-dir build-mbedtls --output-on-failure --parallel 4

Affected-modules workflow

For a faster local iteration loop, the test scripts diff against a base
ref (default origin/main) and run only the tests for changed libx
modules and their dependents:

./scripts/test-mac.sh                    # macOS, openssl, vs origin/main
./scripts/test-mac.sh -t mbedtls --all   # force-test every module, mbedTLS
./scripts/test-linux.sh --ci --base-sha <SHA>   # CI mode, native Linux

Pass --detect-only to print just the affected module names without
building or running anything.

Linux via container (macOS host)

Requires macOS 26+ with
Apple Containerization:

brew install container
container system start
./scripts/test-linux.sh            # default: gcc:14, Debug, -j2
./scripts/test-linux.sh -j4 -m 4G  # custom parallelism / memory

Benchmark

See the benchmark pages for micro-benchmarks of the
foundation libraries and end-to-end HTTP server numbers.

License

MIT © 2025-present @mivinci and moo contributors