The demos look flawless. An AI agent books a meeting, negotiates a contract, coordinates a logistics chain. Then you deploy it to production and watch it fall apart in ways nobody anticipated.
After Google Cloud NEXT '26, every serious engineering team is building agent systems. The tools are there. The hype is deafening. But most of these systems will fail, not because the models aren't good enough, but because production environments expose gaps that demos never touch.
The Cascade Problem
The first failure mode is cascade errors. An agent makes one bad call early in a workflow - maybe it misinterprets a customer's urgency, maybe it prioritises the wrong task - and every subsequent decision compounds the error. In a demo, you restart. In production, the agent keeps going, making twenty more decisions based on that first mistake.
Traditional software fails predictably. You trace the stack, find the bug, fix it. Agent systems fail in ways that are hard to reproduce because the decision path changes with context. The same input can trigger different reasoning depending on what the model has "learned" from recent interactions. That makes debugging feel like chasing smoke.
Decision Unpredictability
Here's what Google's demos don't show you: the moments when the agent does something technically correct but contextually bizarre. It optimises for the metric you gave it, ignoring the unspoken constraints that any human would understand.
You tell an agent to schedule meetings efficiently. It books three back-to-back calls across four time zones, leaving no gap for lunch or preparation. Technically efficient. Practically unusable. The model followed the instruction. The instruction was incomplete.
This isn't a training problem. It's a specification problem. Humans operate with massive amounts of implicit context - social norms, organisational priorities, unspoken trade-offs. Agents don't. And writing that context into prompts turns out to be much harder than anyone expected.
The Observability Gap
When a database query fails, you get a stack trace. When an agent makes a bad decision, you get... a conversation log. Maybe. If you instrumented it properly. Which most teams don't, because they're focused on making the agent work, not on making it observable.
The problem is that agents aren't just executing code. They're reasoning through multi-step processes, weighing trade-offs, making judgment calls. To debug them, you need to see not just what they decided, but why. That requires logging at a level of granularity most teams haven't built infrastructure for.
Google's tools give you metrics - latency, token usage, error rates. They don't give you insight into the agent's reasoning path. They don't tell you which context window shaped the decision. They don't flag when the model's confidence dropped but it made the call anyway.
That's not an oversight. It's a hard problem. But without it, you're flying blind.
The Missing Governance Layer
The biggest gap isn't technical. It's governance. Who is responsible when an agent makes a decision that costs money, damages a relationship, or violates a policy? The model? The engineer who deployed it? The business owner who approved the use case?
Most companies don't have answers to these questions yet. They're deploying agents into workflows where accountability matters, without clear lines of responsibility. That works until something goes wrong. Then it becomes a legal problem, not just an engineering one.
Google's tools don't provide governance frameworks. They provide deployment infrastructure. The assumption is that companies will figure out the policy layer themselves. Some will. Most won't, at least not until they've learned the hard way.
What Actually Works
The teams that succeed with agents in production are the ones who start small and constrained. They don't build general-purpose reasoning systems. They build narrow agents with explicit boundaries, clear fallback paths, and human oversight at decision points that matter.
They instrument everything. Not just errors - decision paths, confidence scores, context changes, every fork in the reasoning process. They build dashboards that make agent behaviour visible, not just performance metrics.
And they accept that agent systems are probabilistic, not deterministic. That means designing workflows where occasional failures are survivable. Where the agent's role is to assist, not to own the outcome.
The hype says agents will automate everything. The reality is more modest: agents will handle repetitive reasoning tasks, surface options for human decision-makers, and reduce cognitive load in well-defined domains. That's still valuable. But it's not the autonomous future the demos suggest.
Google gave everyone the tools to build agent systems. What they didn't provide is the infrastructure to run them reliably at scale. That gap is where most of the current wave of agent projects will stumble. The ones that survive will be the ones who saw it coming.