# 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. Source: https://capitalandcompute.net/blog/codistry-vs-claude-code-token-cost/ Published: 2026-08-25 Updated: 2026-10-13 On August 19, 2026, a Seattle startup called [Adronite](https://adronite.com/) launched [Codistry](https://codistry.ai/), 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](https://codistry.ai/blog/what-does-an-ai-coding-agent-actually-cost), 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. Key takeaways * The 48% claim is a cost figure, not a token figure. On real brownfield code Codistry used about 32% fewer billable tokens; cost fell further because output tokens, the expensive kind, are where the savings land. * Every dollar figure traces back correctly: $0.204 vs $0.394 per blank-project run is 48.2%, and the published break-even of roughly 1.2 tasks on PocketBase follows from the numbers. * The brownfield evidence base is one run per agent on one repository. The blank-project result had 10 runs per agent; the enterprise-shaped case did not. * Codistry-hosted models carry a 25% fee on top of model cost, which shrinks the net saving to roughly 35%. Bring your own key or run local models and there is no fee. * On a local open-weight model with no caching involved, Codistry still used about 41% fewer tokens, which supports the claim being structural rather than a pricing artifact. 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](https://theclarity.today/story/adronite-unveils-ai-coding-tool-based-on-embedded-context-engine-feb09165), 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](https://winbuzzer.com/2026/08/02/codistry-review-a-context-aware-ai-coding-assistant-for-vs-code-review/) 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 timing matters Codistry launched six days after OpenAI cut GPT-5.6 Sol API pricing by more than 20% and two weeks after Anthropic made Sonnet 5’s introductory rate permanent rather than raising it September 1\. Model-side price cuts and harness-side token reduction are substitutes: both attack the same line in your budget. Codistry’s bet is that the second lever keeps working after the first one stops making headlines. ## The benchmark, as actually specified Vendor benchmarks usually die on vagueness. This one doesn’t, and credit where due: the [methodology post](https://codistry.ai/blog/what-does-an-ai-coding-agent-actually-cost) 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](https://platform.claude.com/docs/en/about-claude/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.8__ | Item | Claude Code | Codistry | | -------------------------------- | ----------- | -------- | | Billable tokens (input + output) | 8,707 | 4,504 | | Full context incl. cache reads | 446,446 | 74,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](https://codistry.ai/pricing) 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](/blog/why-is-my-ai-api-bill-so-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](/ai-coding-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 * Adronite / Codistry Engineering (August 2026). _What does an AI coding agent actually cost?_ codistry.ai benchmark post. * Adronite (2026). _Codistry pricing and account documentation._ * Adronite via Business Wire (2026, August 19). _Adronite Launches Codistry._ syndicated at secureitworld.com and financialcontent.com. * Riley, D. (2026, August 19). _Adronite launches Codistry AI coding platform, claims half the token cost._ SiliconANGLE. * Clarity Today (2026, August 19). _Adronite’s Codistry makes token count, not context window, the axis of competition._ * Kasanmascheff, M. (2026, August 2). _Codistry Review: A Context-Aware AI Coding Assistant for VS Code._ WinBuzzer. * Reuters (2026, August 21). _OpenAI cuts developer pricing for frontier GPT-5.6 Sol model by more than 20%._ * Anthropic (2026). _Claude Platform pricing documentation._