cos0 · ada-agent v0.15.0

cos0 — a coding agent
built from zero.

A terminal client in the spirit of pi / Codex / Cursor. Holds every provider key on one backend, speaks one wire format, and normalizes the whole model zoo back to it.

cos 0 = 1 — every provider reduces to one protocol.

MIT · Node ≥ 18 · no build step

→ to advance

The thesis

One wire format. Every model, every provider.

The client talks only OpenAI Chat Completions to the backend.
The backend routes each request by model id and normalizes every provider back to that format.
Keys, auth, rate limits and billing live in one control point — the server.
The client carries nothing but a single ada key. Same shape as Cursor.

Architecture

Two programs, one protocol.

ada client

agentic loop
tools · sessions
TUI + approval

→HTTP / SSE←

ada backend

auth (client key)
router: id → provider
adapter per wire format

→upstreams←

providers

OpenAI · Anthropic
Gemini · Mistral · Grok
Qwen · Cloudflare · Ollama · OpenRouter

Adapters keyed by wire format — not provider

New model? Zero code. New provider? Two lines.

new model

0 code — routing is by id, nothing to add.

OpenAI-compatible provider

2 lines — base URL + key env in config.ts.

brand-new wire format

1 adapter + one registry line. Only Anthropic needs it today.

vendor SDKs

loaded lazily — @anthropic-ai/sdk never loads unless a Claude request arrives.

The engine

Stream → call tools → feed back → repeat, until done.

Each turn streams the model's reply; tool calls are gated by the permission mode, run, and appended as tool turns.
read/write/edit_file · apply_patch · bash in a real PTY · grep/glob · web · lsp_diagnostics · ask_user
Auto-format on edit (prettier / gofmt / ruff / shfmt) in trusted projects.
Ollama leaked a tool call as JSON text? Detected and run anyway.

Safety

Three modes. Every approval in plain words.

/ask · default

Each gated tool prompts — “ada wants to run a shell command…” — and one key answers: [y]es · [a]uto · [p]lan · [n]o.

/plan · read-only

ada plans but won't edit. /run approves and executes.

/auto · free run

Tools run without asking; destructive bash still confirms.

protected paths

Undo reverts the agent's edits; snapshots capture the whole tree.

Skills

~285 skills that actually fire.

Bundled SKILL.md instructions across ~30 categories — loaded only when a task needs them.
A relevance router ranks every request: a clear match is auto-applied (↳ skill: commit); ambiguous ones are suggested.
Browse with list_skills, rank with find_skill, load with use_skill.
Add your own under .ada/skills/<name>/ — front-matter is all it takes. Project overrides global overrides built-in.

Trust

Nothing is ever lost.

sessions

Every turn persisted as append-only JSONL; --continue / --resume picks up where you left off.

undo

/undo reverts the agent's edits; checkpoints make it surgical.

snapshots

/snapshot + /restore capture the whole workspace tree.

compaction

Old turns are summarized automatically as context grows — /compact forces it, /context shows the estimate.

Measured against Claude Code

Half the tokens. A third less spent.

444k 893k

tokens vs Claude Code — same machine, same model (Opus 4.7), same prompts, matched worktrees.

$3.05 $4.68

cost across five repo tasks — cheaper on 4 of 5. Full write-up in docs/product-report.

Benchmarks

Runs SWE-bench Verified for real.

Generates patches for actual GitHub issues — one isolated repo clone per task.
Emits official-format predictions.jsonl scored by the official swebench Docker harness.
node bench/swebench.mjs --dataset … --model … --out runs/x
Offline checks too: npm run selfcheck — tools, sessions, routing, parsers, TUI.

Enterprise control plane

Your org, one backend.

seats & policy

Per-user seat keys; server-enforced model allowlist + tool rules pushed to every client.

metering & audit

Per-user usage metering and an append-only audit log. File-backed, self-hosted in your network.

OIDC SSO

Okta, Entra, Auth0, Keycloak, Google Workspace. JIT-provisioned seats; offboarding is immediate.

fail-closed

Stdlib-only RS256/JWKS verification, no new dependency — a bad token is a denied request.

Deploy

Ship it anywhere.

docker compose up runs the backend; clients point at it with ADA_BACKEND_URL.
Cloudflare Workers AI (@cf/*) or an AI Gateway — zero code change.
No build step: TypeScript runs straight through tsx; one native dep (node-pty).
Sign in with GitHub or Google (RFC 8628 device flow) — zero client config, no password ever reaches ada.

Extensible

Built to be built on.

MCP connectors

stdio and HTTP servers — filesystem, github, postgres, slack, sentry… tools appear as server__tool.

HTTP API + SDK

ada serve — one-shot and Cursor-style streaming sessions with approval gating; typed SDK included.

ACP bridge

ada acp plugs the agent into editors; ada share publishes a session view.

agents & strategies

Named agents, subagents, worktrees, and orchestrators: react · single · plan · multi · toolsmith.

cos0 · the takeaway

cos 0 = 1

One wire format. One control point. One key per client.

A new model is zero code; a new OpenAI-compatible provider is two lines.
Keys stay on the server; ~285 skills stay on tap; nothing you do is ever lost.
Measured leaner than Claude Code — fewer tokens, less money, same model.
→ npm i -g ada-agent · clone & npm start · docs/ for the details

cos0 — a coding agentbuilt from zero.