Caudra

Stop assembling your coding agent.

Caudra arrives complete. Subagents you can steer, built-in token savings, a workbench, and a history you can revert were designed together, and they ship in one native binary. Install it with one command and bring the models you already pay for.

Leave a session working toward a goal while you are away. When you are at the keyboard, guide any subagent, ask a side question, or open the code beside the conversation.

curl -fsSL https://caudra.ai/install.sh | sh

Website · Documentation · Quick start · Gallery · Reference configs · Inspect the script

See it work

Each clip is a short excerpt of a real session, played at its original speed. Click a clip to watch the whole session on caudra.ai.

Guide a running subagent Open a running subagent's chat and type. It reads your guidance at its next turn while the main agent keeps working. Model: openai/gpt-6.1-sol · Queue and steering · Full session

Filter shell output Command-aware filters shrink shell output before the model reads it, with rules that mostly come from RTK. One click shows the raw output. Model: openai/gpt-6.1-sol · Shell · Full session

Revert files from a message Revert files first counts what it would create, replace, or delete. Choosing it again applies the revert, and Unrevert puts the files back. Model: openai/gpt-6.1-sol · File revert · Full session

The workbench beside a session Ctrl+X w opens source control, an editor, and project search while the session keeps running. Model: openai/gpt-6.1-sol · Workbench · Full session

Work toward a goal /goal keeps the session working until a separate evaluator finds your condition met. Model: openai/gpt-6.1-sol · Completion goals · Full session

A local model fixes the bug Qwen3.8-27B on ninfer-4090 uses the same tools and permission rules as a hosted model. Model: ninfer-4090/qwen3.8-27b · Custom providers · Full session

See every recording in the gallery

The parts know about each other.

Designed together

The core team builds, tests, and releases every capability together, so one feature can hand work to the next with no extra setup. You install one binary, with no third-party plugins to vet or keep up to date. Lua extensions remain an experimental option.

• Workbench → Prompt. Ctrl+X Enter sends the lines you selected to the composer as a mention such as @src/api.ts:L10-L20. How it works
• Shell → Transcript. The model reads the filtered output, and the footer switches you to the raw view. How it works
• You → Running subagent. Type into a running task's chat, and the subagent reads it at its next turn boundary. How it works
• Background work → /goal. The goal check waits until background tasks and shell commands settle. How it works
• Tool call → Revert. Each call that may change files is recorded, so a revert touches only the files those calls changed. How it works
• Every model → /usage. /usage shows what the session spent and scores the cache hit rate of each model. How it works

The last coding agent I needed to install.

Why Caudra exists

I spend most of my working day with coding agents, and I have tried many of them. Each had ideas I liked. I wanted those ideas together, along with a few new techniques, in one standalone binary I could bring into any environment.

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

Thorsten Born, software engineer and data architect, creator and maintainer of Caudra

Measured by Caudra's creator in daily use:

Figure	What it measures
20B+	tokens a month through Caudra
<2 GB	for over a month of complete local history
<1 s	to load or save a 10k-turn session, subagents included
~97%	Anthropic prompt-cache hit rate, and about 94% on OpenAI

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

Caudra builds on ideas from these projects, with thanks:

• RTK: shell output filtering
• ripwire: code maps
• Plannotator: passage review
• Herdr: terminal workspaces for agents

Guide any agent while it works.

When a subagent drifts

The input stays open while Caudra works. Queue the next task, add guidance to the current run, or replace it. Open any running subagent and guide it directly.

Key	What happens
Enter	Queues your prompt for after the current run. Queued prompts stay editable
Ctrl+X g	Adds your guidance to the current run before its next model request
Ctrl+X x	Stops the current run and starts yours
/tasks	Lists the subagents. Open a running one and type, and your guidance stays visible until it reads it at its next turn boundary

• Read a brief as it is written. A subagent's chat opens while the model is still writing its instructions, so you can read the task before it starts.
• Ask /btw on the side. Ask about the conversation without adding to its history. When the main agent asks you a question, F2 opens /btw to clarify the choices, and Esc returns to the unchanged form.

Queue and steering · Watch: Guide a running subagent, Clarify a question with /btw, Work starts while the model writes

Token savings, built in.

