Skip to main content
Corbits Code is a coding agent that lives in your terminal. Describe a task in plain English and it reads the repository, writes the code, runs the tests, and drives the work to done, interrupting you only where an action is consequential enough to deserve it. It runs on the model you choose. Follow the first-run setup to connect a provider, including browser sign-in, an API key, or local Ollama; that guide keeps the complete provider catalog in one place. (provider setup source)
Corbits Code is built on the same Corbits/Interchange runtime primitives documented across the platform overview: the agent loop, inference, tools, and persistence. It is a consumer of those primitives rather than a rewrite of them, though it currently vendors the inference, types, and storage packages as source so it can track fixes ahead of their npm releases. Its guardrails, though, are layered by Corbits Code: a permission, secret, and authorization system enforced as tool middleware in its own process. They are not the control plane’s credentials and grants.

​
Get it running

Your first Corbits Code run

Install Corbits Code, connect a model, and put an agent to work in one of your repositories.
Add another provider whenever you like with /connect, or Alt+A from the /model picker. Alt+D sets which one is the default. Run without the terminal UI, for a script or for CI, with corbits exec "…". Exec prompts on stdin when it has a terminal to prompt to; when it does not, an action that would have asked is denied instead, so an unattended run fails closed rather than waiting on nobody. (headless execution; permission gate)

​
Why it finishes what it starts

Most coding agents stall. They re-read the same files, drift from their own plan, or go quiet without ever saying they are done. Corbits Code replaces the open-ended chat loop with a deterministic event loop: the Interchange reactor processes one event at a time and asks what happens next, and Corbits Code supplies the policy that answers. That policy is written in code, not buried in a prompt as a suggestion the model can talk itself out of. (event-loop policy)

No quiet half-finish

When the agent tries to end a turn with tasks still open, the policy rewrites that ending into another inference pass carrying a pointed reminder, up to three times, instead of letting a run stop half-done without saying so.

A checklist it has to hold

The agent tracks its work as a task list through a dedicated tool. That list lives in the reactor director’s own state rather than only in the chat transcript, so it survives context shifts across a long run. (event-loop policy)

Tool output stays addressable

The shared Interchange runtime spills oversized tool results to the session blob store and leaves a URI in their place. (tool-output size cap) Corbits Code separately makes those runtime URIs usable: it wires a blob reader into read_file and rejects them on tools that cannot resolve them. (blob URI reader; tool-output URI handling)

​
Pick up where you left off

Conversation context persists to a git-backed store, and run state (status, turns used, the task, the model, connected MCP servers) is snapshotted alongside it, with the task list coming back from the transcript on resume. Relaunch in the same repository and corbits resume offers a picker of recent sessions, completed ones included, so a Ctrl+C, a crash, or a walk away from the desk costs you nothing. (runtime configuration; session restoration; session picker)

​
Using Corbits Code

Steering and safety

Steer a Corbits Code run from the terminal, and see the permission, secret, and catastrophic-command guards it enforces at the tool layer.

The fleet

How Corbits Code dispatches specialist agents, enforces their authority tiers where tools are assembled, and lets you steer workers mid-run.

Configuration

Where Corbits Code keeps its settings and provider credentials, and how to choose a provider and model at launch.

Integrations

Extend Corbits Code with MCP servers, lifecycle hooks, plugins and skills, and slash commands.

Connect MCP servers

Add Linear over OAuth and Slack as a local process to Corbits Code, and confirm both are connected.
If you followed a link to a section from the previous Corbits Code overview, continue here:

​
Built on the platform

Corbits Code is the honest test of the platform. Everything the runtime provides, it composes. Everything it adds sits cleanly on top.
  • Agent loop: the event-driven reactor and agent lifecycle
  • Inference: the runtime’s inference primitive, run here over OpenAI-compatible sources and the native Anthropic Messages source
  • Tools: POSIX shell, file read/write/edit, grep, and search
  • Persistence: git-backed context and state storage for resume
The primitives that make Corbits Code fast, safe, and resumable are the ones the platform exposes to you, tracked here at Interchange’s own head rather than the last published release.

Platform overview

The runtime primitives Corbits Code is built on, and how they fit together.

Guardrails

The platform’s Credentials and Grants model: how the control plane keeps agents in bounds.

Workbench

The multiplayer workspace for humans and agents, where a team authors and runs its agents together.

Isolation

How agent workloads are kept apart from one another.

​
Support

Help Center

Join hundreds of developers building with Corbits and speak with the team directly.