This is a submission for the Google Cloud NEXT Writing Challenge

Google Cloud Next '26 had a very loud headline: the agentic enterprise is here.

But the more interesting story, at least for developers, was quieter.

It was not just "agents are smarter now." It was this:

AI agents are finally being treated like production software.

That may sound less exciting than a keynote demo, but I think it is the real shift. The serious part of the event was not that an agent can answer a question, generate a document, or call an API. We have seen enough demos like that.

The serious part was Google saying, in many different ways, that agents now need infrastructure: runtime, identity, memory, observability, evaluation, access control, data grounding, secure sandboxes, and governance.

In other words, the future of agents is not just about better models. It is about everything around the model.

The announcement that stood out

The center of Google Cloud Next '26 was the new Gemini Enterprise Agent Platform.

Google described it as the evolution of Vertex AI: a platform to build, scale, govern, and optimize agents. That framing matters because it moves the conversation away from "Can I build a cool AI demo?" and toward "Can I run thousands of agents safely inside a real organization?"

Sundar Pichai's Next '26 post captured the shift well. He wrote that the question has moved from "Can we build an agent?" to "How do we manage thousands of them?" That one sentence explains most of the event.

Google's answer is a stack with pieces like:

• Agent Development Kit, or ADK
• Agent Studio
• Agent Runtime
• Agent Registry
• Agent Identity
• Agent Gateway
• Agent Observability
• Agent Simulation
• Agent Evaluation
• Memory Bank
• Agent Sessions
• Model Armor
• Google Cloud MCP servers

That is a lot of product names. But under the naming, there is a real architecture forming.

The developer keynote made it real

The opening keynote gave the vision. The developer keynote made it practical.

The demo was built around planning a marathon in Las Vegas. That sounds like a toy problem until you think about what it actually requires: route planning, constraints, simulation, safety, logistics, evaluation, and constant iteration.

The system used multiple specialized agents instead of one giant "do everything" agent:

• A planner agent proposed marathon routes.
• An evaluator agent checked those routes against requirements.
• A simulator agent modeled the impact on the city.
• A supply chain agent handled logistics like water stations, medical tents, and portable toilets.

That is the architecture pattern I found most useful: not one magical assistant, but a network of smaller agents with clear jobs.

The developer keynote showed agents using ADK, MCP, Agent Runtime, Agent Registry, A2A-style agent communication, A2UI-style user interfaces, Memory Bank, runtime traces, Cloud Assist, Cloud Run, GKE, Agent Identity, and Agent Gateway.

That is much closer to real software engineering than the usual "I typed a prompt and magic happened" demo.

The hidden message: agents need boring systems

The most underrated part of Next '26 was how much of the agent story was boring in the best possible way.

Boring like logs.

Boring like identity.

Boring like access control.

Boring like knowing what changed, who changed it, what tool got called, what data was accessed, and why the agent made a bad decision.

That is what makes software production-grade.

A chatbot can be loose. A production agent cannot.

If an agent can read documents, write code, trigger workflows, browse internal systems, call another agent, or act on customer data, then it needs the same discipline we expect from any other production system.

That is why features like Agent Identity and Agent Gateway matter. Agent Identity gives agents a trackable identity. Agent Gateway becomes a control point for agent-to-agent and agent-to-tool traffic. Agent Registry gives organizations a way to know what agents and tools exist. Agent Observability gives developers traces and logs for debugging.

This is not glamorous, but it is the difference between "cool demo" and "I would trust this in production."

What people seem excited about

After reading the official announcements and community reactions, the excitement is mostly around practical developer workflows.

ADK is a big one. Developers want a way to build multi-agent systems without inventing the architecture from scratch. Google's graph-based ADK direction is interesting because it acknowledges that agent workflows need structure. Some tasks can be generative, but some need deterministic paths, especially in compliance, security, finance, healthcare, and operations.

MCP is another major theme. Google is exposing cloud services through Model Context Protocol and also announced an official Agent Skills repository. I like this because it tackles a problem developers already feel: context bloat. Giving an agent the entire internet, all docs, and every internal page is not a strategy. Smaller, task-specific skills are a cleaner way to give agents expertise only when needed.

