The math behind every cost claim on this site.

The "99.97% reduction" headline is technically defensible but rhetorically suspect.

The most aggressive number you can put on a marketing page is the comparison against the worst-case approach: load every file in the codebase into the LLM context window. For Kubernetes that's 17,171 files × ~5,000 tokens/file ≈ 86 million tokens, which at Opus 4.7 input pricing ($15 per million tokens) costs $1,287 per query. ArgosBrain serves the same query for $0.33. That's a 99.97% reduction — true, calculable, and meaningless because no agent on earth actually reads every file.

The honest comparison is against a competent agent that does what a senior engineer does: grep first, read selectively, summarise. For a Kubernetes-scale audit a competent agent loads ~150 files × 5K tokens ≈ 750,000 tokens, which costs $11.25. ArgosBrain's $0.33 is a 97.1% reduction against this floor.

Both numbers are real. The 99.97% is the ceiling of the win; the 97.1% is the floor. We publish both because:

• The ceiling is what the comparison could claim if you accept the worst-case framing — useful for back-of-envelope sanity-checking ("does this even matter at scale?")
• The floor is what the comparison must claim if you reject naive baselines — the number that survives an adversarial reading on Hacker News
• Either way, ArgosBrain lives in a different cost regime: the engine fits inside the per-PR CI budget instead of the quarterly-audit budget

If a marketing page anywhere on this site shows only the ceiling number without a link back to this page, that's a bug; please let us know.

Three numbers: naive baseline, realistic baseline, and ArgosBrain.

Naive baseline (the ceiling)

Where:

Realistic baseline (the floor)

Where:

ArgosBrain (the actual measurement)

Where:

10 minutes, two terminals, your own numbers.

Every cost claim on this site reproduces in two MCP sessions against the same codebase. Pick any open-source repo (Kubernetes, ripgrep, your own monolith). Run both flows. Compare.

Terminal 1 — measure the realistic baseline

Terminal 2 — measure ArgosBrain

Compute

For Kubernetes 1.32 we measured: realistic = 97.1%, naive = 99.97%. Your numbers will vary by codebase shape, query specificity, and the agent's grep skill — that's exactly why we publish a range, not a single point estimate.

Keep us honest. If your reproduction lands materially different numbers, file an issue. We've been wrong before; we'll publish the correction with the same prominence as the original claim.

Headline costs use Anthropic Opus 4.7 input pricing — the most expensive option in production use.

We deliberately quote against the most expensive frontier model for two reasons: (1) it's what enterprise customers actually run for security-critical reachability proofs, and (2) cheaper models make ArgosBrain look more attractive, so quoting against Opus is the conservative choice. Provider prices change; we update this table when they do.

Prices as of 2026-04-25. Output tokens cost more (typically 4-5× input) but are negligible in retrieval-heavy workflows like ArgosBrain — the agent does ~22K input tokens of MCP responses and emits ~2K output tokens of summary, so output cost is <5% of total. ArgosBrain's per-query cost is for the LLM driving the workflow; the brain itself is $0 per query.

Honest scope statement.

• This is the cost of the agent driving the workflow, not the brain. The brain itself returns answers at $0 per query — it's a Rust process on your laptop. The numbers above measure what the LLM consumes on top to reason about those answers.
• Token counts are approximate. Real-world variance is ±15% depending on query specificity, agent prompting style, and how aggressively the agent re-reads files. We publish the median; your run will land within a 30% band either side.
• Realistic-baseline assumptions are debatable. "150 files for a K8s-scale security audit" is what we observed across 12 reproduction runs by 4 different operators. A more skilled grep-er might do it in 80 files; a less experienced agent might thrash through 400. The point of the realistic baseline isn't precision — it's existence proof that even an optimistic floor is two orders of magnitude above ArgosBrain.
• The 5K tokens/file estimate is conservative for some files, generous for others. Test files run smaller; generated code (zz_generated_*.go in K8s) runs larger. Average across a real corpus is within ±20% of 5K.
• This methodology applies to retrieval-heavy workflows. If you're using an LLM to generate long-form code (write me a 500-line implementation), token economics shift toward output cost and ArgosBrain's input-side savings matter less. The skills shipped on /skills are all retrieval-heavy by design.
• We make no claim about quality of findings. Token reduction without finding-quality parity would be useless. The Kubernetes case study reports specific findings + library gaps so quality is verifiable independently of cost.

Anticipated objections.

"99.97% sounds dishonestly inflated. Why publish it at all?"

It's the upper bound under a clearly-labelled worst-case assumption. We always publish it next to the realistic-baseline number on the same line. Anyone who cites the 99.97% without the 97.1% is misrepresenting our claim — point them here.

"Your '5K tokens per file' is suspect."

Run tiktoken against random samples from your own codebase. We have. Median is between 4,200 and 6,800 depending on language. We use 5K as the round number and disclose the range here.

"Why Opus pricing? Most teams use Sonnet."

Headline cost numbers should reflect the most expensive realistic deployment, not the cheapest. Customers running security-critical reachability proofs run Opus. Section 04 above shows the numbers for Sonnet, Haiku, GPT-4o, and Gemini — at every price point ArgosBrain stays in a fundamentally different regime.

"What about output tokens?"

For retrieval-heavy ArgosBrain workflows, output is <5% of total cost (typically 2K output vs 22K input). We omit it from the headline numbers because it's noise relative to the input-side savings — the same agent producing the same summary on the realistic baseline pays the same output-token cost.

"What does ArgosBrain itself cost?"

$0 per query. The brain is a Rust process running on your laptop or CI runner. No cloud round-trip, no per-query LLM call. The only costs are (1) the LLM that drives the workflow (the numbers above), (2) the one-time ingest cost (CPU + memory for ~30s on a small repo, ~10min on a monolith), and (3) the optional license fee if you're on Pro tier — but the per-query cost is zero either way.

"Will the numbers change?"

Yes. Provider prices drop ~50% per year on average. Our cost stays $0. The reduction percentages will increase over time as LLM input pricing gets cheaper but the file-read economics stay the same. We re-publish the K8s table every quarter.

Run the K8s audit on your machine. Compare your tokens.

curl -fsSL https://argosbrain.com/install | sh
cd ~/code/kubernetes-1.32
argosbrain ingest .
# In Claude Code: /argos-security
# Then sum the tokens reported in your status bar.
# Compare against the table in Section 04 above.