Open source terminal coding agent

The complete coding agent
for your terminal.

Autopilot, a decision system for screening and reranking, built-in token savings, background subagents and shell calls, a learner with memory, nudges that keep small and flagship models on track, and code mode. Everything else a modern coding agent should have comes with them, designed together in one native binary.

Platform
curl -fsSL https://caudra.ai/install.sh | sh
irm https://caudra.ai/install.ps1 | iex
brew install caudra/tap/caudra

Then run caudra in a repository. It opens in Plan mode and writes only its plan until you approve.

Caudra after the fix. The shell card shows the git diff of src/pagination.ts, where line 29 now returns a cursor only when more rows remain. Below it, all three todos are done. The reply names the root cause at src/pagination.ts:29 and the single-page regression test that the background task added at src/pagination.test.ts:14, and reports make check passed: 8 tests, 0 failures.

Terminal recording · From bug report to passing testsA real session in the demo project, whose AGENTS.md asks for background tasks and one final make check. One prompt asks for the fix and a test. A subagent writes the test in the background while the main agent fixes the code, and make check runs after your approval. The workbench then shows the diff.Open in the gallery

Leave a session working toward a goal while you are away, and read what autopilot decided when you come back. At the keyboard, steer any subagent while it works.

See every recording in the gallery

Measured by Caudra's creator in daily use

  • 40B+tokens a month through Caudra
  • <4 GBfor over a month of complete local history
  • <1 sto load or save a 10k-message session, subagents included
  • ~97%Anthropic prompt-cache hit rate, and about 94% on OpenAI
How these were measured

01When you step away

Step away.
Autopilot keeps it moving.

Autopilot answers what would otherwise wait for you, so a session keeps working toward its goal while you are away. A completion goal decides when the work is done, and your permission rules still decide what may run.

The Autopilot panel on its Log tab. Engagement 1 ended with goal met, and its one entry reads permission allow, shell: make check, with the reason that the user wants make check to pass with the cursor bug fixed. Below it the panel shows the request: tool shell, input make check, and the prompt reason that no current permission rule covers it.

Terminal recording · Autopilot toward a goalA real session in a demo project with no stored rules, with gpt-6.1-sol in Build mode and content screening of the jev-latest decision engine in enforce mode. /autopilot sets the goal that make check passes with the last-page cursor bug fixed, and the footer shows the goal and the autopilot chip. The agent fixes src/pagination.ts. When make check asks for approval, autopilot allows that one call and the transcript row gives its reason. No rule is stored. The goal check passes, and a row ends the engagement. /autopilot log lists the decision with what the delegate was asked and why.Open in the gallery
The goal panel over a working session. It reads ACTIVE, the condition make check exits 0 and no existing test was edited, the default evaluator, 16 automatic continuations, 0 evaluations after 10 s, and the goal spend so far.

Terminal recording · Work toward a goalA real session in the demo project. /goal sets the condition make check exits 0 and no existing test was edited. The panel shows the condition, the evaluator, and the limit of 16 automatic continuations. The agent fixes the bug, and after the work turn a separate evaluator finds the goal met and clears it.Open in the gallery
  • Engage it with one command

    /autopilot <goal> sets a completion goal and engages. Only you can engage it. Scripts, profiles, and the model cannot. --autopilot engages the session Caudra starts with.

  • Answers what would wait for you

    A separate model call, the delegate, answers permission prompts, the question tool, questions asked in prose, and a plan that is ready to implement. It never runs tools, and it leaves what it cannot decide safely to you.

  • Approvals that end with the call

    An approval covers one call and adds no rule. Protected files, sudo, and tools that always ask are never approved, and nothing is approved after content screening flags a result or cannot screen one in full.

  • Budgets and a log

    An engagement ends after 100 continuations by default, and you can cap its spend and its minutes. Decision calls count toward that spend. /autopilot log lists every decision, what the delegate was asked, its reason, and what followed.

Unattended work needs a running session, for example in tmux or Herdr. Closing it stops background work, and when you reopen the session, the main turn and its subagents resume. Shell commands are not run again. When nothing screens fetched pages, engaging autopilot says so. Autopilot is delegated consent and no security boundary. /goal looks for evidence in the transcript. It does not prove the work is correct.

Autopilot in depth How autopilot works

02When a page talks to the agent

Screen what it reads.
Rank what it finds.