Cloud Run updates also caught attention. Developers care about things like managed MCP servers, long-running background agents, sandboxing, SSH support, service bindings, serverless GPUs, and billing caps. Billing caps may not sound like a keynote-worthy feature, but for developers worried about surprise cloud bills, that can be more exciting than another model benchmark.

There was also interest in the codelabs. Google said there were 55+ new codelabs across Cloud at Next, with labs covering ADK + A2UI, multi-agent systems, secure agents, Google Maps grounding, Agent Engine deployment, Cloud Run, and agent skills. That matters because developers do not just need a keynote. They need something they can run after the keynote ends.

What people are worried about

The concern I saw again and again is AI fatigue.

Some developers are asking whether Google Cloud Next is becoming "Gemini Next." On Reddit, one person joked about trying to find a session without AI and failing. Another pre-event thread asked what people expected besides "Agentic AI spam."

That frustration is fair.

A lot of production teams still care about IAM, networking, Kubernetes, databases, cost controls, observability, migrations, and reliability. If every topic gets wrapped in "agentic AI" language, it can start to feel like the practical infrastructure concerns are being painted over with marketing.

But I think the best version of Google's Next '26 story actually answers that criticism.

The useful announcements were not "AI will fix everything." The useful announcements were about the infrastructure agents need when they stop being demos:

• GKE Agent Sandbox for isolated execution
• Agent Runtime for deployment
• Agent Gateway for governed traffic
• Agent Identity for traceable permissions
• Agent Observability for debugging
• Agent Evaluation for quality checks
• Model Armor for prompt injection and data leakage protection
• Knowledge Catalog for trusted business context
• Cloud Run billing caps for cost safety

Those are not just AI features. They are operational features.

The data story may be more important than the model story

Google also announced the Agentic Data Cloud, and I think this might be one of the most important parts of the event.

Agents are only useful if they understand the business context around the task.

A generic model may understand the word "margin," but inside a company, "margin" might depend on team-specific definitions, regional rules, product lines, internal dashboards, and messy historical decisions. If an agent does not understand that context, it will confidently do the wrong thing.

That is why Knowledge Catalog, Cross-Cloud Lakehouse, BigQuery measures, LookML Agent, Data Agent Kit, and Conversational Analytics matter. They are not just data products. They are attempts to make enterprise context usable by agents.

This is where the agentic enterprise either becomes real or falls apart.

Without trusted context, agents hallucinate.

Without permissions, agents leak data.

Without observability, agents become impossible to debug.

Without evaluation, agents drift.

Without cost controls, agents become expensive experiments.

Security is not optional anymore

The security announcements also stood out. Google is combining Google Threat Intelligence, Security Operations, and Wiz into what it calls Agentic Defense.

The important idea here is that agents create new attack surfaces.

If agents can use tools, attackers will try to poison tools.

If agents can read data, attackers will try to extract data.

If agents can call other agents, attackers will try to exploit the chain.

If agents can execute code, attackers will try to turn them into execution paths.

This is why Agent Identity, Agent Gateway, Model Armor, Wiz, threat detection agents, detection engineering agents, and runtime security all belong in the same conversation as ADK.

Security cannot be a final checklist after the agent is built. It has to be part of the agent architecture.

My honest take

I am excited, but cautiously.

I like that Google is treating agents as systems, not toys. The developer keynote was strongest when it showed the full lifecycle: build, test, remember, debug, deploy, scale, and secure.

That is the right framing.

But I also think the industry needs to be careful. "Agentic" is becoming a word that gets attached to everything. Not every workflow needs an autonomous agent. Some need a form. Some need a queue. Some need a cron job. Some need a dashboard. Some need better documentation.

The best agent systems will not be the ones that automate the most. They will be the ones that know when to act, when to ask, when to stop, and when to hand control back to a human.

That is why the boring parts matter so much.

The future is not one giant AI agent running a company. The future is probably many small, specialized agents operating inside strict boundaries, with humans still setting intent, reviewing important decisions, and owning the outcome.

Final thought

Google Cloud Next '26 made one thing clear to me:

The agent era will not be won by the flashiest chatbot.

It will be won by the platform that makes agents observable, governable, secure, grounded in real data, and boring enough to trust.

That is a less dramatic story than "AI will do everything."

But for developers, it is a much better one.

Because if agents are going to become part of real software, they need to behave like real software.

And real software needs infrastructure.