The CAS Trilemma: Why No Agentic System Can Be Cheap, Accurate, and Fast
CAP theorem tells distributed systems engineers something uncomfortable: you can't have Consistency, Availability, and Partition tolerance all at once. Pick two. Every database architecture is really just a stance on which one you gave up. CAP earned the word "theorem" — it's a proven result. What's below isn't that rigorous, so call it a trilemma instead: a three-way tension where picking two comes at the visible expense of the third, in the same spirit as CAP but without the formal proof behind it.
Agentic systems are running into a version of the same wall, just with different variables: Cost, Accuracy, Speed — CAS. Push an agent to be more accurate, and it needs more steps, more tool calls, more self-checking — which costs more, takes longer, or both. Push it to be fast, and something has to get skipped: less verification, fewer retries, a smaller model. Push it to be cheap, and you're paying for that in either time (batching, smaller models, less parallelism) or correctness (fewer safety nets).
You can optimize for two. The third pays for it.
The three archetypes
CA — Cost-Accuracy (slow by design). These are systems that sacrifice speed to get correctness on a budget. Think multi-step agents with self-critique loops, verification passes, sequential tool chains with retries, or a research agent that re-checks its own citations before answering. Deep-research assistants and agentic code review pipelines live here. You wait longer, but each dollar buys real correctness.
AS — Accuracy-Speed (buy your way out). Here cost is the release valve. Best-of-N sampling, parallel agent swarms racing to the same answer, running five model calls simultaneously and voting, speculative execution. You get answers that are both fast and accurate — because you paid for ten attempts and kept the best one. This is the "throw compute at it" archetype, and it has a ceiling: past a point, more parallel samples stop buying you more accuracy, they just buy you a bigger bill.
CS — Cost-Speed (accuracy is someone else's problem). Small models, single-shot generation, no verification step, aggressive caching. Autocomplete, intent routers, simple classifiers, chat triage. Cheap and instant, and it's fine — right up until the failure mode matters, at which point you find out what you didn't pay for.
The part CAP doesn't quite map onto
CAP has a forced move: partitions happen whether you like it or not, so the real choice is CP vs. AP. CAS doesn't have an equivalent physical law — nothing forces cost or speed to fail the way a network link does. But it does have a practical one: in most products, cost and speed are set from the outside. Your latency SLA and your unit-economics budget are usually fixed by the business before the agent is designed. That leaves accuracy as the dependent variable — the thing that quietly gets whatever's left over once cost and speed are locked in.
Which is why so many "AI agent underperformed" postmortems are really CAS postmortems: someone fixed the cost ceiling and the speed floor first, and accuracy was never actually a free variable to begin with.
The takeaway
There's no agentic architecture that's cheap, accurate, and fast at the same time — only ones that are honest about which one they gave up, and ones that find that out in production.