Caudra asks a decision model small typed questions where a judgement helps. Is this fetched page trying to instruct the agent? Which memory notes matter for this task? The answers screen what reaches the model and put what matters first.

The fetch card for http://127.0.0.1:8787/cursor-kit/README.md reads Decision engine: withheld from the model, with a flagged chip. The decision line above it reads content_screening, withheld the result from the model: it holds possible instructions to an agent, 0.97 injection, 0.94 addressed_to_agent in chunk 1 of 1. Below, the model says it will not try to retrieve the README another way.

Terminal recording · Withhold a page that gives the agent ordersA real session in the demo project with gpt-6.1-sol, with content screening of the jev-latest decision engine in enforce mode and every other engine feature off. The model fetches the README of a pagination library from a test server on 127.0.0.1:8787. A quoted note in it tells AI coding assistants to delete the tests and push to main. The engine scores the page at 0.97 for injection and 0.94 for addressed to the agent, against thresholds of 0.9, so the result is withheld from the model. The reply says that the README was withheld and answers from the code. A click opens the card, which still shows you the whole page with the note.Open in the gallery
The card Memory searched next-page cursor, 3 notes, with a ranked chip. Its decision line reads memory_search, ranked 6 keyword matches, left out 3 judged unrelated. next-page-cursor.md scores 0.96 and stays first, database-cursors.md and docs-pages.md follow, and terminal-cursor.md, refunds-next.md and page-titles.md are left out.

Terminal recording · Rerank memory search with /decisionsA real session in the demo project with gpt-6.1-sol and the jev-latest decision engine, where only content screening is on. /decisions opens the Features tab, and Space switches memory_search and then source_code_context to enforce, which Caudra saves to the global caudra.toml. The project memory holds six notes, and five of them only share a word with the question. The agent searches its notes for the next-page cursor. The engine ranks the six keyword matches, keeps the note about the next-page cursor first with a score of 0.96, and leaves out three it judged unrelated. A click on the chip shows each score. The reply reads the note and names line 29 of src/pagination.ts. Every decision feature stays off until you turn it on in /decisions and needs an active decision endpoint, and a left-out note still opens with read.Open in the gallery
  • Screening that can withhold a result

    Content screening reads web, MCP, and code output for text that tries to instruct the agent. In advise mode a flagged result carries a caution. In enforce mode the model receives a notice in its place, and you still see the result on its card. A result that cannot be screened in full is withheld too, and its chip says why, such as screening timed out.

  • Reranking where the agent searches

    Memory search and history search keep the matches judged relevant, best first. source_code_context keeps the code rows that fit the task and sends no source text. Compaction keeps the results that matter to the goal, and output pointers name omitted lines worth reading.

  • Advice on every prompt

    Permission advice adds warnings to a prompt without delaying it. Auto mode turns a flagged call into a prompt, and autopilot approves nothing while screening restricts the session.

  • One endpoint you choose

    Add TypeSafe Jev, OpenAI Luna, or a server of your own in /login, and switch it in /model. A local server on a loopback address needs no key.

Every feature is off until you turn it on in /decisions, and each needs an active decision endpoint. shadow mode only collects predictions. The transcript shows what each feature changed, and a decision about a tool call shows on its card. Predictions add to deterministic permission rules and can miss risks. enforce never grants a permission, and redaction of what is sent is best effort.

Decisions and reranking in depth Decision endpoints

03When the token bill arrives

Token savings,
built in.

Every turn re-sends the conversation, so a noisy result costs tokens again on every later turn until compaction. Caudra keeps results small and round-trips few, starting with RTK-style shell output filtering that is on by default.

Caudra after make check failed. The shell card footer reads filtered, make, progress, 36% smaller, click for raw. Below it, the reply reports 4 passed and 3 failed and starts a table of failing tests at src/orders.test.ts:16 and src/pagination.test.ts:21.

Terminal recording · Filter shell outputA real session in the demo project. make check fails three tests, and the make and progress stages make its output 36% smaller for this command. The reply names each failure, and one click shows the raw output.Open in the gallery
  • RTK-style output filtering

    Command-aware rules, most of them from RTK, trim build and test noise before the model reads the output, and a filtered result is always smaller than the raw one. A failure is never reported as a success, and a failing command keeps its first and last lines. Progress bars collapse to one row, and you can switch between filtered and raw views.

  • Structure before content

    file_index returns a file outline with signatures and line numbers. The source_code_* tools rank the symbols a task touches and show callers, call sites, and the tests they can trace to a change. They parse the source on the fly, so there is no index to build or maintain and nothing to configure.

  • Fewer, smaller turns

    Oversized results reach the model as a bounded head and tail, and tool_output searches the rest. batch runs independent calls in one turn, and subagents keep their exploration out of the main context.

  • A prompt cache that holds

    MCP servers are reached through code mode, so a server that connects or changes its tools never changes the tool definitions. Caudra sends a per-conversation cache key where providers accept one, and /usage scores the cache hit rate for every model.

