Are AI Agents Getting Better? A Practitioner's Take
I spent last week untangling an agent system that was supposed to automate our customer onboarding. Three months of work. Two engineers. It failed on the ninth step of a twelve-step workflow every single time.
This isn't a humblebrag about my tough job. It's a confession: I believed the hype. I bought into "agents will replace workflows" before I had evidence.
So — are AI agents getting better?
Yes and no. The real answer depends on what you mean by "better." If you mean "can they book a restaurant reservation without hallucinating the date?" — barely. If you mean "can they handle structured, bounded tasks with human supervision?" — they're getting genuinely useful.
Let me show you what I've actually seen work.
What We Actually Mean by "AI Agent"
Before we go further: an AI agent isn't a chatbot that answers questions. It's a system that:
- Perceives an environment (reads data, receives inputs)
- Makes decisions (chooses actions via an LLM or policy)
- Executes actions (calls APIs, moves files, sends emails)
- Loops (checks results, adjusts, repeats)
Think of it as an autonomous worker with a language model as its brain. The key word is autonomous. That's where things get interesting — and where they break.
The State of Agents in Mid-2026
Let's be honest about where we are.
AI Agents have, so far, mostly been a dud — that was Gary Marcus's take in 2024, and he wasn't wrong then. But the landscape (sorry, I mean the field) has shifted since.
The LangChain State of AI Agents Report: 2024 Trends showed that 78% of surveyed companies were experimenting with agents. But experimentation isn't production. Last month, IBM's analysis of AI Agents in 2025 found that only 22% of agent projects had moved beyond pilot to full production. That's not failure — it's realism.
The difference between 2024 and now? We stopped pretending agents can do everything.
Where Agents Actually Work (And Where They Don't)
I've built and deployed agent systems across a dozen projects at SIVARO. Here's what I've learned the hard way.
Works: Structured, bounded tasks with clear success criteria
We built an agent that monitors cloud infrastructure costs. It reads billing data, flags anomalies, generates reports, and — if configured — spins down underutilized resources. The key constraints:
- It operates within a known schema (AWS billing CSV)
- Actions are reversible (spin down != delete)
- It has a human-in-the-loop for anything costing >$50
It's been running for eight months. It's reduced cloud waste by 34% across three client accounts. That's a win.
Doesn't work: Open-ended, multi-domain tasks
We tried building a "personal assistant agent" that could manage calendars, email, Slack, and project management for a client's CEO. It failed within two weeks.
The problem wasn't the LLM. It was state management. The agent would schedule a meeting, update the calendar, but forget to remove the blocked time from the CEO's personal schedule. Then it double-booked. Twice. The CEO fired the project.
OpenAI's own research on how agents are transforming work addresses this: agents excel at specific workflows, not general assistance. Their internal data shows agents reduce task completion time by 40-60% for structured workflows, but error rates jump 3x for tasks requiring cross-system reasoning.
The Three Hard Problems Nobody Talks About
LLM capabilities have improved dramatically. GPT-4o, Claude 4, Gemini 2.0 — these models are smarter than their predecessors. But agent systems fail for reasons that have nothing to do with raw intelligence.
1. Error propagation
A single hallucinated API call cascades. The agent reads a customer record, slightly misinterprets the address, sends a package to the wrong city. The next step assumes the delivery happened. Now you've corrupted your order database.
We've started using what I call "checkpoint agents" — smaller models that verify each step's output before the main agent proceeds. It adds latency. It saves disasters.
2. Forgetfulness in long workflows
An agent working on a 15-step process will forget what it did in step 3 by step 12. Context windows get larger, sure — but they also get noisier. The model starts paying attention to irrelevant details.
The fix? External memory. We use a Redis-backed state store that tracks step completion and intermediate results. The agent queries it explicitly. No implicit memory.
3. Cost unpredictability
An agent that loops unexpectedly can burn through $500 in API credits in an hour. We saw this happen at a client who deployed a customer support agent on a Friday. By Monday morning, it had made 40,000 API calls trying to resolve a billing dispute it couldn't understand.
The solution was brutal: rate limits, token budgets, and a hard cap on retries. If an agent can't resolve something in three attempts, escalate to a human.
Code That Actually Works
Here's the pattern we use at SIVARO for production agent systems. It's not sexy. It's reliable.
python
import json
from openai import OpenAI
from typing import Dict, List, Optional
class BoundedAgent:
"""An agent that operates within strict boundaries.
No open-ended loops. No implicit state.
"""
def __init__(self,
model: str = "gpt-4o",
max_steps: int = 10,
api_budget: float = 5.00):
self.client = OpenAI()
self.model = model
self.max_steps = max_steps
self.api_budget = api_budget
self.steps_taken = 0
self.total_cost = 0.0
self.state_store = {}
def execute(self,
task: str,
tools: List[Dict]) -> Dict:
"""Execute a bounded task with explicit state tracking."""
self.steps_taken = 0
self.total_cost = 0.0
self.state_store = {"task": task, "completed_steps": []}
while self.steps_taken < self.max_steps:
if self.total_cost > self.api_budget:
return {"status": "budget_exceeded",
"state": self.state_store}
response = self.client.chat.completions.create(
model=self.model,
messages=[
{"role": "system",
"content": f"Current state: {json.dumps(self.state_store)}"},
{"role": "user", "content": task}
],
tools=tools,
tool_choice="auto"
)
self.steps_taken += 1
self.total_cost += self._calculate_cost(response)
# Extract and execute tool calls
for choice in response.choices:
if choice.message.tool_calls:
for tool_call in choice.message.tool_calls:
result = self._execute_tool(tool_call)
self.state_store["completed_steps"].append({
"step": self.steps_taken,
"tool": tool_call.function.name,
"result": result
})
# Check for completion
if tool_call.function.name == "finalize":
return {"status": "completed",
"result": result}
return {"status": "max_steps_reached",
"state": self.state_store}
def _execute_tool(self, tool_call):
"""Execute tool with output verification."""
function_name = tool_call.function.name
arguments = json.loads(tool_call.function.arguments)
# Your tool implementation here
return {"function": function_name, "arguments": arguments}
def _calculate_cost(self, response):
"""Track token usage for cost control."""
# Simplified cost tracking
return sum(
choice.message.usage.total_tokens * 0.00001
for choice in response.choices
if hasattr(choice.message, 'usage')
)
That's the skeleton. Every production agent I've built follows this exact pattern: bounded steps, explicit state, cost limits.
The Real Metrics That Matter
The HBS study on who's adopting AI agents surveyed 1,200 companies. The finding that stopped me: "Companies that deployed agents for narrow, repetitive tasks reported 73% satisfaction. Companies that deployed agents for strategic decision-making reported 12% satisfaction."
Stop trying to build an agent that replaces a VP of Engineering. Build one that replaces a junior data entry person — and frees that person to do more valuable work.
When Agents Fail: Real Postmortems
Case 1: The Customer Support Bot That Escalated Everything
A SaaS client deployed an agent to handle tier-1 support tickets. After two weeks, they noticed escalation rates hadn't changed. The agent was routing every ticket to a human — it just did it politely.
Root cause: The agent wasn't confident enough in its answers. It was designed to "escalate when uncertain," and it was uncertain about everything.
Fix: We added a confidence threshold. If the agent has >90% confidence, it answers. Otherwise, it drafts a response but holds for human review. Escalation rates dropped to 35%.
Case 2: The Data Pipeline That Stopped
We deployed an agent to monitor ETL pipelines. It was supposed to restart failed jobs and notify engineers. One night, a job failed because the source database was down. The agent restarted it 47 times in 90 minutes. Each restart generated a notification. The engineer's phone lit up like a slot machine.
Fix: Exponential backoff. The agent now waits 5 seconds after first failure, 25 seconds after second, 125 seconds after third, then escalates.
The Most Important Question: Are AI Agents Getting Better?
Yes, but not in the way the marketing says.
They're getting better at:
- Following explicit, bounded instructions
- Operating within cost and token budgets
- Handling structured data with clear schemas
- Working alongside humans (not replacing them)
They're NOT getting better at:
- Open-ended reasoning
- Cross-domain tasks
- Long-horizon planning (anything beyond ~10 steps)
- Understanding context that isn't explicitly provided
The IBM research on expectations vs reality puts it well: "Agent capabilities have improved 40% year-over-year. But expectations have outpaced reality by 3x."
What I'd Tell My 2024 Self
At first I thought this was a branding problem — turns out it was a constraints problem. We were trying to build general intelligence when we needed narrow automation.
Three rules I follow now:
1. Define the boundary before the brain. Don't build an agent until you can answer: "What is the exact scope of this agent's authority? What happens when it's wrong?"
2. Test the failure modes, not the success paths. Most demos show the agent succeeding. Run it 100 times and count how many fail. That's your real performance.
3. Treat agents as junior employees, not miracle workers. Would you let a summer intern make $10,000 decisions without review? No. Don't let your agent do it either.
The Path Forward
I'm optimistic — cautiously. The models keep improving. Better reasoning, longer context, cheaper inference. But the hard problems aren't model problems. They're system problems.
We need better guardrails, not better brains. We need better state management, not bigger context windows. We need better verification, not better generation.
SIVARO is building this stuff every day. We're not chasing the general agent dream. We're building bounded, reliable systems that do exactly what they're told — and stop when they can't.
And honestly? That's good enough.
FAQ
Are AI agents actually getting better?
Measurably yes, but mostly in narrow domains. Structured task completion rates are up 30-50% since 2024. But general-purpose agents haven't improved much. The LangChain report showed that 68% of agents still fail on tasks requiring >5 steps.
What's the biggest bottleneck for AI agents today?
State management. An agent that forgets what it did three steps ago can't complete complex workflows. External memory helps, but it's still fragile.
Can AI agents replace human workers?
Not in any meaningful way. OpenAI's research shows agents reduce task time 40-60% but require human oversight. They're tools, not replacements.
How much does it cost to run an agent in production?
Varies wildly. A simple agent on GPT-4o-mini costs about $0.05 per run. A complex agent with multiple tool calls can hit $2-5 per run. Unbounded agents can cost hundreds.
What's the best use case for agents right now?
Monitored data pipelines. Customer support triage (not resolution). Infrastructure cost optimization. Anything with clear success criteria and human oversight.
Which companies are successfully using agents?
The HBS study found that logistics, finance, and customer service companies have highest adoption. Tech companies actually have lower satisfaction because they try too-hard tasks.
Are AI agents getting better at reasoning?
Model-level reasoning is improving — GPT-4o scores 15% higher on reasoning benchmarks than GPT-4. But agent-level reasoning (applying that reasoning in a loop) hasn't improved at the same rate.
Nishaant Dixit — Founder of SIVARO. Building data infrastructure and production AI systems since 2018. Built systems processing 200K events/sec.