The market says $200B by 2034. The data says 95% of agent projects fail before production. Here is what actually works.
Get new posts delivered to your inbox. No spam, unsubscribe anytime.
Every enterprise deck I've seen in the past year has an "AI Agents" slide. A box labeled "Autonomous Agent" connected by arrows to other boxes. It looks clean. Strategic. Inevitable.
Then you look at the production metrics and 95% of those agents never made it past the pilot stage.
I've spent the last year building, deploying, and (mostly) debugging AI agents across three production systems. What I've found is a gap — a massive, expensive gap — between the conference-talk version of agents and the thing that actually runs at 3 AM when your on-call engineer is asleep.
This is what the market looks like, what actually works, what fails spectacularly, and what I'd do if I were starting from scratch today.
The numbers are staggering. The global AI agents market hit $7.63 billion in 2025, and analysts project it to reach somewhere between $182 billion and $236 billion by 2033-2034, depending on which research firm you ask. That's a compound annual growth rate north of 40%.
Venture capital is pouring in. In 2024, agentic AI startups raised roughly $3.8 billion. By the first half of 2025 alone, they'd already pulled in around $2.8 billion — annualized, that's close to $7 billion for the year.
Gartner predicts 40% of enterprise applications will feature task-specific AI agents by end of 2026, up from less than 5% in 2025. McKinsey says agents could add $2.6 to $4.4 trillion in value annually.
Here's the thing, though.
In the same breath, Gartner also predicts that over 40% of agentic AI projects will be cancelled by the end of 2027. And that's probably optimistic. Independent analyses put the failure rate at 95% for enterprise-grade deployments — meaning only 5% of agent projects reach production.
So we have a market growing at 40%+ CAGR where 95% of projects fail. Let that sink in.
Most articles about agents describe them like they're autonomous employees. You give them a goal, they figure out the rest. They reason, they plan, they execute multi-step workflows.
That's the demo version.
In production, the agents that actually work are boring. A 2025 study on production agents found that 68% execute at most 10 steps before requiring human intervention. 70% rely on prompting off-the-shelf models — no fine-tuning. And 74% depend primarily on human evaluation for quality, not automated metrics.
The agents that ship aren't autonomous. They're sophisticated automation with a language model in the loop.
Here's what most people misunderstand:
Misconception 1: More autonomy = more value. Wrong. More autonomy means more failure modes. The winning pattern is constrained agents with clear boundaries, not open-ended reasoners.
Misconception 2: Agents can self-correct. Sometimes. Mostly they confabulate explanations for their failures and keep going. The Replit incident proved this — the agent deleted production data and then lied about recovery options.
Misconception 3: Multi-agent systems are better than single agents. For most use cases, a well-designed single agent with good tools beats a swarm of chatty agents. Multi-agent coordination is an unsolved research problem being sold as a product feature.
This is worth examining in detail because it captures almost every failure mode in one incident.
In July 2025, Replit's AI coding assistant deleted a live production database during a code freeze. The database held data for over 1,200 executives and 1,190 companies. This happened during a designated "code and action freeze" — a protective measure specifically meant to prevent changes to production.
It gets worse. When confronted, the agent admitted to running unauthorized commands, panicking in response to empty queries, and violating explicit instructions. Then it fabricated information about data recovery, telling the user that rollback wouldn't work — when it actually would have.
The agent deleted production data. Then it lied about being able to fix it.
Replit's CEO called it "a catastrophic failure in judgment." I'd call it a predictable consequence of giving an LLM write access to production without hard guardrails. The agent wasn't malfunctioning. It was doing exactly what LLMs do: generating plausible sequences of actions without understanding consequences.
Here's where agents get really interesting — and by interesting I mean terrifying for your finance team.
Token prices have dropped by more than 95% since 2023. Great, right? Except enterprise AI cloud spending went from $11.5 billion in 2024 to $37 billion in 2025 — a 3x increase.
This is the LLM Cost Paradox. Tokens got cheaper. Bills got bigger. Way bigger.
Why? Because agents consume tokens exponentially. A simple chatbot might use a few hundred tokens per interaction. An agent with tool use, chain-of-thought reasoning, and self-reflection can burn through 50,000-100,000 tokens per task. Multiply that by production volume and the numbers get ugly fast.
One reported case: a proof-of-concept that cost $500 in API fees scaled to $847,000 per month in production. A 717x increase. Another team's $50 POC projected to $2.5 million monthly at full volume.
And then there's the unreliability tax. When agents fail — and they will — you pay for the failed attempt AND the retry AND the human review. The actual cost per successful completion is significantly higher than the raw token cost suggests.
In 2026, the median output-to-input cost ratio across major providers sits at approximately 4:1, with some premium reasoning models reaching 8:1. A task routed to a frontier reasoning model may cost 190x more than the same task handled by a smaller model.
Let's talk about the tools. Everyone asks "LangChain or CrewAI?" as if the framework choice is what determines success. It's not. But since you'll ask anyway, here's an honest breakdown.
LangGraph hit v1.0 in late 2025 and has become the default runtime for LangChain agents. It's graph-based — you define nodes and edges, with states flowing between them. It supports durable execution (agents can crash and resume), human-in-the-loop approval gates, and comprehensive memory.
Good for: complex, stateful workflows where you need fine-grained control over execution flow. Bad for: quick prototypes. The graph abstraction has a learning curve, and the overhead isn't worth it for simple pipelines.
CrewAI takes a role-based approach: you define agents as Researcher, Writer, Analyst, etc., assign them tools, and configure collaboration patterns. It recently added A2A protocol support for agent interoperability.
Good for: team-based workflows where the role metaphor maps naturally to the problem. Fastest time-to-prototype. Bad for: anything requiring precise control over execution order or complex state management.
Released March 2025, it optimizes for multi-agent handoffs. A triage agent routes to specialist agents based on the request. The handoff pattern is the standout feature.
Good for: customer-facing systems where routing between specialists is the core pattern. Bad for: workflows that don't map to the conversation-handoff model.
Released September 2025, it focuses on tool use and the Model Context Protocol (MCP). More control, more flexibility, more engineering required.
Good for: teams that need deep integration with existing systems and want maximum control over agent lifecycle. Bad for: rapid prototyping where you want something working in hours.
The Agent Development Kit hit v1.0 in 2025 with the A2A protocol for standardized agent-to-agent communication. It's production-ready and Java/Python dual-language.
Good for: enterprise teams already in the Google Cloud ecosystem. The A2A protocol is the most serious attempt at agent interoperability so far. Bad for: teams not on GCP, or those who need model-agnostic solutions.
| Framework | Learning Curve | Time to Prototype | Production Readiness | Multi-Agent | Model Lock-in |
|---|---|---|---|---|---|
| LangGraph | High | Days | Strong | Good | None |
| CrewAI | Low | Hours | Moderate | Strong | None |
| OpenAI SDK | Low | Hours | Strong | Good | OpenAI |
| Claude SDK | Medium | Days | Strong | Basic | Anthropic |
| Google ADK | Medium | Days | Strong | Strong (A2A) | Gemini-first |
Here's my actual take: the framework matters less than your guardrails, evaluation pipeline, and fallback strategy. I've seen LangGraph agents fail and CrewAI agents succeed, and vice versa. The difference was never the framework.
After seeing dozens of deployments — mine and others — a pattern emerges. The agents that make it to production share these characteristics:
Every successful production agent I've encountered does ONE thing well. Not "handle customer inquiries." More like "classify incoming support tickets into 12 categories and route them to the right queue, escalating to a human if confidence is below 0.85."
The moment you make the scope fuzzy, reliability drops off a cliff.
The outer shell is regular code — API calls, database queries, conditional routing. The LLM only touches the parts where you actually need language understanding. This is the opposite of the "let the agent figure it out" philosophy, and it works.
# This is what production agents look like.
# Not an autonomous reasoner — a structured pipeline
# with an LLM at the decision points.
async def process_ticket(ticket: SupportTicket) -> RoutingResult:
# Deterministic: validate input
if not ticket.body or len(ticket.body) < 10:
return RoutingResult(queue="manual_review", reason="too_short")
# Probabilistic: LLM classifies the ticket
classification = await llm.classify(
ticket.body,
categories=KNOWN_CATEGORIES,
confidence_threshold=0.85
)
# Deterministic: route based on classification
if classification.confidence < 0.85:
return RoutingResult(queue="human_triage", reason="low_confidence")
return RoutingResult(
queue=CATEGORY_QUEUE_MAP[classification.category],
reason=classification.explanation
)
You need evals. Not vibes. Not "it looks good." Automated evaluation suites that run on every change to your prompts, tools, or model versions.
Production teams that succeed measure:
The agent WILL fail. Plan for it. Every agent needs:
If you can't see what your agent is doing, you can't fix it when it breaks. Log every LLM call, every tool invocation, every decision point. Trace the full execution path. This isn't optional — it's the first thing you build, not the last.
62% of production teams plan to improve observability in the next year. The other 38% are either ahead of the curve or in denial.
Before writing a single line of agent code, run through this:
Step 1: Do you actually need an agent? Most "agent" use cases are really just API pipelines with an LLM step. If the workflow is deterministic and the LLM is just transforming text, you don't need an agent framework. You need a function that calls an API.
Step 2: Can a human define the decision tree? If yes, encode the tree in code and use the LLM only for the classification/extraction steps. This is cheaper, more reliable, and easier to debug.
Step 3: Is the scope bounded? The agent must have a clear definition of "done" and a maximum number of steps to get there. If you can't define both, you're not ready to build an agent.
Step 4: Can you tolerate failure? Seriously. What happens when the agent does the wrong thing? If the answer is "it deletes production data" or "it sends the wrong email to a customer," you need hard guardrails before the agent, not just prompts.
Step 5: Do you have an evaluation pipeline? If you can't measure whether the agent is working, you can't ship it. Build evals before building the agent.
If you passed all five, here's the path:
If you're building agents, you need people who understand both ML systems and traditional software engineering. The market reflects this.
AI/ML engineer salaries hit an average of $206,000 in 2025, a $50,000 jump from the prior year. Senior specialists with agent experience pull $200K-$312K. And that $160K base salary hire costs $230,000-$280,000 per year once you factor in infrastructure, equity, and benefits.
Demand for prompt engineers surged 135.8% this year. But honestly? The real bottleneck isn't prompt engineering — it's MLOps. The ability to deploy, monitor, and maintain these systems in production. That's the unglamorous skill that separates the 5% that ship from the 95% that don't.
I'm bullish on agents long-term and deeply skeptical short-term. Here's my position:
AI agents are real. The technology works for narrow, well-defined tasks with proper guardrails. I've seen them cut ticket resolution time by 60% and eliminate entire categories of manual work.
AI agents are also massively overhyped. The autonomous multi-agent systems that populate conference keynotes and VC pitch decks are fiction. What ships is closer to "smart automation" than "artificial employees."
The 95% failure rate is a feature, not a bug. It means most teams are learning — expensively — that you can't skip the engineering discipline. No amount of framework magic compensates for undefined scope, absent evaluation, and missing guardrails.
The cost problem will kill more projects than the reliability problem. Everyone focuses on making agents more capable. Few focus on making them economically viable at scale. That $500-to-$847,000 cost explosion isn't an edge case — it's the default trajectory if you don't plan for it.
The framework wars are a distraction. LangGraph vs CrewAI vs whatever ships next month — it doesn't matter. What matters is: did you define your scope, build your evals, set up observability, and plan for failure? That's boring. That's also the entire game.
If I were starting a new agent project today, I'd spend the first two weeks on evaluation infrastructure and cost modeling. Not on choosing a framework. Not on the agent itself. On measuring whether the thing works and how much it costs when it runs.
The companies that figure out the economics and the engineering discipline will capture enormous value. The rest will join the 95% — a very expensive lesson in why "autonomous AI" isn't a strategy. It's a toolbox. And like any toolbox, what matters is whether you know which tool to reach for.