04When work takes a while

Work in the background.
Steer it while it runs.

Subagents and long shell commands keep running while the main agent moves on, and their reports wake it when they finish. The input stays open the whole time, so you can queue the next task, guide the current run, or open any subagent and steer it.

The chat of a running subagent. It has patched src/pagination.test.ts with a test named "an empty listing has no items or next cursor" and starts its report. Below it, your guidance, Call the new test "returns no cursor for an empty listing", waits in the queue of the task until the subagent reads it.

Terminal recording · Guide a running subagentA real session in the demo project, whose AGENTS.md asks for background tasks and one final make check. You guide the running subagent from its own chat, add guidance to the main run, and queue make check for after the run. The subagent renames its test as guided. The main run ends with its own make check, and the queued prompt then runs make check a second time. Both pass 8 tests.Open in the gallery
The chat of the task List failing Bun tests. Its brief reads In /tmp/caudra-demo/orders run bun test and list the failing tests with concise failure details and exit status. Do not edit any files. Run no other commands. Below it, the subagent is writing its first command, bun test.

Terminal recording · Work starts while the model writesA real session in the demo project. One reply asks for a grep, a read, and a background task. The grep and the read finish while the model is still writing the task brief, and the task chat opens before the brief is complete. The subagent runs bun test and reports the three failing tests.Open in the gallery
  • Subagents in the background

    A task can run in the background while the main agent works on a separate part. Its report starts the next step at a safe boundary, with no polling.

  • Shell calls in the background

    A shell command waits up to 10 minutes. A command still running then moves to the background without a restart, and the agent gets the output so far. The model can also start a server or a long build in the background at once. /shells lists each command with an ETA learned on your machine.

  • Guide a subagent directly

    Open a running subagent from /tasks and type. Your guidance stays visible until the subagent reads it at its next turn boundary. When the subagent is heading the wrong way, Ctrl+X x replaces its current turn with your message.

  • Switch models while work runs

    /model and /thinking act on the chat on screen, including a running or finished task. The request in flight finishes first. A request that waits for a retry, a rate limit, or a spent account goes out at once on the new model.

05When you repeat yourself

Say it once.
Caudra writes it down.

When you correct the agent, cut an answer off, refuse a call, or repeat a preference, a background learner notices. It checks each finding against the project's history and writes what will still hold into your instruction files and project memory, so later sessions start out knowing it.

The Learning modal after a run of openai/gpt-6.1-sol. Its summary says that repeated corrections establish that final-page responses must include nextCursor: null. Below it, a change to /tmp/caudra-demo/orders/AGENTS.md with 2 refs adds the line: Preserve the pagination response shape: the final page, including an empty listing, must include nextCursor: null, never omit the field. The status bar reads Learned: project instructions.

Terminal recording · Review what Caudra learnedA real session in the demo project, whose earlier recorded sessions include the guidance "Keep nextCursor null on the last page rather than leaving the field out". /learn shows that the project has no learning runs yet, and n starts one now. Its transcript opens live: the learner, on the Learn job, which follows the chat model, reads a digest of the project history, checks the guidance in it, and reports one convention. The list then shows the line Caudra wrote into the learned block of AGENTS.md, with its two history references. u reverts the change, and AGENTS.md is unchanged again.Open in the gallery
The Memory inspector in This session mode: 7 entries, 6 lines, 0.9 of 32 KiB. Six notes sit in the view, and below the divider for entries written since the view was taken, entry 6+1 fixtures-seed.md is marked written here. The detail pane shows its text: scripts/seed.ts writes fixtures/orders.json, so make fixture changes in the seed script.