When the token bill arrives

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.

• 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.
• MCP servers through Python. The model reaches your MCP servers by writing Python in its one code tool. A snippet calls several tools at once and filters their results before the model reads anything, and a server that connects or changes its tools never changes the tool definitions, so the prompt cache holds.

Caudra sends a per-conversation cache key where providers accept one, and /usage scores the cache hit rate for every model. In the creator's daily use, about 97% of Anthropic and 94% of OpenAI prompt tokens came from cache. With credit to the ideas in RTK and ripwire.

How Caudra saves tokens · Watch: Filter shell output

Go back to any point in the work.

When a change goes wrong

Every session keeps its full history, subagent transcripts included, in compact local storage. Revert the conversation, the files, or both from a message, and preview the file changes first.

• Large sessions open fast. Payloads are compressed, appending saves write only new rows, and the transcript lays out only what is on screen. In the creator's use, a 10k-turn session loads in under a second.
• Revert with a preview. Each tool call that may change files is recorded before and after it runs, so a revert touches only those files. The first Revert files shows what would change, and repeating it applies the revert. Unrevert puts the files and the conversation back.
• Memory that outlasts the session. The agent keeps notes on project gotchas and decisions outside your repository. Older notes fold into one-line summaries, so the view in each request stays within 32 KiB. The model opens a summary or searches the notes when it needs more, and /memory shows what it reads.
• Fork and branch out. Fork from a message to try another approach. /worktree new moves a session into a fresh Git worktree with its conversation and plan.

File revert cannot undo external side effects such as running processes, databases, network calls, or Git branch state.

Sessions and revert · Watch: Revert files from a message

Open the code without leaving.

When you need to see the code

Ctrl+X w brings up a file explorer, tabbed editor, project search, and source control while the session keeps running. It lives in the terminal, so it comes along over SSH.

• Read the actual change. Inspect diffs, browse the commit graph, and stage, unstage, or discard per file or folder.
• Point at exact lines. Ctrl+X Enter sends the file, line, or selection to the composer as a mention such as @src/api.ts:L10-L20. Caudra puts those lines in the request.
• Review passages of a reply. Ctrl+X r opens passage review. Mark the parts of an answer that need work, add a note to each, and send every note back as one prompt.
• Replies rendered for engineers. Tables, highlighted code, Unicode maths, and Mermaid flowcharts render in the terminal. Copying a passage gives back its Markdown source.

Passage review was inspired by Plannotator.

Explore the workbench · Watch: The workbench beside a session, Review passages of a reply

Set the finish line. Wake to results.

When you step away

/goal keeps a session working until a separate evaluator finds evidence that your condition is met, for example "tests pass and clippy is clean". Background work reports back without polling, and your permission rules decide what runs while you are away.

• Goals that check evidence. After each work turn, a separate model call with no tools reads the transcript. An unmet goal starts another turn. A met goal clears itself. /goal log lists every check with its model, cost, and reason.
• Background work wakes the agent. Tasks and shell jobs can keep running in the background. Their reports start the next step at a safe boundary, with no polling.
• Permissions that read the command. Shell chains and pipelines split into separate commands for approval. Approve once, for the conversation, the project, or every project, and accept patterns Caudra suggests from repeated approvals.
• Plan first, then hear back. By default, new sessions open in Plan mode, where the agent edits only its plan and asks before commands it cannot prove read-only. Notifications tell you when a turn finishes or a prompt needs your answer.

Unattended work needs a running session, for example in tmux or Herdr. Closing it cancels background work. Experimental autopilot can answer permission prompts, questions, and ready plans while you are away, within budgets you set. Its log lists every decision and what followed. A goal allows 16 automatic continuations by default, and work pauses when it needs your answer. /goal looks for evidence in the transcript. It does not prove the work is correct.

Completion goals · Watch: Work toward a goal

Give every session its own tab.

When you run several sessions

Run Caudra inside Herdr or Orca, and the host knows what each session is doing. Caudra reports its state, names the tab after the session, and opens forks and worktrees in tabs of their own.

