Free Allowance or Self-Hosted Box? Compute the Crossover Before You Commit

A platform lead I'll call Dana pinged me mid-sprint with a one-line message: "our AI lane is free, so why does it feel expensive?"

The lane wasn't the problem. The problem was that nobody had converted "free" into the only unit her org actually budgets in — merged pull requests. This scenario is a composite of conversations I've had with platform leads; the numbers below are illustrative, not audited results from any specific company.

That conversion is the whole article. If you can't say how many merged PRs your allowance covers, you don't have a capacity plan. You have a vibe.

The claim, and what it is worth

MonkeyCode's operators state two things that matter for this decision: free model access with 10 million free tokens, and a free server option. The project is also described as open source. I have not audited the quota mechanics, expiry, or fair-use rules, so treat all of that as a claim to verify inside your own account before you plan around it.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

A free allowance changes the shape of your cost curve, not the existence of one. Below the line, marginal cost is zero. Above it, you either pay overage or you own hardware. Those are different businesses, and they fail differently.

Step 1: measure tokens per merged PR

Not per seat. Not per developer-day. Per merged PR. Seats hide idle time; days hide rework.

I keep a tiny script for this because the mean lies. Agentic sessions have a long tail — one runaway loop can double your average while the median barely moves.

# tokens_per_pr.py — run against your own usage export
import csv, statistics

rows = list(csv.DictReader(open("usage.csv")))   # columns: pr, tokens
per_pr = {}
for r in rows:
    per_pr[r["pr"]] = per_pr.get(r["pr"], 0) + int(r["tokens"])

vals = sorted(per_pr.values())
median = statistics.median(vals)
p90 = vals[int(len(vals) * 0.9)]
print(f"PRs={len(vals)} median={median} p90={p90} mean={sum(vals)//len(vals)}")

Use the median for planning and the p90 for your worst-case gate. If median and p90 differ by more than 3x, your workflow has an unbounded loop somewhere, and no pricing model will save you from it.

Step 2: convert the allowance into PRs

This is one division, and it is the most useful number in the whole exercise.

covered_prs = allowance_tokens / tokens_per_pr_median

At an illustrative 45,000 tokens per merged PR, 10 million tokens covers roughly 222 merged PRs. Whether that is generous or thin depends entirely on your team, and that is the point — the number is meaningless until it meets your sprint board.

Ask the question that actually decides things: does my pilot need more than ~200 merged PRs to produce a defensible answer? If yes, you are not testing the free lane. You are testing your overage path while calling it a pilot.

Step 3: find the self-host crossover

Here is the counterintuitive part. Self-hosting almost never wins on tokens alone. It wins on control. Let's show the arithmetic instead of asserting it.

# crossover.py — a model, not a benchmark. Plug in measured inputs.
def cost_per_pr(tokens_per_pr, overage_per_million):
    return tokens_per_pr / 1_000_000 * overage_per_million

def break_even_prs(tokens_per_pr, hosted_overage, box_month, ops_hours, loaded_hourly):
    fixed = box_month + ops_hours * loaded_hourly
    saving = cost_per_pr(tokens_per_pr, hosted_overage) - 0.0  # box marginal ~ 0
    return fixed / saving if saving > 0 else float("inf")

n = break_even_prs(
    tokens_per_pr=45_000,
    hosted_overage=0.40,     # $ per 1M tokens after allowance (illustrative)
    box_month=192.0,         # 160 h x $1.20/h (illustrative)
    ops_hours=6.0,
    loaded_hourly=85.0,
)
print(round(n))  # ~39,000 merged PRs/month to justify the box

Thirty-nine thousand merged PRs a month is not a team. It's a CI pipeline with aspirations. At low overage prices, the math says: stay hosted, keep the ops hours for something that compounds.

Now push the overage price up and watch the answer move.

Tokens/PR (median)	Overage $/1M	Self-host fixed $/mo	Break-even PRs/mo
45,000	0.40	702	~39,000
45,000	3.00	702	~5,200
15,000	3.00	702	~15,600
45,000	3.00	2,400	~17,800

Read the last two rows together. Shrinking tokens-per-PR by 3x raises the bar by 3x. Adding an SRE-grade box triples it again. Self-host crossover is a lagging indicator of operational discipline, not a pricing event.

The three gates

A spreadsheet is a conversation tool, not objective truth. Use it to force three yes/no answers.

1. Coverage gate. allowance / median_tokens_per_pr ≥ your pilot's required merged PRs, with 30% headroom for the p90 tail. Fail this and you are measuring overage, not the free lane.
2. Ops gate. Name one human who owns patching, upgrades, and on-call for the self-hosted path, with hours on a calendar. No named owner means your ops_hours input is fiction, and the crossover number is fiction with it.
3. Reversibility gate. What does leaving cost in each lane? Migrating prompts, evals, and CI hooks is the real bill. Open-source matters here far more than price does — you can read the code, fork it, and leave with it. Check the actual license yourself before counting on that.

Fit criteria

Choose the free hosted lane when: your pilot fits inside the coverage gate, you have no data-residency constraint, and your bottleneck is review time rather than token spend. Most teams land here, and pretending otherwise wastes a quarter.

Choose self-hosted when: you need airgapped or residency-bound execution, custom weights, or offline CI. Do it for those reasons and say so out loud — the crossover sheet will not back you up on cost.

Choose a paid seat when: you have crossed the allowance in two consecutive sprints and your p90 is stable. Stable overage is a signal to buy predictability, not to build a data center.

Limitations and who should skip this

This model ignores latency, queueing, egress, storage, and quality differences between models. Tokens are not equal across providers, so never compare raw counts between lanes. Quota terms and prices move; re-run the sheet before each renewal.

Skip this if you have no one who can own infrastructure, if you have a hard residency requirement (that decision is already made for you), or if your actual constraint is reviewer attention — in which case the crossover is the wrong sheet entirely.

The question that should end the meeting

Don't ask whether the free option is good. Ask: which single input would flip my decision? For most teams it is tokens_per_pr, not price. Measure it for two weeks and the argument dissolves.

If you want a zero-cash place to collect your first real tokens_per_pr number, MonkeyCode's free model access is a reasonable lane to start on — bring the spreadsheet, not the enthusiasm.