Terminal recording · A note for later sessionsA real session in the demo project with gpt-6.1-sol, where the project memory already holds six notes. Asked to remember that scripts/seed.ts writes fixtures/orders.json, the agent saves a note through the memory tool. /memory shows the view the model reads, 0.9 of 32 KiB, and in This session mode marks the new entry as written here, with its text and its place in the summary tree. After /new, a question about the test data opens the note, and the answer sends the change to scripts/seed.ts rather than the generated JSON.Open in the gallery
  • Evidence before it writes

    The learner is a read-only subagent that checks each finding against this project's past sessions. A line in the committed AGENTS.md needs evidence from at least two of them, and text that looks like a secret is refused.

  • Review and revert in /learn

    /learn lists each run with what it changed, what it dropped, and why. Open a run's transcript, revert one change, start a run now, or pause learning for the project.

  • Memory that outlasts the session

    The agent keeps notes on project gotchas and decisions outside your repository, and later sessions in the project start with those notes in view. Writes pass your permission checks, and reading needs no approval.

  • A view that stays small

    Older notes fold into a tree of one-line summaries that the Memory model writes in the background, so the view in each request stays within 32 KiB however many notes a project collects. The model opens a summary line when it bears on the task.

06When a local model stalls

Keep any model
on task.

Smaller local models such as Qwen3.8-27B need more help to finish a task. Caudra nudges the model when a turn stalls, gets cut off, loops, or stops after announcing work. The rules react to what a reply did, so the same defaults work well with flagship models.

The reply I will run make check now, followed by the dim row The turn ended on a statement of intent. The work it announced was not performed. Below it, the expanded text the model received, Carry out what you said you would do now, using tool calls, and the make check card with 4 pass and 3 fail.

Terminal recording · Nudge a turn that stopped earlyA real session in the demo project. The prompt asks for only the sentence I will run make check now, so the reply announces work and calls no tool. A dim row reports the nudge, a click shows the exact text the model received, and make check then runs under a project rule stored before the take.Open in the gallery
  • Nudges for stalled turns

    After an empty or cut-off reply, Caudra asks the model to continue. After “I will run the tests now” with no tool call, it asks for the work itself. The third identical tool call in a row is refused before it runs.

  • Hints when work goes in circles

    When the model repeats a tool cycle or an answer, or keeps making failed calls, a hint asks it to reconsider its approach. Hints stop at four per run by default and never reopen a finished answer.

  • Sensible defaults, tuned per model

    Every rule is on by default, and budgets cap how often each one fires. Change a threshold, a budget, or the wording of a nudge for all models, or only for one exact provider/model-id.

  • Every nudge in the transcript

    Each nudge appears as a dim row. Click it to read the exact text the model received.

07When a server ships 100 tools

Call every server
from one snippet.

The model reaches your MCP servers, your past conversations, and the decision engine by writing Python in one code tool. The tool definitions never change when a server connects, so the prompt cache holds, and a snippet returns only what the model needs to read.

The code card with a snippet that calls home.intent__HassTurnOff for five lights through asyncio.gather. Below it, each call is a child row, Turn off with the name of the light, marked action done with a check mark for Bed Light, Ceiling Lights, Entrance Color + White Lights, and Kitchen Lights.

Terminal recording · Call MCP servers from PythonA real session in the demo project, with Home Assistant and its demo integration running in a local container as an MCP server. /mcp lists the home server with 28 tools via code. The prompt asks to turn off every light except the living room and for the temperature of each climate device. The model writes Python in the code tool: one snippet reads the live context, and a second turns off five lights at once with asyncio.gather. Each server call passes the permission rules, so the take allows the read for the conversation, and the light calls with any arguments after a second Enter. The reply says that it left the living room lights on and shows a table of three climate devices. A question about the front door asks again, because Home Assistant lock devices always ask.Open in the gallery
The reply Defined and ran list_orders_pages(240) in the code tool, above a table of limit, nonempty pages, last nonempty page size, calls until a null cursor, and final page size. A limit of 7 gives 35 pages with 2 orders on the last and 36 calls, and every final page is empty. Below, the reply says that src/pagination.ts:29 returns a cursor for every nonempty page, including the last one, so following cursors until null takes one extra call that returns an empty page.