• Status where you look. The Herdr sidebar shows the state of each session with its title, model, and context usage. Orca shows the state on the tab. Both raise their own notice when a turn ends or a prompt waits, and name the prompt, such as Permission requested: shell.
• Tabs named after the session. Caudra renames a Herdr tab to the session title while the tab still shows its number, and a tab you named keeps its name. Orca shows the session title on the terminal tab.
• Forks open in a new tab. Fork here, in the message menu, starts the new session in a new Herdr or Orca tab with a Caudra of its own. The session you forked from stays open where it was.
• Worktrees in the host. /worktree new asks Herdr or Orca to create the worktree, and the session continues there. /worktree close brings its commits and changes back, and every open session returns in a tab of its own. After a Herdr restart, the focused session comes back in its pane.

Caudra detects each host from the variables the host sets in the terminal. Inside either one, the herdr or orca skill gives the agent the instructions of the installed release, and its commands still pass through your permission rules. Integrates with Herdr and Orca.

Herdr and Orca integration · Watch: Caudra inside Herdr

Keep any model on task.

When a local model stalls

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.

• 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. Under [agent.steering] in caudra.toml, 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.

# caudra.toml: more patience for one local model
[agent.steering.models."my-server/qwen3.8-27b".rules.abandoned_turn]
max_attempts = 4

In daily use, the abandoned_turn rule matched 35 of 386 final Qwen3.8-27B replies and none of 2,185 from Claude and GPT models, as measured by Caudra's creator. A nudge is a message to the model. It cannot run or approve a tool, and every real tool call still passes through validation and your permission rules.

Configure automatic steering · Watch: Nudge a turn that stopped early

Tools that say what they missed.

When a tool reaches a limit

When a tool stops at a limit or leaves something out, its result says what is missing, and the model can go back for it. The file, shell, web, code, and Python tools come from Workcell, which also runs on its own as an MCP server.

• Searches that report what they withheld. A file_grep or file_glob call that reaches its bounds returns what it found and reports how much it withheld, so the model can tell a missing match from a file it never searched. Directory searches skip credential files such as .env and SSH private keys.
• Guarded web fetching. webfetch refuses private, loopback, and link-local addresses and checks every redirect the same way. Pages arrive in the character set they declare, and a page cut at 2,000 lines or 50 KiB ends with a line that names the limit.
• PDFs as text or as the file. A fetched PDF arrives as its text. In attachment mode, a model that reads PDFs receives the file itself inside the tool result, within a quarter of its context window. Saved sessions keep only the URL, name, and page count.
• 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.

Attached PDFs reach Claude through Anthropic or Amazon Bedrock, and custom models on a compatible API that declare PDF support. Other models receive the extracted text with a line that says why.

Built-in tools · Watch: Search and fetch with stated limits

Caudra comes from caudate.

Why the name

Caudra, pronounced KAW-druh, is named after the caudate nucleus. This part of the brain belongs to the circuits that connect evidence and goals to action. Studies link it to learning which actions lead to which outcomes.

The name describes how Caudra works. It turns the context of your task into an action, then reads the outcome before it chooses the next one.

1. Context and intent
2. Evaluate evidence
3. Select an action
4. Execute with tools
5. Observe the outcome

Each outcome becomes evidence for the next step. The brain is only the inspiration for the name. Caudra is software, and it works toward the goal you set.

Sources: Grahn, Parkinson and Owen, 2008, Lau and Glimcher, 2007, Doi et al., 2020.

Use the models you already pay for.

Bring your models and your setup

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.

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

• ChatGPT. Sign in with your ChatGPT subscription.
• GitHub Copilot. Sign in with GitHub, or import an existing Copilot token.
• xAI. Sign in with your xAI account.
• Claude (experimental). Sign in with your Claude subscription.

Claude subscription sign-in is experimental. Anthropic's terms limit Pro and Max subscriptions to official clients. Every provider also accepts an API key. See Providers and sign-in.

Keep the setup you have

Caudra reads the instruction files and skills you already have and connects to your MCP servers, so trying it does not mean starting over.

• Instruction files. At session start, Caudra loads AGENTS.md, CLAUDE.md, .cursorrules, GEMINI.md, or one of six other instruction file names.
• Skills. Caudra reads skills from .claude/skills and .agents/skills folders.
• MCP servers. Add stdio or HTTP MCP servers in mcp.toml, with OAuth sign-in. The model calls them by writing Python in its code tool, and Caudra speaks the current MCP protocol and the older one.
• Scripts. --print writes the same JSON fields as Claude Code, so scripts that parse its output keep working.

