Codewhale Is the Rust Coding Agent That Gives You Every Model and Every Line of Code
I've tried a lot of coding agents lately. Most of them lock you into one model, one vendor, and one way of working. Claude Code wants you on Claude. Copilot wants you on GitHub. Cursor wants you in their editor. Codewha
I've tried a lot of coding agents lately. Most of them lock you into one model, one vendor, and one way of working. Claude Code wants you on Claude. Copilot wants you on GitHub. Cursor wants you in their editor.
Codewhale is different. It's an open-source coding agent for your terminal, written in Rust, that works with any model and lets you read every line of its source. I spent a week with it. Here's what I found.
What Codewhale actually is
Codewhale is a terminal coding agent under the MIT license. You give it a task, it reads your repository, edits files, and runs commands until the job is done or it needs your input. That's the standard agent loop.
What makes it interesting is the flexibility. More than 40 providers are built in, including Anthropic, OpenAI, DeepSeek, Google, Mistral, Moonshot, OpenRouter, and xAI. Any OpenAI-compatible endpoint works. Local models through Ollama, vLLM, or SGLang work too. You can switch models between turns.
The site claims 50 provider routes and 91 models. That's more choice than any other agent I've used. And it runs with no account. You install it, point it at a repo, and start working.
The terminal UI is built with Ratatui, the Rust TUI library. That matters because it makes the interface fast and responsive, even on large repositories.
The feature that changed my workflow
The standout feature is the Fleet. Codewhale can split one task across several agents, each with its own role and model. That's a different mental model from a single assistant.
I tested it on a refactor that touched a Python service and its tests. I configured a Fleet with three roles: a planner using a strong reasoning model, an implementer using a fast coding model, and a reviewer using a different provider entirely.
The planner broke the task into steps. The implementer worked through them. The reviewer checked each change against the repo's AGENTS.md rules. When the reviewer found a missing type hint, it sent the change back to the implementer with specific feedback.
That loop ran while I made coffee. When I came back, the diff was clean and the tests passed. I didn't have to manage the handoffs manually.
The /goal command sets an objective that carries across turns. That's useful for long-running work where you want the agent to stay focused on the end state rather than the immediate next step.
Approval rules and receipts
Here's something the agent tools don't talk about enough: trust. When an agent runs commands on your machine, you need to know what it did and why.
Codewhale keeps approvals and receipts in your hands. Every tool call still meets your approval rules. Each call leaves a receipt. You can see exactly what the agent tried to do, what you approved, and what happened.
That's the kind of transparency that should be standard in every agent. Most tools treat the approval gate as a checkbox. Codewhale treats it as a record.
Code mode is experimental and on by default. It lets the model write one execute_tools program that calls several MCP and plugin tools at once. Each call still goes through approval rules. Each call keeps its receipt. That's a clever way to reduce round trips without giving up control.
MCP servers, skills, plugins, and hooks on session and tool events all work. The plugin marketplace has first-party plugins and skills that install into Codewhale.
Where it still frays
The desktop app is in development with no public download yet. Cloud computers are invite-only. The promise of one session that follows you from terminal to desktop to browser to cloud is being built, not shipped.
That's fine. The terminal app and local browser client are released and work today. codewhale web lets you read the conversation, send a task, and answer approvals in your browser on your own machine. No account needed.
The learning curve for Fleets is real. Configuring three agents with different roles and models takes thought. If you give two agents overlapping responsibilities, they can produce conflicting changes. You have to design the Fleet the way you'd design a team.
And like every agent, Codewhale is only as good as the model you put behind it. The flexibility is there. Your judgment still matters.
The local browser client
One feature I didn't expect to use as much as I did is codewhale web. It starts a local browser client that lets you read the conversation, send a task, and answer approvals in your browser.
It comes with the terminal install. No account, no cloud service, no signup. It's running on your own machine.
That turned out to be useful for reviewing long diffs. The terminal is great for writing code, but reading a multi-file change in a browser is easier. I'd start a task in the terminal, then open the browser client to review what the agent had done and approve the next step.
How it compares
Against Claude Code, Codewhale trades polish for freedom. Claude Code is more refined and deeply tuned to Anthropic's models. Codewhale gives you any model you want and a transparent source tree. If you only use Claude, Claude Code is the smoother ride. If you mix providers or run local models, Codewhale wins.
Against OpenCode, the difference is the multi-agent Fleet system and the approval receipts. OpenCode is more mature and has a bigger community. Codewhale is newer, faster in the terminal thanks to Rust, and more explicit about agent roles. Both are worth trying.
Against Ante, which is also a single Rust binary, Codewhale is more configurable and less locked to one path. Ante is simpler. Codewhale is more powerful.
What the Rust choice buys you
Codewhale is written in Rust, and that shows in the terminal experience. Startup is instant. The TUI never stutters, even while an agent is streaming output and running commands in the background.
Memory use is low. On a long session with multiple Fleet agents active, I never saw the process balloon the way some Node-based agents do. The Ratatui component library that powers the UI is also available as a separate crate, so you can build your own terminal tools on the same foundation.
None of that matters if the agent writes bad code. But when two tools are otherwise similar, the one that feels snappy in the terminal is the one you reach for.
The model flexibility in practice
I ran the same task through three different models on Codewhale: a cloud model from Anthropic, a cheap model from DeepSeek, and a local model through Ollama.
The cloud model produced the cleanest code. The cheap model was fast and good enough for boilerplate. The local model was slower and needed more hand-holding, but it never sent a byte of my code off the machine.
Being able to switch between those in one tool, sometimes within the same session, is the whole point. You pick the model for the task instead of reshaping the task for the model.
Who this is for
If you're a developer who cares about vendor independence, local models, and being able to read the source of the tool you use every day, Codewhale belongs on your shortlist.
If you run a team that wants different models for different roles, the Fleet system is worth exploring. Planning with a strong model, implementing with a fast one, and reviewing with a third is a practical pattern.
If you just want one agent that works well out of the box and you're happy with a single vendor, this is more flexibility than you need. That's fine. Not every tool has to be for everyone.
Why this matters
The coding agent market is splitting into two camps. Closed tools that own the whole stack, and open tools that let you bring your own model and read the source.
Codewhale is firmly in the second camp. The tagline says it best: "The model can be anyone's. The agent should be yours."
That matters for developers who care about vendor independence, local models, and being able to audit what their tools do. It also matters for teams that want to run different models for different tasks without juggling five separate tools.
If you're happy with a single closed agent, you don't need Codewhale. But if you want an agent that works with the model you choose, splits work across a team of agents, and shows you every line of code, it's worth a look.
Have you tried multi-agent workflows, or do you still prefer one agent handling the whole task? Drop a comment. I'll read every single one.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes β full credit and traffic to the original publisher.