Terminal recording · Compute with PythonA real session in the demo project, in Plan mode. The prompt asks for a function that counts the pages listOrders returns at four limits, run for 240 orders. The model reads src/orders.ts and src/pagination.ts, defines list_orders_pages in the code tool, and shows a table: 35, 10, 5, and 3 pages. It also notes the extra call that returns an empty page. The follow-up asks for 1,000 orders, and the second snippet is one line, list_orders_pages(1000), because the function is still defined. The interpreter has no file system, network, or environment variables.Open in the gallery
  • One tool for every MCP server

    The model never sees an MCP tool definition. It calls your servers from Python, and a snippet can call several tools at once. A server that connects, fails, or changes its tools never changes the tool definitions or the system prompt.

  • Filter before the model reads

    A snippet can filter, join, and summarise results before the model reads anything. Only what it prints and the value of its last expression come back, so a list of 500 issues can come back as three lines.

  • Python in an isolated worker

    code runs snippets in a separate worker with no file system, network, environment variables, or subprocesses. A snippet that calls nothing outside the worker runs without a prompt, and each call it makes, such as a search of your past conversations, is checked on its own. timeoutSec bounds the whole run, waits included.

  • Judgement inside the snippet

    decisions.decide() and decisions.rerank() judge what a snippet gathered before any of it reaches the model.

Why Caudra exists

The last coding agent I needed to install.

I spend most of my working day with coding agents, and I have tried many of them. I kept adding plugins to get the features I wanted. Often I could not build the plugin I needed, because the agent had no hook in the place it needed one. A proper /goal mode was one of them. Keeping the plugins I did have up to date was work of its own.

So I built those features into the agent itself, where they can work together. Caudra is one binary I can install in a new environment with one command, and it works with small local models as well as flagship ones.

I push more than 40 billion tokens a month through it. With another agent, my local history grew by more than 2 GB a day. Caudra keeps over a month of my complete history in less than 4 GB, and a 10k-message session still loads in under a second.

Thorsten BornSoftware engineer and data architect, creator and maintainer of Caudra
Local history elsewhere
>2 GB a day
Local history in Caudra
<4 GB for over a month

Open-source credits

Caudra builds on ideas from these projects, with thanks.

MethodThese are the creator's own measurements from daily use, not benchmarks. Timings were measured by hand. Results depend on models, projects, and hardware.

Bring your models

Use the models
you already pay for.

First-class support for Anthropic and OpenAI, 17 built-in providers, local models through Ollama or llama.cpp, and custom endpoints that speak a supported API. New models and prices arrive in a signed model list, without a Caudra update.

Anthropic · OpenAI · Google · GitHub Copilot · xAI · Mistral · DeepSeek · OpenRouter · Z.AI · Ollama · llama.cpp

Models and setup in depth Several accounts per provider Providers and sign-in

Claude subscription sign-in is experimental. Anthropic's terms limit Pro and Max subscriptions to official clients.

Questions

Before you install

  • What does it cost?

    Caudra is free and open source under the Apache License 2.0. You pay your model provider, or nothing when you run a local model.

  • Which models can I use?

    Sign in with ChatGPT, GitHub Copilot, or xAI. Or use an API key with one of the 17 built-in providers, or a local model through Ollama or llama.cpp. Providers lists them all.

  • What leaves my machine?

    Your prompts go to the model provider you choose. Telemetry is off unless you send it to a collector you run. A normal run also checks models.caudra.ai for a signed model list and asks GitHub for a newer release, each at most once a day. It reaches Exa when the agent searches the web. Privacy has the details.

  • Can it break my repository?

    Caudra opens in Plan mode, where it writes only its plan until you approve. In Build mode, file edits inside the repository run freely, shell and web tools ask first, and deny rules always win. Caudra keeps a record of the file changes its tool calls make, so you can revert them from any message.

  • Where does it come from?

    Caudra is an independent fork of Maki by Tony Solomonik. It keeps Maki's native Rust core and adds completion goals, durable subagents, steering, revert, and the workbench. Changes from Maki lists the work in detail.

  • How stable is it?

    Caudra is in preview and releases often. When an upgrade changes the session database or a config file, it saves a backup first, and older releases may not read the upgraded files. Close other Caudra sessions before you start such a release, because the upgrade needs the database to itself. The release notes say what each upgrade changes.

  • Who builds it?

    Thorsten Born builds Caudra and uses it for his own work every day. Ask questions in GitHub Discussions and report bugs in Issues.

Your next working session

Try it on the repository
you have open.

Install Caudra on macOS, Linux, or Windows. The installer checks each download against the release SHA-256 manifest.

Platform
curl -fsSL https://caudra.ai/install.sh | sh
irm https://caudra.ai/install.ps1 | iex
brew install caudra/tap/caudra
  1. Run caudra auth login to sign in or add an API key.
  2. cd into a repository and run caudra.
  3. Describe the task. Caudra plans first, and Tab switches to Build mode when you are ready.