A model for each job

Eleven jobs decide which model serves each kind of work. Pin a job to a model in /model, or let it follow Chat, Plan, Fast, or Best. A local endpoint can name its own Fast and Best models in providers.toml. For a single task, name the model in your prompt, as in “ask opus and sol to review this change”, and each gets a task of its own.

Job	What it serves
Chat	The main conversation. Picking a model in /model sets it.
Plan	Main turns in Plan mode, on the Chat model until you bind it.
Subagent	Delegated tasks, on the parent agent's model until you bind it.
Compact	Summaries when a context window fills.
Title	Session names, on Fast until you bind it.
Goal	The /goal evaluator, on Fast until you bind it.
Extract	Requirements for /extract and compaction, on Fast until you bind it.
Memory	One-line summaries of older memory notes, on the compaction model until you bind it.
Autopilot	Answers for experimental autopilot while you are away, on Best until you bind it.
Fast	The preferred small model, for routine calls.
Best	The provider's flagship. Point Plan or a prompt profile's subagents at it.

See Model jobs.

The JEV decision engine sends typed questions to one decision endpoint you pick: TypeSafe Jev, OpenAI Luna, or a server of your own. It powers permission advice, Auto mode screening, shell effect and duration predictions, sampled web and MCP content screening, tool search ranking, skill suggestions, goal prescreening, and subagent routing to the Fast or Best model. As a reranker, it can put the most relevant memory notes, code context rows, and omitted tool output first, and the transcript shows what each feature changed. Add an endpoint in /login and switch it in /model. Each feature is off until you turn it on, and predictions add to deterministic permission rules and can miss risks.

75 capabilities, designed together.

Everything in the box

Each one links to its documentation. Experimental items are marked and stay off until you switch them on.

Agents (14)

• Steerable subagents
• Background tasks and shell jobs
• Next, Guide, and Replace queue
• Completion goals with a log of every check
• Autopilot toward a goal (experimental)
• Side questions with /btw
• Questions you can answer later
• A model for each job
• Tasks on the model you name
• Favorite models in /model
• Automatic steering, tuned per model
• Requirements tracking with /extract
• Resume a stopped turn with /continue
• Durable workflows (experimental)

Tools (11)

• File read and search, with one editor per model
• File outlines with file_index
• Code maps for 37 languages and formats
• Shell with output filtering
• Python for computation, history search, and MCP
• Parallel calls with batch
• Retained output search
• Web search and fetch, with PDFs as text or as the file
• Image generation with a ChatGPT login
• Tool-call JSON repair
• Tools loaded on demand

Context (10)

• Instruction files with AGENTS.md
• Project memory with summaries
• Skills from .claude and .agents folders
• @file and #commit mentions
• Inspect with /context and /projection
• Compaction that keeps recent turns
• System prompt profiles
• Config edits apply while Caudra runs
• {env:NAME} secrets in global config
• The full manual offline in /docs

Sessions (11)

• Revert conversation, files, or both
• File changes recorded per call
• Forks from any message
• Forks in a new Herdr or Orca tab
• Tabs named after the session
• Git worktrees you open and close
• Retention policies and /storage
• Move sessions between directories
• Search past conversations from Python
• Spend by model and purpose in /usage
• Release notes after an update, with /changelog

Interface (8)

• Workbench with Git and search
• Passage review
• Markdown with maths and Mermaid
• Tool calls drawn as they stream
• Draft stash and command palette
• Paired light and dark themes
• Hover tooltips that explain controls
• Notifications in tmux, Herdr, and Orca

Safety (7)

• Parsed shell permissions
• Scoped approvals, down to a folder
• Patterns suggested from history
• Plan mode
• No tracking, opt-in telemetry
• Managed VM sandboxes (experimental)
• JEV decision engine (experimental)

Integrations (14)

