Codebuff
Also known as: Codebuff AI, Freebuff
Open source terminal coding agent with a multi agent architecture (file picker, planner, editor, reviewer) that makes codebase aware multi file changes, plus an SDK and any model routing.
Codebuff is an open source, terminal native AI coding agent whose distinguishing idea is a multi agent architecture. Rather than asking one model to do everything, it coordinates specialized agents that each own a step: a file picker agent scans the codebase to understand its architecture and find relevant files, a planner agent decides which files change and in what order, an editor agent writes the code, and a reviewer agent checks the result. The pitch is that splitting the work this way gives better context, more accurate edits, and fewer errors than single model tools, especially on architectural, multi file changes. The project is MIT licensed with a public repository of around six thousand nine hundred stars.
Codebuff is built for wholesale changes across a codebase rather than single file autocomplete. It deeply reads project structure, dependencies, and patterns, applies surgical edits across many files from one prompt, and runs the project's tests to confirm nothing breaks, gating completion on those tests. It lives entirely in the terminal, installs through npm, and works with any tech stack. A project knowledge file gives the agents persistent context. The team also reports that Codebuff outscores Claude Code on its own evaluation suite across many tasks, a figure worth reading with the usual skepticism given it is self reported.
Two strengths stand out for developers. First, model flexibility: Codebuff runs any large language model through OpenRouter and can route different tasks or agents to GPT, Claude, DeepSeek, or others by complexity and budget, and it can run with locally hosted models for offline private work, so there is no vendor lock in. Second, extensibility: a TypeScript SDK lets teams embed Codebuff in their own applications and CI/CD, define custom tools, and build custom agents with specialized workflows, and it supports the Model Context Protocol for connecting external tools and data. Because it is open source and indexes code locally, source can stay on the developer's machine.
For onboarding, Codebuff offers Freebuff, a free, ad supported version with no subscription, credits, configuration, or API key, powered by strong open source models like DeepSeek, Kimi, and MiniMax and monetized through curated developer ads in the command line. It doubles as a funnel to the paid product. Codebuff's paid tiers are credit based and priced toward heavier task execution, with a first paid plan around one hundred dollars a month and power user capacity reaching up to five hundred dollars a month, well above the roughly twenty dollar anchor common to lighter coding assistants. The main caveats are that it is terminal only, custom agents require TypeScript, and its success rate still demands disciplined human review.
Vendor details
Canonical URL
https://www.codebuff.com
Category
Coding agent
Subcategory
Open source multi-agent terminal coding agent
Funding status
Independent. Codebuff (by CodebuffAI) is an open source project, MIT licensed, with a public repository of roughly 6,900 GitHub stars, alongside a commercial managed offering and a free ad supported version called Freebuff. Specific funding figures are not disclosed in available sources.
Company status
independent
Use cases & customers
Primary use cases
Target customers
Deployment options
Integrations
Calls shell, git, and test commands directly in the terminal, supports the Model Context Protocol for connecting external tools and data, and exposes a TypeScript SDK for embedding into applications and CI/CD with custom tool definitions. Model access is routed through OpenRouter, with support for local models.
In practice
You need a change touching many files, endpoints, and tests at once. Codebuff's agents map the codebase, make the edits from one prompt, and run your tests to verify nothing broke.
Your source code cannot leave your machine. Codebuff is open source, indexes your code locally, and can run with locally hosted models, so you get an autonomous coding agent without sending code to a cloud.
You want coding assistance inside your own product or CI pipeline. Codebuff's TypeScript SDK lets you embed its agents, define custom tools, and route each task to whichever model fits the job.
Sources & related URLs
Related / legacy domains
Capability coverage
8.5 / 14 capabilities · 61%
| Integrations & Tool CallingSupports the Model Context Protocol for connecting external tools and data, calls shell, git, and test commands directly, and integrates into CI/CD through its SDK with custom tool definitions, strong integration and tool calling, though breadth comes via MCP and custom tools rather than a large prebuilt connector catalog. | Partial |
|---|---|
| Workflow OrchestrationCoordinates a genuine multi agent pipeline (file picker, planner, editor, and reviewer agents) to execute multi file changes across a codebase, supports custom agents with specialized workflows defined in TypeScript, and gates completion on tests, a real multi agent orchestration engine. | Full |
| Knowledge Grounding & RAGDeeply indexes and understands the entire codebase structure, dependencies, and patterns through a dedicated file picker agent and a project knowledge file, grounding edits in real repository context, a headline grounding capability. | Full |
| Human Oversight & GuardrailsSurfaces its changes in the terminal for the developer to review, gates completion on passing tests, and includes a reviewer agent, keeping humans in oversight, though enforcement of a human approval gate is workflow dependent rather than a hard runtime guardrail. | Partial |
| Security, Identity & GovernanceOpen source code and local codebase indexing offer transparency and keep source on the machine, but no infosec certifications, SSO, RBAC, or formal governance controls are surfaced. | Unable to verify |
| Observability & AuditabilitySurfaces the multi agent pipeline's steps in the terminal and emits progress events through the SDK, with test results providing verification, some execution observability, though not a full tracing or audit logging system. | Partial |
| Memory & State PersistenceA persistent project knowledge file provides context to the agents, but this is grounding configuration rather than a distinct runtime agent memory that accumulates state across sessions. | Unable to verify |
| Deployment & Data ResidencyOpen source under MIT, runs in the developer's own terminal, indexes the codebase locally so source stays on the machine, and can run with locally hosted models (Ollama, llama.cpp) for fully offline private development, a genuine self host and data residency capability. | Full |
| Prebuilt Agents, Templates & PacksShips prebuilt base and specialized role agents (file picker, planner, editor, reviewer) and lets users scaffold custom agents with the init command, reusable prebuilt building blocks, though custom agents are defined per project rather than shared through an open marketplace. | Partial |
| Triggers & Channel CoverageRuns in the terminal and can be embedded and triggered programmatically through its SDK, including in CI/CD pipelines, some channel and trigger coverage, though it lacks IDE, web, or chat surfaces. | Partial |
| Model Flexibility & RoutingOffers full model flexibility and routing: any LLM through OpenRouter with per agent and per task model selection so different steps or budgets route to GPT, Claude, DeepSeek, or others, and local models are supported too, a genuine routing capability with no vendor lock in. | Full |
| APIs, SDKs & MCP ExtensibilityOffers a full extensibility stack: a TypeScript SDK with an API for embedding coding assistance into applications and CI/CD, MCP support for connecting external tools, custom agent and custom tool definitions, and an open source codebase, comprehensive extensibility. | Full |
| Testing, Debugging & OptimizationGates edits on running the project's tests, includes a reviewer agent that checks output, and the team maintains a coding agent evaluation framework, real testing and verification, though the primary user facing capability is test gated editing rather than a full agent evaluation suite for users. | Partial |
| Browser & Computer UseExecutes shell and terminal commands, runs code and tests, and performs git and file operations in the developer's environment, genuine computer use through the terminal, though not general browser automation. | Partial |
Pricing
Freebuff free (open source, ad-supported) · Codebuff paid credit-based from ~$100/mo up to ~$500/mo · open source (MIT), BYO models
Managed paid tiers are credit-based (usage). The open source CLI is free to self-host (you pay your own model provider or run local models). Freebuff is free and ad-supported.
Included quota
Multiple paths. (1) Freebuff: free, ad-supported, no subscription/credits/config/API key; powered by open-source models (DeepSeek/Kimi/MiniMax). (2) Open source CLI (MIT): free to self-host; you supply your own model provider keys (any LLM via OpenRouter) or run local models (Ollama/llama.cpp), paying only your own inference. (3) Codebuff managed (paid): credit-based, roughly $100/mo entry up to ~$500/mo for power-user capacity. SDK (@codebuff/sdk) for embedding/CI-CD; MCP support; custom agents and tools.
What is public
Freebuff (free/ad-supported) and the open-source CLI are clearly free; managed paid pricing is credit-based and cited around $100-$500/mo via third-party analysis, with exact tier prices less transparent.
Billing mechanics
Managed: credit-based by task execution. OSS: free to self-host, you pay your own model provider. Freebuff: free, ad-supported.
Cost watchouts
Own-model-key path incurs provider token costs that can spike on large codebases; multi-agent runs use more credits/tokens than single-model tools; managed power-user tier reaches ~$500/mo.
Variable cost rationale
Managed pricing is credit-metered by task execution, and multi-agent runs (multiple specialized agents plus test runs) consume more per task, so heavy use scales cost, with a ceiling up to about $500/mo. Self-hosting the open source CLI shifts cost to your own model provider tokens (which can add up on large codebases) or local compute. Either way, spend tracks usage rather than a flat seat.
Additional watchouts
Managed credit costs can climb on heavy multi-agent runs. Self-hosting shifts cost to your own model tokens (large codebases re-read = more tokens). Terminal-only; custom agents require TypeScript. Benchmark claims are self-reported. Still needs careful human review (61% success rate).
Overage / add-ons
Managed tiers are credit-metered by task execution; heavy multi-agent runs consume more credits. Self-hosting shifts cost to your own model provider (token usage) or local compute.
Sales call required
No — self-serve available
Free / trial
Free via Freebuff (ad-supported, no subscription/credits/config/API key) and via the MIT open source CLI run with your own model provider keys or local models.
Lowest paid plan
Codebuff paid (managed) is credit-based, starting around $100/month, which is high relative to the ~$20 category median because it targets heavier multi-agent task execution. Free paths: Freebuff ad-supported, and the MIT open source CLI run with your own model keys.
Commercial notes
Unusual multi-path model: free OSS/Freebuff for activation, paid managed for scale. Higher paid entry (~$100) than the category anchor because it packages multi-agent execution. Self-hosting with your own keys or local models avoids managed fees entirely.
Key ambiguities
Managed paid tier prices are approximate; the real cost depends on which path you take (free OSS/Freebuff vs managed credits) and your model/token usage.
Cancellation / refund
Free paths require no commitment; managed credit tiers are self-serve. Specific terms not detailed. Open-source CLI can be run independently at any time.
Support SLA / resale
Community support (open source, contributions welcome). Managed/enterprise infrastructure available for scaling commercial needs. No reseller/whitelabel program surfaced.
Missing data
Exact managed tier prices and per-credit costs are not fully published (third-party figures ~$100-$500/mo). Enterprise pricing not detailed.
Related vendors
- Cognition — Maker of Devin, an autonomous AI software engineer
- Aider — Open-source, model-agnostic terminal coding agent that works…
- Anthropic Claude Code — Anthropic's terminal and IDE-native coding agent with sub-agent…
- Augment Code — AI coding assistant evolving into an AI-native engineering platform
- Blackbox AI — AI coding assistant for code generation and developer workflows
- Blink — Agentic AI app builder that turns a natural language prompt into a…