Capital & Compute

Codistry vs Claude Code: Auditing the Half-Cost Token Claim

Adronite claims Codistry costs 48% less than Claude Code per task. We checked the math in its own benchmark data: arithmetic holds, but three caveats matter.

· ai· coding-agents· pricing· By Capital & Compute

On August 19, 2026, a Seattle startup called Adronite launched Codistry, a coding platform whose entire pitch is a money claim: in the company’s own benchmarks it finished comparable development tasks using roughly half the tokens of Claude Code, at about 48% lower average cost per task, with both tools running the same model. Most coverage restated the number. The interesting question is whether the number survives contact with the company’s own methodology, because Adronite published the full benchmark write-up, receipts included.

Short answer: the arithmetic checks out, and the methodology is unusually honest for a launch announcement. But the headline figure compresses three different results into one number, and two of them deserve more caution than the press release gives them.

Codistry
Adronite, launched August 19, 2026
VS
Claude Code
Anthropic, VS Code extension arm of the test
$0.204
Cost per blank-project run (Opus 4.8)
$0.394
4,504
Billable tokens per run (input + output)
8,707
74,374
Full context processed incl. cache
446,446
2:40
Wall-clock per run, local model round
1:43
1
Runs behind the PocketBase result
1

What Codistry actually is

Codistry is a VS Code extension built around what Adronite calls the Context Engine, or ACE. Instead of shipping large slices of a repository into every prompt, the tool builds a relational map of the codebase once at install time, keeps it current as you commit, and hands the model only the portion of the map a given task needs. The premise, in CTO Edward Rothschild’s framing reported at launch, is that most platforms answer hard problems by feeding models more context and more tokens, when supplying less leaves more of the model’s reasoning budget for the actual problem.

That puts it in a specific competitive slot. It is not trying to out-model Claude Code. It runs Claude Opus 4.8, GPT models, OpenRouter endpoints, or local models through Ollama and LM Studio, and competes on how few tokens reach any of them. Deployment spans cloud, on-premises, and air-gapped environments, aimed at regulated teams that cannot send source code to external endpoints. A hands-on review of the beta extension by WinBuzzer on August 2, before launch, found the product real and working, with the disclosure that Adronite had supplied a free API allowance for testing.

The benchmark, as actually specified

Vendor benchmarks usually die on vagueness. This one doesn’t, and credit where due: the methodology post specifies enough to rerun it.

Both agents ran through their VS Code extensions with an identical set of six MCP servers totalling 72 tools. When Adronite discovered two additional servers were unsupported by Claude Code, they were removed rather than left in. A byte-for-byte proxy sat between agent and model, counting exactly what the model processed without translating or rewriting payloads, which matters because API-format translation silently changes token counts.

Two tasks, two model rounds:

Round Task Runs per agent
Local: qwen3.6-35b-a3b-mlx via LM Studio Blank project: build a Python expression evaluator with tests 10
Cloud: Claude Opus 4.8 Same blank project 10
Local: qwen3.6-35b-a3b-mlx PocketBase (~143,000 lines of Go): design a GCS backend, docs only 1
Cloud: Claude Opus 4.8 Same PocketBase design task 1

Cloud pricing basis was standard non-batch rates at test time: $5 per million input tokens, $25 per million output, $0.50 per million cache reads. Those match Anthropic’s published Opus-class pricing, so the dollar figures are grounded in real rates rather than invented ones.

~48%
Cost saving per task
vendor-reported, Opus 4.8
1.2
Tasks to break even
PocketBase, index amortized
1
Run behind the brownfield result
per agent; variance unmeasured

Does the arithmetic hold?

This is the part nobody else checked, so here is the check.

The cost claim. Per blank-project run on Opus 4.8: $0.394 for Claude Code against $0.204 for Codistry. That ratio is 51.8%, so Codistry came in 48.2% cheaper. The “~48%” headline is accurate to the decimal.

The break-even. On PocketBase, a single Codistry task cost $1.10 against Claude Code’s $2.12, but adding the one-time index brings the first task to $2.30, which is 8.7% more expensive than Claude Code. The crossover math: Claude Code costs $2.12 flat per task, Codistry costs $1.20 once plus $1.10 per task. Setting those equal gives $1.20 divided by $1.02, which is 1.18 tasks. The company’s “~1.2 tasks, roughly $2.50 total” break-even statement follows exactly. After that point every task trends toward the 48% saving.

So the numbers are internally consistent. What the headline compresses is the distance between them.

Per-run token volume, blank project on Claude Opus 4.8Billable input plus output tokens versus full context including cached tokens, averaged over ten runs per agent. Vendor-reported data.Claude CodeCodistry0100,000200,000300,000400,000500,000Billable tokens (input + output)Full context incl. cache reads
Per-run token volume, blank project on Claude Opus 4.8
ItemClaude CodeCodistry
Billable tokens (input + output)8,7074,504
Full context incl. cache reads446,44674,374

Three things the headline hides

One: it is a cost figure wearing a token costume

Look at the two bars above. On full context processed, Claude Code touched six times the tokens. On billable input and output, it used about 1.9 times. The gap collapses because most of Claude Code’s volume is cache reads, billed at one-tenth the input rate. Claude Code leans hard on prompt caching; caching is doing exactly what it is designed to do, which is make repeated context nearly free.

The expensive line item is output, and that is where Codistry’s smaller prompts pay off: fewer wasted turns means less generated text to pay full price for. That is a genuine advantage, but it means the 48% figure depends on Anthropic’s cache discount staying at 90% off. If your workload runs on a provider without aggressive cache-read discounts, raw token volume matters more than this benchmark suggests. And if a provider reprices cached input upward mid-flight, as DeepSeek did in August when peak cached-input rates rose twelvefold, the economics shift again.