• MCP code mode: the model calls your servers from Python
• MCP OAuth with client ID metadata documents
• MCP results drawn by type, with token estimates
• MCP server questions and @ resources
• ACP for Zed
• Headless runs for scripts and CI
• Claude Code compatible output
• Custom slash commands
• Herdr integration
• Orca integration
• Workcell tools, also a standalone MCP server
• Cross-session messaging (experimental)
• Lua extensions (experimental)
• Remote Workcell workspaces (experimental)

Switch on what you want to try.

Experimental lab

These capabilities are implemented and experimental. Each one is off by default and needs its switch under [experimental] in your global caudra.toml, which lives at ~/.config/caudra/caudra.toml, or at %APPDATA%\caudra\caudra.toml on Windows. A project's own settings cannot turn them on.

[experimental]
workflows = true

• Managed sandboxes (sandboxes). Move execution into a VM. Managed sandboxes run workspace tools in a separate VM. Model connections, provider credentials, and the conversation stay on your machine, so a compromised VM cannot read credentials it never received. Network policy allows listed domains and IP ranges, with TLS hostname checks or an inspecting proxy. File transfers between your machine and the VM go through a review. They require e2b-libvirt infrastructure that you or your operator run. Transferred files can still carry secrets. The separation reduces exposure and is no guarantee against compromise.
• Autopilot (autopilot). /autopilot <goal> hands permission prompts, questions, ready plans, and stalls to a separate delegate model until the goal is met, a budget runs out, or you stop it. The delegate approves a prompt once and adds no rule. It never approves prompts that plan mode raises, tools that always ask, or protected files and commands. It also runs headless with caudra -p --autopilot. A log lists every decision, what the delegate was asked, and what followed.
• Durable workflows (workflows). Scripts launch subagents in phases, keep a journal, and can pause and resume. Each agent call can name a model job, such as Fast for a wide pass and Best for the answer you read. Built-in workflows cover deep research, change review, and root-cause analysis. They are heavily inspired by Grok Build workflows and mostly compatible with them.
• Cross-session messaging (cross_session_messaging). Live sessions on one machine exchange messages, publish to topics, and share work through consumer groups.
• Lua extensions (lua_plugins). Add your own commands, tools, and interface behavior in Lua when the built-in workflow needs something specific.
• Remote Workcell (remote_workcell). Run workspace tools on a Workcell server while the conversation stays on your machine.

Your history stays on your machine.

Privacy

Sessions, retained output, and file change records are stored locally. Cloud models and network tools still receive what you send them.

• No tracking. Telemetry is off unless you send it to a collector you run.
• Offline with a local model. Use Ollama or llama.cpp without internet access, or point a providers.toml entry at ninfer-4090, a custom inference engine by Caudra's creator for Qwen3.8-27B on one RTX 4090. It serves a standard OpenAI-compatible endpoint that follows the official Responses API specification, so the entry sets protocol = "openai-responses" as it would for any such endpoint. Otherwise a normal run contacts your provider, refreshes the public models.dev catalog at most once a day, and reaches Exa when the agent searches the web.
• Commands start from a cleared environment. Shell commands receive only a short list of variables, such as PATH, HOME, and proxy settings, so API keys set for Caudra stay out of them. /env forwards the variables you choose, and a project .env or project config never supplies them.
• Private addresses refused. webfetch checks every URL and redirect before it connects, and refuses private, loopback, and link-local addresses.
• Update checks you can turn off. At startup, the interactive UI asks GitHub for a newer release at most once a day and shows a banner. GitHub receives your IP address and normal request metadata, but no session data or installed version. Caudra never installs an update by itself. Set ui.update_check = false or CAUDRA_ENABLE_UPDATE_CHECK=0 to stop the checks. See updating and release channels.

Try it on the repository you have open.

Your next working session

Install Caudra on macOS or Linux, sign in to a provider, and run caudra in your project.

Install

On macOS and Linux:

curl -fsSL https://caudra.ai/install.sh | sh

The first public release is Caudra 0.2 Preview (0.2.0-preview.1). The installer prefers a stable release and selects a preview only when no stable release exists. It verifies the archive checksum before installing. A failed release lookup stops installation rather than switching channels.

The script installs Caudra to ~/.local/bin. Set CAUDRA_INSTALL_DIR to choose another directory. If you would rather read the script first, download it, look it over, and run it yourself:

curl -fsSL https://caudra.ai/install.sh -o install.sh
less install.sh
sh install.sh

