After the explosion of large models, many people are shouting that “AI Agents are the future,” and even NVIDIA CEO Jensen Huang has asserted that agents will create a trillion-dollar market. However, from the perspective of frontline developers, the reality is far from optimistic.
Recently, an engineer who has built over 12 production-level AI Agent systems in development, operations, and data management expressed his skepticism about the upcoming wave of agents in 2025—he believes that the current concept of “autonomous agents” is fundamentally flawed mathematically, and that agents capable of running stably in production environments are not at all what is being promoted on the market today.
Original link:https://utkarshkanwat.com/writing/betting-against-agents/
Scan to join the AI study group
Many people say, “2025 is the year of AI agents.” Various news articles have headlines like:
“AI agents will completely change the way we work”
“Agents are the next big wave in AI”
“The future belongs to agents”
Yet I have just spent a year figuring out which agents can actually be used in production environments, and for this reason, I am not optimistic about this trend.
1
I am not a contrarian; I have actually done the work
In the past year, I have developed several deployed agent systems that cover the entire software development process, such as:
·Development agents: generating React components from natural language, refactoring old code, automatically maintaining API documentation, generating functions from specifications.
·Data and infrastructure agents: automatically executing complex SQL, handling database migrations, managing infrastructure code (IaC) with AI, and supporting multi-cloud environments.
·Quality and process agents: AI-driven CI/CD pipelines, automatically fixing lint issues, generating tests, conducting code reviews, and writing PR descriptions.
These systems are indeed functional and create real value, saving several hours of manual work each day. For this reason, I believe that the external narrative calling 2025 the “year of AI agents” overlooks many critical realities.
2
Key Takeaways: Three Harsh Realities About AI Agents
After building over 12 production-level systems, I have drawn the following conclusions:
·The error rate in multi-step processes will amplify exponentially. Even if each step has a success rate of 95%, by the 20th step, the overall success rate drops to only 36%. Production environments typically require a starting reliability of 99.9%.
·The token costs associated with context windows grow quadratically. The longer the conversation, the higher the costs, leading to staggering expenses at scale.
·The biggest challenge is not the AI’s capabilities but how to design tools and feedback systems that agents can genuinely use.
3
A Mathematical Reality No One Wants to Face
All companies working on AI agents are avoiding an uncomfortable truth: in production-level multi-step tasks, the accumulation of errors makes “fully autonomous agents” mathematically unfeasible.
Error accumulation in AI agent processes
Let’s do the math. If the reliability of each step in an agent’s process is 95% (which is already optimistic for current large models), then the overall success rate is:
·5-step process, success rate approximately 77%
·10-step process, success rate approximately 59%
·20-step process, success rate only 36%
Production environments typically require reliability above 99.9%. Even if you miraculously achieve a 99% success rate at each step (which no one has done), the overall success rate for 20 steps would still only be 82%. This is not a prompt design issue or a model capability issue; it is a mathematical reality.
The DevOps agent I developed works precisely because it is not a fully automated 20-step process. It is broken down into 3-5 independent, verifiable operations with clear rollback points and human confirmation steps. The agent is responsible for generating complex infrastructure code, but the entire system architecture is designed around this mathematical limitation of reliability.
Every successful agent system I have built follows the same pattern: clear contextual boundaries, verifiable operational steps, and human decision points at critical junctures. Once you attempt to have an agent autonomously string together complex operations beyond a few steps, mathematics will let you down.
4
Long Conversations Mean Exploding Costs
Another mathematical reality that many AI agent proponents deliberately ignore is that context windows lead to quadratic growth in token costs, making conversation-based agents economically unfeasible.
Specifically, creating a “chatting” agent encounters the following issues:
·Each new interaction must process all previous context
·Token consumption grows quadratically with conversation length
·A 100-turn conversation could incur token costs of $50 to $100
·With many users, thousands of them, these costs become completely unsustainable
When I was developing a prototype for a conversational database agent, I experienced this firsthand.
Initially, the costs for a few interactions were low, but by the 50th request, each response was costing several dollars, far exceeding the value it could provide. In most scenarios, this economic model simply does not work.
The reason my function-generating agent succeeded is that it is completely stateless: input description – output function – process ends. There is no context to maintain, nor is there a need to track conversations, avoiding cost explosions. It is not an experience of “chatting with code” but rather a tool focused on solving specific problems.
In fact, the most successful agents in production environments often do not rely on conversation at all. They are smart, bounded tools that focus on doing one thing well and then exit cleanly without dragging things out.
5
The Biggest Challenge is Not Model Capability, But Tool Design
Even if you solve the above two mathematical problems, you still face a reality: for AI to use tools effectively, there must be appropriate interfaces and feedback systems. However, many teams currently underestimate this challenge.
Current tool calls are already quite precise; the real difficulty lies in tool design. Each tool must be meticulously crafted to provide appropriate feedback without overwhelming the context window with information. You need to consider:
·How does the agent know that an operation was only partially successful? How can it convey complex state changes without wasting a lot of tokens?
·For example, a database query might return 10,000 records, but the agent only needs to know, “Query successful, 10,000 results, here are the first 5.” Designing such abstractions is an art.
·When a tool fails, what information does the agent need to recover? Too little information will cause it to stall, while too much will waste context resources.
·How to handle interdependent operations? For example, database transactions, file locks, resource dependencies.
The reason my database agent works is not that tool calls are error-free, but because I spent weeks designing tool interfaces that can effectively communicate with AI. Each tool returns structured feedback that the agent can genuinely use for decision-making, rather than just receiving a pile of raw API responses.
Those companies claiming that “connecting to APIs will allow agents to handle everything” have never done this kind of engineering work.They treat tools as human-computer interaction interfaces rather than designing them for AI. As a result, while agents may superficially succeed in calling APIs, they cannot truly complete complex processes because they do not understand what is happening.
Every agent system in a production environment has an unspoken truth: AI may only do 30% of the work, while the remaining 70% involves tool engineering—designing feedback interfaces, efficiently managing context, handling partial failures, and building recovery mechanisms that AI can understand and utilize.
6
Integration with Reality is a Test
Assuming you have solved the reliability and economic issues, you will face an even greater challenge—integrating with real-world systems, which are often complex and problematic.
Enterprise systems are not a clean set of APIs waiting for AI agents to coordinate. They are mostly legacy systems with various quirks, fault modes, ever-changing authentication processes, time-varying access frequency limits, and compliance requirements that cannot be easily fit into simple prompt templates.
My database agent does not just “automatically execute queries.” It also has to handle connection pool management, transaction rollbacks, read-only replicas, query timeouts, and log all operations for auditing. AI is responsible for generating query statements; everything else relies on traditional system programming.
Those boasting that “fully automated agents can seamlessly integrate your entire tech stack” are either overly optimistic or have never truly tested this in large-scale production environments. In reality, integrating with real-world scenarios is often the graveyard of AI agents.
7
What is Truly Feasible (and Why)
After working on over a dozen agent systems covering the entire software development lifecycle, I have found that successful projects share common characteristics:
The reason my UI generation agent works is that every interface is reviewed by a human before going live. AI is responsible for converting natural language into usable React components, but the final user experience is overseen by humans.
The reason my database agent is reliable is that every destructive operation is confirmed beforehand. AI translates business requirements into SQL, but data integrity is ensured by humans.
The reason my function-generating agent works is that it operates within clear boundaries: give it a specification, and it outputs a function. No side effects, no state management, and no complex integration.
The reason my DevOps automation agent works is that it generates infrastructure as code (IaC) that can be reviewed, version-controlled, and rolled back. AI translates requirements into Terraform code, but the deployment process is backed by our years of accumulated security mechanisms.
My CI/CD agent has clear success criteria and rollback mechanisms. AI analyzes code quality and generates repair suggestions, but the final decision to merge is controlled by the pipeline.
In summary:
AI handles complex problems, humans control key decisions, and traditional software engineering ensures system stability and reliability.
8
My Predictions
Here are my specific predictions and judgments about who will struggle in 2025:
·Those startups backed by venture capital, claiming to have “fully autonomous agents,” will be the first to hit economic bottlenecks. Their demos may work well for processes with fewer than five steps, but what customers truly need are complex processes with more than 20 steps, which cannot be sustained mathematically. To address these insurmountable reliability issues, their burn rate will skyrocket.
·Companies that force “AI agents” into existing enterprise software products will see user acceptance stagnate. Their agents simply cannot deeply integrate and handle real workflows.
·The winners will be those teams building constrained, domain-specific tools,which use AI to tackle difficult problems while maintaining strict boundaries on human control or key decisions. In other words,not “fully automated everything,” but rather “powerful assistants with clear boundaries.”
·The market will ultimately learn to distinguish between “visually impressive” AI and “truly stable and usable” AI, and this process will be costly for many companies.
I am not pessimistic about AI; I am skeptical about the current approaches to agent architectures. However, I believe the future will be far more valuable than the current hype.
9
The Right Way to Build
If you plan to create AI agents, start with these principles:
·Define boundaries: What can your agent do, and which parts should be handled by humans or deterministic systems?
·Design for fault tolerance: AI errors may account for 20-40% of cases; how will you respond? Is there a rollback mechanism?
·Address economic issues: How much does each interaction cost, and how will costs scale with user growth? Stateless designs are often more economical than stateful ones.
·Prioritize reliability over autonomy: Users trust stable and usable tools more than systems that occasionally produce miraculous results.
·Build a solid foundation: AI handles the difficult parts (understanding intent, content generation), while key processes (execution, error handling, state management) still rely on traditional software engineering.
The agent revolution will come; it just won’t be as glamorous as the 2025 hype suggests, and for that reason, it is more likely to succeed.
1
END
1
This article is reprinted from: CSDN Knowledge Base WeChat Official Account.
Original link: https://utkarshkanwat.com/writing/betting-against-agents/