Your agent's $6,451 review bill is a repeat problem — and the cheapest fix has a dangerous twin Parcha built its own code-review agent after its Greptile review bill jumped from $180 a month in December to $6,451 in October, roughly 36x, following Greptile's shift to per-review pricing. The in-house reviewer runs a cheap model tuned on Parcha's own pull requests, with a parent agent dispatching eight reviewers over a read-only checkout and verifying findings before posting comment-only reviews, bringing cost to about 18 cents per review. On 30 held-out PRs the cheap reviewer caught 42% of real bugs versus Greptile's 26%, though the company's own benchmark, graded by Claude Opus 5.5, rests on a small sample and does not measure false positives. Parcha's coding agents started opening more pull requests, and its Greptile review bill went from $180 a month in December to $6,451 in October — $7,018 in November so far, about 36x. The pricing change that triggered it was mundane: Greptile moved from flat per-seat pricing to a dollar per review beyond the first 50. The bill that followed was not. Stack Futures, Nov 13, 2026 http://stackfutures.com/blog/parcha-agentrun-code-review-18-cents-greptile-bill-180-to-6451-nov-2026/ Parcha's answer was not to shop for a cheaper model. It was to stop paying the frontier model to re-derive what it already knew. It built its own reviewer on a cheap model, tuned on its own PRs, with a parent agent dispatching eight reviewers over a read-only checkout and verifying each finding against the code before posting a single comment-only review. A review now costs about 18 cents. On the 30 newest PRs in its own repository — held out from tuning — the cheap reviewer caught 42% of real bugs against Greptile's 26%, and 5 of 8 bugs classed as serious against Greptile's 1. Discount those numbers the way the write-up itself does: it is Parcha's own repository and Parcha's own benchmark, graded by Claude Opus 5.5, eight serious bugs is a tiny sample, and nothing there measures false positives against Greptile's configuration. But the cost mechanics are credible, and the shape of the fix is the point. The second case study in the same README makes it explicit: Parcha let Opus work out how to classify merchants, then handed what it learned to a cheaper model. Cost fell from $0.89 to $0.12 per merchant, roughly 7x, for the same job. After each run, the agent keeps a note, a skill, or a workflow that makes the next run cheaper. Learn once, hand off — that loop is the actual product. That is the same shape as every agent cost blowup. A 20-step task re-sends its context at every step; a review agent re-reads the same repository for every PR; a support agent re-derives the plan for a goal it solved an hour ago. The price you shop for — dollars per million tokens — is the smallest term in the bill. The terms that decide it are in your own traces: how often the same goal repeats, how long the gaps between repeats are, and what a finished task costs end to end. On τ-bench — the airline customer-service benchmark, dense with the rephrased-same-goal traffic that support agents actually see — Pomerene's trajectory cache served 86% of paraphrased requests from cache , with 78% of those judged correct . Read both numbers honestly: 86% is why repetitive agent workloads are worth caching, and 78% is why the safety rules below are the product, not a footnote. The fix Parcha built and the fix a trajectory cache provides are the same move at different layers. Parcha hands a learned workflow to a cheaper executor. A trajectory cache replays the recorded plan instead of re-deriving it: a 14-step audit trajectory replays in 47ms versus 3.9s live, with zero LLM invocation on the hit path. Prefix caching and trajectory caching attack different terms and they compose — prefix caching reuses the re-sent context and still generates, trajectory replay skips the re-derivation entirely. There is a fix that looks cheaper than both, and it is the one that will hurt you. Semantic caching — match the new request to a cached answer by meaning — attacks the repeat directly, and it is exactly wrong around writes. Embeddings capture topic, not polarity: "activate user 4471" and "deactivate user 4471" score 0.853 cosine similarity . A semantic cache will happily replay the wrong one. A wrong hit doesn't show up in your token bill. It shows up as a wrong answer, a duplicated charge, a state change that never should have happened. So the gate has to be structural, not a threshold. The match has three outcomes, all deterministic — hashing plus vector geometry computed in TypeScript, no LLM call in the match decision, so the same input makes the same cache decision every time. L1 is a full replay. L2 replays the matching prefix and hands control back to your agent at the exact step where the plan stops matching. A miss runs live and gets stored. And steps that write are never fuzzy-matched against a new request: a cached write step replays only on an exact goal-plus-context repeat; anything ambiguous becomes a miss or an L2 handoff. On an adversarial eval of polarity-flipped pairs — requests that are semantically close but must not be confused — the gated engine produced 0 false positives across 18 pairs . One honest note, because the gate's story changed after the first post about it: the write-safety gate as originally published had three holes, found via outside critique and fixed in core — merged, shipping in the next core release. An abstract-goal match is no longer treated as an exact repeat write trajectories are refused there, and context is diffed ; a trajectory with no taint records plus a context change is now a miss; and a hit never serves past a declared external write — control hands back to the agent at that step. Still open, not shipped: entity agreement on read matches. Any cost model you build should treat those as the current rules, and the open item as the next gate to build. Parcha's lesson generalizes: measure the repeat first, then attack it. Run the three numbers from your traces — goal repeat rate cluster completed runs by goal, not by exact prompt text , gap histogram a repeat after the data changed is a stale hit, not a saving , and cost per finished task including the runs that failed and retried . If goal repeats across sessions are effectively zero on your corpus, a trajectory cache has almost nothing to serve there — and the honest answer is to not buy one. If they are not, you are paying the model to rediscover plans it already derived, and the cheapest fix that is also safe is the one with a structural write gate. The kit's built-in diagnostics /v1/diagnostics show hit rates, the L1/L2/miss breakdown, latency percentiles, and dollars and tokens saved for your real traffic, so the three numbers decide whether caching is a cost lever or a distraction for your workload. Pomerene ships as a self-hosted Starter Kit — Indie $99 / Pro $249, one-time, source included — so the cache runs in your infrastructure, next to your agents. Quickstart is about 5 minutes Node 20+, Docker or Postgres 15+ . Docs and details at pomerene.io/starter-kit https://pomerene.io/starter-kit .