On Windows, in PowerShell:

irm https://caudra.ai/install.ps1 | iex

This installs to %LOCALAPPDATA%\caudra and adds it to your user PATH. In Git Bash, the shell script above works too.

With Nix:

nix run github:caudra/caudra

Prebuilt binaries for Linux and macOS on x86_64 and ARM64, and for Windows on x86_64, are on GitHub Releases. To build the main branch yourself:

cargo install --locked --git https://github.com/caudra/caudra.git caudra

A plain cargo install build has no worker for the code tool, the isolated Python tool, because only release builds, Nix, and make install from a checkout embed it. The other tools work as usual.

First steps

Connect a provider, then start Caudra in a repository:

caudra auth login
cd my-project
caudra

caudra auth login asks for a provider and a sign-in method. Inside Caudra, /login offers the same choices.

Caudra opens in Plan mode. There the agent reads and searches freely, writes nothing but its plan, and asks before any command it cannot prove read-only. When the plan looks right, press Tab to switch to Build mode. File edits inside the repository then run without asking. Shell commands and web tools still ask first, and you can remember each approval for the conversation or the project.

Instructions you already wrote for other agents carry over. Caudra reads AGENTS.md or CLAUDE.md from your repository and picks up skills from .claude and .agents folders.

A few more things to know on day one:

• F1 lists every key.
• /docs opens the whole manual inside Caudra, matched to the version you run.
• caudra --continue resumes the most recent session in the current directory.
• caudra --print runs non-interactively for scripts and CI and exits when done.
• caudra acp lets editors that speak the Agent Client Protocol, such as Zed, drive Caudra.

Documentation

The manual lives at caudra.ai/docs. The same pages ship inside the binary, so /docs works offline too. Good places to start:

• Quick start
• Queue and steering
• Automatic steering
• How Caudra saves tokens
• Workbench
• Sessions, forks, and revert
• Permissions
• Providers
• Changes from Maki

Reference configs lists every key of each config file with its default, and the gallery shows real sessions by topic.

Contributing

Caudra is under active development, and bug reports help a lot. Issues and pull requests are welcome on GitHub. Please read CONTRIBUTING.md before you start on a larger change.

Ask questions in Discussions, and see SUPPORT.md for where each kind of request goes. Everyone who takes part in the project follows the Code of Conduct.

Caudra is a Rust workspace, and the Makefile holds the everyday commands. It requires GNU Make, Bash, and Python 3. On Windows, use Git Bash with GNU Make installed separately. Python defaults to python3, overridable with make PYTHON=python <target>.

make check         # type-check the workspace
make lint          # clippy, with warnings as errors
make test          # the test suite
make ci            # most application CI checks
make install       # install from your checkout, Python worker included

Cargo-compiling targets build the Python worker automatically. make code-worker is an optional warmup. Pass extra flags with ARGS='...', such as make build ARGS='--release'. To sign in from a debug build, use make run ARGS='-- auth login'.

Canonical docs live in docs/content/, with navigation in docs/navigation.json and generated config examples in docs/examples/. The pages are compiled into the binary for /docs. The website is maintained separately and consumes these same sources. Application development and docs generation do not require JavaScript tooling.

Credits

Caudra was created by Thorsten Born, who develops and maintains it. It stands on the shoulders of Maki and has grown in its own direction since the fork. The repository keeps Maki's history and includes work by Maki contributors. Caudra is independently maintained and is not affiliated with or endorsed by the original project.

The projects whose ideas Caudra builds on are listed above. Caudra also adapts code from two projects:

• Most of Workcell's filter rules are copied from RTK under the Apache License 2.0.
• The built-in deep-research workflow is adapted from Grok Build under the Apache License 2.0.

The file, shell, web, code, and Python tools come from Workcell, released under the Apache License 2.0 and developed in this workspace under workcell/. The isolated Python tool runs on Monty by Pydantic.

License

Caudra's first-party work is licensed under the Apache License, Version 2.0 from this transition forward. Maki-derived code and prior MIT-licensed Caudra work retain their MIT terms. Third-party material retains its own MIT, Apache-2.0, or file-level license terms. NOTICE.md covers the prospective transition, attribution, and third-party exceptions.