The agentic IDE, and the agent
that works without it.
Code with Capuchin, our own model, which serves 92.7% of production requests. Turn on Auto mode and a frontier model steps in only when a task needs it. Claude, Gemini and ChatGPT are in the same plan, or run a model on your own machine. 50+ agent tools and a bill you can forecast.
Prefer the terminal? Install the CLI or the Code Agent. Also runs 100% local or with your own key. Open core. No lock-in.
Animated demo: an agent asked to add CSRF exceptions for webhook and Stripe routes plans four steps. Capuchin completes the first three for $0.00, the one complex step routes to Claude for $0.06, the file is edited and 12 tests pass.
Measured on production traffic. Not projections.
Capuchin, free to start.
Our fast-and-reasoning coding model ships with the IDE — try it free with the promo, no card. Capuchin Flash for instant edits, Capuchin Reason for planning and agents. Unlimited on every paid plan.
The frontier, on one subscription.
Claude, Gemini, and ChatGPT included as a transparent monthly allowance, and it goes further here. Auto mode spends frontier tokens only where they change the outcome, and lean local context averages ~$0.06 per frontier request.
Or run it entirely yours.
The full IDE also works 100% locally or with your own API key — free forever. On-device indexing, air-gapped mode, signed and replayable agent runs. No lock-in, ever.
New: Auto mode
Stop picking models. Auto picks one for every step.
Auto runs your task on Capuchin and calls in a frontier model only when the task needs one: tests keep failing, an edit adds new errors, the agent goes in circles, or you correct it. Once the problem is solved, Capuchin takes over again.
- You see every switch.
- Each reply carries a tag with the model that ran it and why: tests failed, stuck in a loop, you corrected it, planning, reviewing.
- No limit wall mid-task.
- If your Premium pool runs out, Auto keeps going on Capuchin, tells you, and brings the frontier model back when the pool resets.
- You can still overrule it.
- Know a task is hard? The rocket button in the IDE and Code Agent, or /frontier in the CLI, keeps the frontier model on for that conversation.
- Cheap handoffs.
- When Auto switches, the new model gets a short summary of the task so far, not the whole conversation again.
Included on Pro and Team. Max quality on Pro+, Ultra and Enterprise. Works in the IDE, Code Agent, CLI and cloud jobs.
Task: add rate limiting to file uploads
- 1Capuchin
Read the upload route and 4 related files
src/routes/upload.ts - 2Capuchin
Added rate-limit middleware and wired it in
src/middleware/rateLimit.ts - 3Capuchin
Ran the tests: 3 failed
- 4Capuchin
Tried a fix. Same 3 tests still fail
- 5Frontier · tests failed
Found the cause: a shared clock mock leaking between tests
- 6Capuchin
Applied the fix. 42 of 42 tests pass
Your code. Your models.
No single company should control how you build software. MonkeysCode runs locally and connects to any API you choose.
Capuchin
Our fast-and-reasoning coding model — free to try with the promo, unlimited on every paid plan. Capuchin Flash for instant edits, Capuchin Reason for planning and agents. No per-token surprise.
try it free
Claude · Gemini · ChatGPT
Included as a monthly allowance on paid plans — one subscription instead of three. Lean local context keeps requests at ~$0.06 on average, so your allowance stretches to hundreds of frontier agent runs. BYOK also supported.
in your plan
Your own — local
Run Ollama, llama.cpp, or vLLM on your hardware. Zero data leaves the machine — and the IDE stays free.
free forever
Your own — remote
Point MonkeysCode at your own server or any OpenAI-compatible endpoint. Your infrastructure, your rules.
your infra
The same $20 buys more here.
Most AI editors send whole files to the model. MonkeysCode sends the relevant slices, resolved locally by an on-device index that understands your codebase structure. The difference compounds.
| Typical AI editor | MonkeysCode | |
|---|---|---|
| Context sent | Whole files | Relevant slices only |
| Repeated context | Re-sent every call | ~90% served from cache |
| Session length before degradation | Short | 100+ messages |
| Cost per frontier request | Higher | ~$0.06 measured |
| Frontier runs on a $20 plan | Fewer | 300+ |
Everyday work runs on unlimited Capuchin. Frontier tokens are spent only on problems that deserve them. That is why a $20 plan here goes further than a $20 plan elsewhere.
Capuchin, the big three, or your own.
- 1Capuchin — our model — Fast-and-reasoning, two tiers (Flash + Reason), tuned for coding and included in your plan.
- 2Claude · Gemini · ChatGPT — First-class via BYOK or managed; swap with a setting, not a reinstall.
- 3Your own, local or remote — Ollama/llama.cpp/vLLM on your machine, or your own server / OpenAI-compatible endpoint. Same agent features either way.
- 4No degraded fallback — Local and self-hosted are full tiers, not a lesser mode.
1import { Router } from 'express'
2
3const router = Router()
4
5router.get('/api/users', async (req, res) => {
6 const users = await db.query('SELECT…')
7 res.json(users)
8})
Add pagination to the users endpoint
Capuchin
I'll add limit/offset params and update the query…
Your codebase never has to leave your machine.
- 1On-device index — Merkle-tracked, tree-sitter-chunked, embedded and searched locally.
- 2Air-gapped mode — Local index + local models + internal registry. Zero outbound calls.
- 3Optional team sync — Share an encrypted index when you want; turn it off and you're fully local.
- 4Monorepo-aware — A symbol/dependency graph so agents reason across services, not just nearby files.
Every agent run, signed and replayable.
- 1Signed event logs — A tamper-evident, replayable trail of plan, tools, and diffs.
- 2Test-gated apply — Agents can't commit code that fails your tests.
- 3Content-signed diffs — Verify exactly what changed and reproduce it byte for byte.
- 4Audit-ready — Hand a run to a reviewer or compliance officer to check themselves.
Diff Preview
- $except = [];
+ $except = [
+ '/api/webhook',
+ '/api/stripe',
+ ];
// shouldSkip()
+ if ($this→inEx…
SIGNATURE
sha256:e4a9f2c7…d31b
Your frontier allowance goes further here.
- 1Auto mode spends where it counts — Capuchin runs the loop, unlimited on paid plans. A frontier model steps in only when tests fail or the agent gets stuck, and every step shows which model ran it.
- 2Lean context, real savings — The on-device context engine sends only relevant code slices: ~$0.06 avg per frontier request on the priciest model, ~90% of context served from cache.
- 3Per-task budgets + hard cap — Agents stop instead of surprising you. Live consumption dashboard included.
- 4BYOK if you prefer — Use Claude/Gemini/ChatGPT on your own key; we don't mark up your tokens.
TODAY
$0.42
THIS WEEK
$2.87
BUDGET LEFT
$47.13
Per-Model Usage
Agent stops when budget is reached — no surprise bills
Plan. Edit across files. Verify. In parallel.
- 1Plan or Fast — Approve a plan for big changes, or fire instant edits for small ones.
- 2Parallel agents — Split work across files and services, then merge cleanly.
- 3Real tools, gated — Terminal, git, test runner, browser, MCP — each behind permissions.
- 4Browser verification — Agents prove a web change works with real navigation and screenshots.
Planning…
Planning…
Planning…
Agents that can actually reach your system.
Filesystem, terminal, git, test runner, browser, search, subagents and MCP servers. 50+ implemented tools, every one behind an explicit permission you control.
An agent that can only suggest is a chatbot. An agent that can edit, run, test and verify is a colleague.
100 % Local. No telemetry by default.
The IDE collects no telemetry by default — your code, prompts, and metrics stay on your machine. Point MonkeysCode at a local Ollama instance and it runs entirely off-grid.
How MonkeysCode stacks up.
Feature-by-feature comparison with the tools developers use today.
One engine. Three ways to use it.
The IDE, the Code Agent desktop app and the CLI share the same agent loop, tools and Auto mode. Use whichever fits the job, all in one plan.
MonkeysCode IDE
Win · macOS · Linux
The full agentic editor. Goes head-to-head with Cursor and Antigravity.
Code Agent
Win · macOS · Linux
A desktop app to launch, watch, and orchestrate parallel agents — without the full editor. Same engine as the IDE. Included in every plan.
MonkeysCode CLI
Win · macOS · Linux · CI
Agentic coding from the terminal and CI, headless, with the same engine. Runs Auto mode, Capuchin, Claude, Gemini, ChatGPT, or your own model. Included in every plan.
MonkeysCode Code Agent
A desktop app for running AI coding agents across your projects. Same engine as the IDE, without the editor.
Launch a run, walk away, come back to a reviewed diff. Run many agents at once. Point them at your laptop, a remote dev box, a cloud container, or a machine across the room.
Use the editor when you want to. Skip it when you don't.
| MonkeysCode IDE | Code Agent | |
|---|---|---|
| What it is | Full agentic editor | Desktop agent runner |
| Use it when | You are writing code alongside the agent | You are delegating work and reviewing results |
| Concurrency | Agent plus sub-agents | Many runs, many projects, in parallel |
| Runs against | Your machine | Local, SSH, Cloud, or a remote peer |
| Included in | Every plan | Every plan |
Same agent loop. Same 50+ tools. Same permission modes, checkpoints and signed runs. Switch between them without changing how you work.
Built for teams that can't compromise.
Whether you're in a regulated enterprise or a fast-moving startup, MonkeysCode adapts to your environment.
One subscription, every model
Unlimited Capuchin + Claude, Gemini, ChatGPT in one plan — instead of three separate bills.
Cost-efficient frontier usage
~$0.06 avg per frontier request; budgets and a hard cap keep spend predictable.
Polyglot & back-end shops
First-class PHP, Python, Go, Rust.
Open-source-minded developers
Open core, Open VSX, no lock-in.
Built for teams
One subscription from first keystroke to production, with shared billing and usage.
We lead with how it works, not with hype.
$0
To get started
Capuchin free to try
Claim the promo and code with our model — no card required.
~$0.06
Avg per request
Efficient frontier usage
Lean local context and caching keep frontier requests cheap.
Zero
Vendor lock-in
No lock-in
100% local or BYOK — your models, your keys, your machine.
From keystroke to production.
MonkeysCode is the IDE arm of MonkeysLegion — a PHP 8.4 framework with AI orchestration built into it.
MonkeysCode
write
MonkeysLegion
build
First-class for MonkeysLegion
Capuchin understands PHP 8.4 and the 28-package framework, not just JavaScript.
Powered by Apex
The same orchestration engine in the framework drives the IDE's agents.
Signed, replayable runs
Every agent action is verifiable — hand a run to a teammate or an auditor.
No lock-in
Open core, Open VSX, MIT framework underneath. Your code is yours.
Start free with Capuchin.
Upgrade when it earns it.
Try Capuchin free, no card. One plan adds unlimited Capuchin plus Claude, Gemini, and ChatGPT — with lean context that makes every token count.