Field notes on AI coding agents: what they cost, where they break, and what shipped. Figures without a traceable source were cut.
Written with AI assistance. Figures without a traceable source were cut before publishing.
MonkeyCode’s free tier includes 900 million tokens, deploys to your own network with 1 command, and ships as open source you can read. Those three facts do different jobs, and only the first one gets attention.
The free allocation is what people notice, since 900 million tokens is well beyond what most competing tools give away and beyond what a solo developer exhausts in normal work. The deployment model is what actually decides whether the tool is usable in the places where AI coding is currently blocked.
Here is what the 900 million actually buys, why the single-command private deployment matters more than the quota in regulated work, and where the free tier stops being the right answer.
Token allocations are hard to reason about because consumption is not proportional to the code you get back.
The bulk of spend in an AI coding assistant goes to context. Every round, the model re-reads the files it needs to see before it can safely change anything, plus your test output, your error logs, and whatever it edited last time. Generated code is a small fraction of the total. A 40-line function might cost several thousand tokens of reading to produce, and on a second pass through the same files it costs roughly that again, because the model does not remember the first read unless you arranged for it to.
That makes the allocation behave differently across project types. A greenfield project with 12 files consumes slowly, because there is not much context to re-read. A mature codebase where every change touches 5 modules and a test suite consumes far faster, and the difference between those two cases is larger than the difference between any two models.
Which means the honest answer to “how long does 900 million tokens last” is that it depends on your repository rather than on your discipline. For a student, an open-source contributor, or someone prototyping, 900 million is effectively unlimited. For someone running an agent continuously against a large production codebase, it is a few months at best, and probably less.
Track consumption from the first week rather than from the first warning at 80 percent. The rate tells you which category you are in, and it is the only number that answers the question for your project specifically.
Private deployment with a single command is the feature that changes which conversations are possible.
Finance, government, and healthcare have not avoided AI coding tools because the tools are bad. They avoided them because sending source code to a third-party endpoint fails a compliance review, and no amount of model quality fixes that. A tool that runs entirely inside the internal network removes the objection rather than arguing with it.
Open source compounds this. Auditable core code means a security team can answer the question they actually care about, which is not whether the vendor is trustworthy but what the software does with the files it reads. That question has a definite answer when the code is readable and only a vendor assurance when it is not.
Most commercial AI coding tools operate as black boxes. You send code out, something comes back, and the middle is a contract rather than a mechanism. For a solo developer that trade is usually fine. For anyone whose repository contains data covered by a regulation, the trade is not available at any price, which is why the deployment story is the load-bearing feature here and the token count is the headline.
Private deployment does have real prerequisites. You need server resources and a network configuration that lets the deployment reach whatever it needs to reach, and the dependencies have to be present. Single-command install means the install is one command, not that the environment configures itself, and the gap between those two claims is where most self-hosting frustration lives.
A generous quota changes the economics of running an agent and changes nothing about whether the output is correct.
2 practices are worth more than the tokens they cost, and both of them spend tokens to save them. The first is read-then-modify: let the model review the project description, the directory structure, the existing tests, and the relevant modules before it proposes a change. Skipping this is how you get an agent that reinvents a utility you already have, or restructures something in a way that is locally sensible and globally wrong. The reading costs tokens and saves a rewrite, which on a 900-million-token budget is a trade worth making every time.
The second is a review step that checks generated code against the specification rather than against itself. An agent asked to evaluate its own output tends to agree with itself, which is the failure people describe as collusion when two model-driven steps validate each other into a confident mistake. A separate reviewing role, whether that is a person or a differently-prompted pass with the spec in hand, catches the class of error that self-review structurally cannot.
The ai-job-search project runs 7 verification steps on generated resumes, with particular attention to PDF text layers, and that is a reasonable model for what verification looks like when it is taken seriously. 7 steps sounds heavy until you notice that each one is cheap, deterministic, and finishes in milliseconds, while the failure it prevents costs an interview.
Session management belongs in the same category. Tools like seshport let you move a session between tools, which avoids rebuilding context from scratch every time you switch, and rebuilding context is exactly the expensive operation described earlier, which arguably makes session portability a bigger lever on your token bill than any setting the tool exposes. Reducing how often you pay for it is a more effective saving than choosing a cheaper model.
There is a point where free stops being the deciding factor, and it arrives earlier than the token count suggests.
Production scale is the obvious limit. As a project grows, the free allocation may simply not cover the work, and at that point the choice is a paid tier or a different tool. Nothing surprising there.
The less obvious limit is support. Commercial alternatives optimized for high-volume, high-complexity work come with dedicated support teams and around-the-clock response, which matters when a tool sits in the path of a production deployment and stops behaving. Open source gives you the ability to read the code and fix it yourself, which is genuinely better on a Tuesday afternoon and considerably worse at 3 in the morning during an incident, when what you want is not source access but someone whose actual job is to pick up the phone.
For individual developers and small projects, this rarely bites. The combination of 900 million free tokens, private deployment, and readable source is a strong position, and the absence of a support contract is not a real cost when the alternative was paying for a tool you did not need.
For anyone in a regulated industry, I think the calculation is different and probably clearer. The quota is a bonus. The reason to look at MonkeyCode is that it runs where your code already lives, and that is a property most of the market does not offer at any price.
Also readable on Telegraph.
Read next
Part of ai-coding-field-notes — field notes on AI coding agents. Found something wrong, or shipped something similar? Open an issue — corrections are the point.