Two: the brownfield evidence is one run per agent

Ten runs per agent backs the blank-project result, which makes it the statistically respectable part of the benchmark. But a blank project is also the case where a context engine has nothing to index, and Codistry still won it by ~48%.

Read that carefully, because it cuts both ways. It means a large share of the saving comes from how the tool manages conversation context, not from the celebrated codebase map. Meanwhile the case that actually exercises ACE, analyzing the real 143,000-line PocketBase repository, ran exactly once per agent. One run has no variance measurement. The company’s own table quietly concedes this shape: greenfield saves ~48% of billable tokens, brownfield only ~32%, and the brownfield cost figure reaches ~48% partly through the output-mix effect described above. If you are evaluating Codistry for an existing enterprise monorepo, the honest reading is: promising, structurally supported by the local-model round, and demonstrated once.

Three: speed is the price locally

On the local open-weight round, Codistry finished each run in 2:40 against Claude Code’s 1:43, taking more, smaller turns (16.5 requests per run against 10.3). Tokens are cheap; wall-clock time sometimes isn’t. In cloud rounds on frontier models the latency difference narrows, but if you route local models through Ollama the way an increasing number of teams do, expect the efficiency to cost you roughly 60% more session time.

What it costs to actually run

From Codistry’s pricing page and docs:

Plan Price What you get
Free $0 Full extension with your own API keys or local models; offline capable
Developer $10/month Adds the Codistry hosted key, $10 of usage credits included monthly (they expire each cycle)
Teams / Enterprise Custom On-prem or air-gapped deployment, SSO/SAML, SCIM, audit export

The fee structure is where careful buyers should do their own math. Hosted-model requests are billed at the provider’s published token rate plus a 25% Codistry fee. Bring your own key or run local models and the fee disappears entirely.

Apply that to the benchmark: if Codistry genuinely delivers 48% savings, running through the hosted key costs 52% of baseline times 1.25, which is 65% of baseline. Your net saving is about 35%, not 48%. Still worthwhile. But the launch coverage quoted the gross figure while the default configuration for new subscribers, the hosted key with auto top-up enabled, silently pays the fee. Set up your own keys and the full saving is yours.

These are founding prices, explicitly marked limited-time on the pricing page, which means the 25% number itself has no permanence guarantee. Pricing explainers exist precisely because tools reprice constantly.

Compare it to just waiting for price cuts

There is a fair question about whether any of this effort beats the market’s own trajectory. In the four weeks before Codistry launched, OpenAI cut GPT-5.6 Luna by 80% and Terra by 20%, then cut Sol by more than 20%, while Anthropic canceled a scheduled 50% increase on Sonnet 5. Per-token prices are falling fast enough that a skeptic can argue harness optimization chases a shrinking target.

Two counters. First, output-heavy agentic workloads scale with tasks, not just rates, and token consumption varies more between tools than list prices do between model generations; our guide to why AI API bills run high covers how much of a typical bill is avoidable volume. Second, the local-model result is the tell: 41% fewer tokens with no caching in play means the mechanism survives whatever cloud prices do next. Cutting waste compounds across every future rate card.

For teams sizing this decision numerically, the coding agent cost calculator takes per-token rates and consumption assumptions and produces comparable cost-per-task estimates across tools.

Verdict

The claim survives its audit, which is rarer than it should be. The arithmetic is exact, the methodology disclosure is better than the industry norm, and the local-model round provides independent-ish corroboration that the effect is structural. Codistry is a real product with a real, differentiated thesis: token count, not context window, as the axis of competition.

What would move it from promising to proven:

  • More than one brownfield repository, and more than one run per agent on it
  • A published task list or harness so third parties can reproduce the numbers
  • Independent replication on a codebase the vendor did not choose
  • Evidence that outcome quality holds when fewer tokens reach the model, since “comparable development tasks” completing cheaply is not the same as completing equally well

If your team burns four figures monthly on coding-agent tokens and lives in a compliance environment that favors on-prem deployment, the free tier with your own keys is a zero-risk trial of the core claim. Just measure your own tokens the way Adronite did: at the model boundary, not the marketing page.

Frequently asked questions

Is Codistry's 48% benchmark trustworthy?
The arithmetic verifies against the company's published data, and the controls (same model, same prompts, identical tooling, standard pricing) are well specified. It remains a vendor-run benchmark on one repository chosen by the vendor, with the brownfield case resting on a single run per agent. Treat it as credible-but-unreplicated.
How much does Codistry cost?
A free plan works with your own API keys or local models. The Developer plan at $10 per month includes $10 of usage credits and adds hosted models, which carry a 25% fee on top of provider token costs. Team and enterprise plans with on-premises deployment are quote-based.
Can Codistry run local models?
Yes. It supports Ollama and LM Studio endpoints and is fully offline capable, including air-gapped deployment. In Adronite's local-model round it used about 41% fewer tokens than Claude Code with no caching involved.
Does the 25% hosted-model fee erase the savings?
No, but it shrinks them. A 48% gross saving becomes roughly 35% net after the fee. Bringing your own API key or running local models avoids the fee entirely and preserves the full saving.

Sources

Get each breakdown before it makes the rounds

You get one email when a new source-backed analysis goes live: what AI agents actually cost, which models are worth running, and what the benchmarks really mean. No hype.

No spam. Unsubscribe anytime.

← Back to Coding agents