When you’re running AI agents in production, the conversation quickly shifts from “can it do the task?” to “what does it cost per task?” I’ve spent the last several months instrumenting production-grade workloads across LangGraph, CrewAI, and AWS Bedrock Agents — measuring token consumption, end-to-end latency, and the hidden overhead that never shows up in framework demos. The results are nuanced, occasionally counterintuitive, and directly relevant to anyone planning to scale agent infrastructure in 2026.
This isn’t a synthetic benchmark. The workloads I tested map to three common production patterns: a customer support triage agent (high-volume, short tasks), a multi-step research and synthesis agent (medium-volume, long-horizon tasks), and a code review orchestration agent (low-volume, tool-heavy tasks). Each framework was run against Claude Sonnet 4.6 and GPT-4o as the underlying models, with identical system prompts and tool definitions wherever the framework allowed.
Let’s get into the data.
Why Token Efficiency Matters More Than Raw Speed
Before diving into numbers, it’s worth establishing why token count is the leading cost driver — not compute or latency alone. At current API pricing, a 1M-token-per-day workload on Claude Sonnet 4.6 costs roughly $3–$9/day depending on input/output ratio. Scale that to 10M tokens/day (a modest mid-market deployment) and you’re looking at $900–$2,700/month from inference alone — before framework hosting, logging infrastructure, or retry overhead.
Latency matters for a different reason: user-facing agents in support or copilot contexts have hard SLA requirements. A framework that uses 15% more tokens but delivers responses 40% faster may be the right economic choice for some teams. The goal of this benchmark is to give you enough data to make that call for your specific workload profile.
The three frameworks represent meaningfully different philosophies:
- LangGraph (LangChain ecosystem) gives you a graph-based state machine where you explicitly control node transitions, tool call loops, and state accumulation.
- CrewAI abstracts agents into role-based “crews” with an opinionated task delegation model and automatic inter-agent messaging.
- AWS Bedrock Agents is a fully managed service with native AWS integrations, automatic prompt engineering via the Bedrock console, and built-in guardrails.
Each choice creates different token overhead profiles — and that’s what most benchmark articles miss.
Benchmark Methodology
All tests were run over a two-week period with traffic routed through a consistent instrumentation layer capturing:
- Input tokens per task run (system prompt + conversation history + tool definitions)
- Output tokens per task run (model completions including intermediate reasoning steps)
- Tool call count (number of discrete tool invocations per task)
- End-to-end wall clock latency (user request to final response delivery)
- P95 latency (to catch tail behavior under load)
The underlying model for primary benchmarks was Claude Sonnet 4.6 with temperature 0 for consistency. I’ll call out where GPT-4o produced meaningfully different results.
Workload definitions:
| Workload | Avg Task Complexity | Avg Tool Calls Expected | Volume |
|---|---|---|---|
| Support Triage | Low | 1–2 | 500 tasks/day |
| Research Synthesis | High | 4–8 | 50 tasks/day |
| Code Review Orchestration | Medium-High | 3–6 | 100 tasks/day |
Token Usage: The Real Numbers
LangGraph
LangGraph’s explicit graph model is both its strength and its cost liability. Because state is threaded through every node transition as a serialized dict, the full accumulated state is re-injected into the model context on every node invocation. For simple linear graphs this is negligible. For graphs with five or more nodes that share state, you’re paying for context re-injection on every hop.
In the support triage workload (simple, 1–2 tool calls), LangGraph was the most token-efficient of the three frameworks — averaging 1,840 input tokens per task against an identical baseline of ~1,200 tokens for the core task content. The overhead (640 tokens) comes from system prompt structure and tool schema injection, which is comparable to raw API usage.
In the research synthesis workload, the story reverses. With 6–8 node hops and 400–600 tokens of accumulated state, LangGraph tasks averaged 8,900 input tokens per run — the highest of the three. The culprit is predictable: state dict serialization bloat. If you’re not pruning your state schema aggressively, you’re paying for it at every node.
LangGraph mitigation: Use Annotated state fields with custom reducers to trim irrelevant fields before they propagate. Dropping three unnecessary state keys from a research graph reduced per-task input tokens by 22% in my tests.
CrewAI
CrewAI’s inter-agent communication model introduces a different kind of token overhead: task delegation messages. When a manager agent routes a task to a subordinate agent, it generates a delegation prompt that includes the original task context, the agent’s role description, and any shared crew memory. For a 3-agent crew, this means roughly 2–3x the base task tokens are consumed across the crew before the actual work begins.
In the support triage workload, CrewAI averaged 2,340 input tokens per task — 27% higher than LangGraph. The overhead is the crew setup cost: even for simple tasks, CrewAI initializes agent roles and backstory prompts on every invocation if you’re not using persistent crew sessions.
In the research synthesis workload, CrewAI performed better than expected: 7,200 input tokens per run, about 19% fewer than LangGraph. The reason: CrewAI’s hierarchical task delegation naturally scopes each sub-agent’s context window to its specific subtask rather than threading the full state through every step. A researcher agent only sees the research subtask, not the entire accumulated synthesis state.
CrewAI mitigation: Set memory=True on your Crew and configure a persistent session store. This amortizes the agent role initialization cost across multiple tasks from the same user, cutting per-task overhead by 15–30% for repeat workloads.
AWS Bedrock Agents
Bedrock Agents has the most opaque token model of the three. AWS manages prompt engineering internally — you define the agent’s instructions and action group schemas via the console or CDK, and Bedrock constructs the actual prompts at runtime. This is both a convenience and a cost hazard.
In my instrumentation (using CloudWatch Logs and the modelInvocationInput logging feature), Bedrock Agents injected substantially larger system prompts than the other frameworks — averaging 3,100–3,600 tokens of framework-managed system content per invocation, before your custom instructions. This is the Bedrock orchestration prompt, which includes the ReAct-style reasoning scaffold, action group definitions, and guardrail instructions.
For the support triage workload, this made Bedrock Agents the most expensive per-task: 4,100 input tokens on average — more than 2x LangGraph. For simple, high-volume workloads, that overhead is hard to justify.
For the research synthesis workload, however, Bedrock’s pre-built orchestration logic means the agent reliably completed tasks in fewer model invocations than the other frameworks — 4.2 average vs. 5.8 for LangGraph and 6.1 for CrewAI. When you multiply tokens-per-invocation by invocations-per-task, Bedrock’s total task cost was competitive at 9,100 input tokens per run, slightly higher than CrewAI but with less engineering effort required.
Bedrock mitigation: Use action group consolidation. Each additional action group adds to the system prompt size. Merging 8 fine-grained tools into 3 broader action groups reduced average input tokens by 18% in the code review workload.
Inference Latency: Where the Gap Widens
End-to-End Latency by Workload
| Framework | Support Triage P50 | Support Triage P95 | Research Synthesis P50 | Research Synthesis P95 |
|---|---|---|---|---|
| LangGraph | 2.1s | 4.8s | 18.4s | 34.2s |
| CrewAI | 3.4s | 7.1s | 22.6s | 41.5s |
| Bedrock Agents | 3.9s | 6.2s | 16.8s | 28.7s |
LangGraph’s Python-native execution model gives it the best P50 latency for simple tasks — there’s no network hop to a managed service, and graph node transitions are in-process. For a support triage bot where you need sub-3-second responses at median, LangGraph on a well-provisioned container wins.
CrewAI’s P95 numbers concern me for latency-sensitive workloads. The hierarchical agent communication introduces queueing behavior: if a sub-agent’s task takes longer than expected, the manager agent blocks waiting for the response. Under load, this serialization creates latency spikes that don’t appear in P50 measurements.
Bedrock Agents has the best P95 behavior for complex workloads — a full 16% tighter than LangGraph at the tail. AWS’s managed infrastructure handles retries and routing transparently, and the pre-built orchestration loop is highly optimized. For long-horizon tasks where reliability matters more than absolute speed, Bedrock’s tail latency advantage is real.
The “Cold Start” Problem
Both LangGraph and CrewAI require your orchestration infrastructure to be warm. If you’re running them on containers that scale to zero, cold starts add 2–8 seconds to first-request latency. Bedrock Agents has no cold start — it’s fully serverless. For workloads with spiky traffic patterns (e.g., business-hours support queues), this can flip the economics: Bedrock’s higher per-token cost may be offset by zero infrastructure management and no cold-start penalty.
Cost Per Task: Putting It Together
Assuming Claude Sonnet 4.6 pricing ($3/M input tokens, $15/M output tokens) and averaging output tokens at roughly 35% of input across workloads:
| Framework | Support Triage Cost/Task | Research Synthesis Cost/Task |
|---|---|---|
| LangGraph | $0.0071 | $0.0344 |
| CrewAI | $0.0090 | $0.0278 |
| Bedrock Agents | $0.0158 | $0.0351 |
At 500 support triage tasks/day, LangGraph saves roughly $14/day vs. Bedrock — about $5,100/year. That’s not nothing, but it also doesn’t account for the engineering hours required to build and maintain a robust LangGraph deployment vs. a Bedrock console configuration.
The research synthesis comparison is more interesting: CrewAI’s natural context scoping makes it genuinely cheaper per task than LangGraph for complex multi-agent workflows, despite being more expensive for simple ones.
Framework Selection: Decision Framework for Cost-Conscious Teams
Choose LangGraph when:
- Your workloads are high-volume and low-complexity (support triage, classification, simple Q&A routing)
- You have engineering resources to instrument and maintain a custom graph
- Latency SLAs are tight (sub-3s P50)
- You’re already in the Python/LangChain ecosystem
Choose CrewAI when:
- Your workloads involve genuine multi-agent collaboration with distinct roles
- Tasks naturally decompose into subtasks that can be scoped independently
- You want faster time-to-production with less graph engineering overhead
- Research, analysis, or content generation workflows with 4+ distinct phases
Choose Bedrock Agents when:
- Your infrastructure is AWS-native and you want managed scaling
- Tail latency reliability matters more than median speed
- You need built-in compliance, guardrails, and audit logging
- Engineering headcount for framework maintenance is limited
The Token Optimization Moves Nobody Talks About
Regardless of framework, three optimizations had the largest impact across all my benchmarks:
1. Aggressive tool schema trimming. Tool descriptions contribute directly to input tokens on every invocation. Cutting verbose parameter descriptions from 80 words to 15 words per tool reduced input tokens by 8–12% across all frameworks without measurably impacting tool call accuracy.
2. System prompt compression. Run your static system prompts through a compression pass — remove redundant instructions, merge overlapping directives, eliminate examples that don’t change model behavior. I routinely cut 20–30% of system prompt tokens without capability regression.
3. History windowing. All three frameworks will happily send your entire conversation history on every invocation if you let them. Implement a sliding window (last 4–6 turns) plus a compressed summary of earlier context. For multi-turn workflows, this was the single biggest lever — reducing input tokens by 30–45% in research workloads.
What’s Coming: Prompt Caching and Its Impact on These Numbers
It would be incomplete to publish these benchmarks without noting that prompt caching (now supported on Claude and GPT-4o) changes the calculus significantly for frameworks with stable system prompts. Cached input tokens cost ~90% less than uncached. LangGraph’s explicit state control makes it easiest to architect cache-friendly prompts; Bedrock Agents’ managed prompt engineering currently offers limited cache control. Watch this space — the frameworks that expose fine-grained cache breakpoints will have a meaningful cost advantage in 2026 production deployments.
Final Verdict
There is no universally cheapest framework — but there are clearly wrong choices for specific workloads. Running Bedrock Agents for a high-volume, simple support triage workload at scale will cost you 2x what LangGraph costs for the same work. Using LangGraph for a complex 6-agent research workflow without aggressive state management will cost more than CrewAI and require more engineering to maintain.
The right framework decision is a function of workload complexity, team size, infrastructure context, and latency requirements. Run these benchmarks against your own representative task distribution before committing to an architecture — the numbers will differ from mine, but the methodology will hold.
Related Benchmarks and Guides
- LangGraph vs AutoGen: State Management and Memory Architecture Compared
- CrewAI Production Deployment: Scaling Crews Without Breaking Your Inference Budget
- AWS Bedrock Agents Deep Dive: What the Managed Orchestration Prompt Actually Costs You
Alex Rivera is a Framework Analyst at agent-harness.ai. He runs production benchmarks across AI agent frameworks and publishes hands-on evaluation guides. Have a framework you want benchmarked? Submit a request.