Hi, I am Aniruddha Adak, an AI agent engineer based in Kolkata. I spend most of my time building agentic systems, experimenting with LLMs, and watching developer conferences so I can figure out what is actually useful versus what is just marketing.
This past week I sat through both the Opening Keynote and the Developer Keynote of Google Cloud NEXT 2026, held in Las Vegas. The event ran from April 22 to 24, 2026. Both sessions are freely available on YouTube, and I want to share what I personally noticed, what made me stop and think, and what I believe developers like you and me should actually care about.
This is not a summary. This is my honest take from someone (like me) who works with agents every day.
How I Watched These Keynotes
I watched both sessions fully. The Opening Keynote runs for about 1 hour 39 minutes. The Developer Keynote is 1 hour 7 minutes. That is nearly 3 hours of content.
I took notes while watching, paused at moments that felt important, and replayed sections where the demos were happening live on stage.
I am going to walk you through what I found most meaningful, section by section.
The Opening Keynote: Sundar Pichai and the Big Picture
Sundar Pichai came on stage pretty early in the keynote. The thing that immediately got my attention was when he talked about how Google now uses AI for nearly 75% of its own code writing. That number stopped me. It means the engineers at Google are not just building AI tools. They are themselves working alongside those tools in their day to day coding.
He also mentioned that Google plans to invest heavily in infrastructure this year, and a significant portion of that investment is going toward AI compute. From where I sit as someone building agent systems, this matters because more compute capacity means the APIs and services we rely on will be more stable and faster.
watch here: 👇
Another moment that stood out was when Sundar described Cloud as the "mission control of the agentic era." That phrase stayed with me. It is not just a catchy line. It reflects a genuine shift in how Google is framing its cloud offering. It is no longer just about storage or compute. It is about giving your AI systems a place to run safely, observe themselves, and scale up.
The Agentic Enterprise Blueprint
Thomas Kurian, who runs Google Cloud, presented what they are calling the Agentic Enterprise Blueprint. The core idea is straightforward: you cannot just bolt AI onto your existing systems and call it done. You need a full stack approach.
Here is what that stack looks like according to what was shown:
1. The Models Layer
Gemini Pro and Flash are at the center of this. But what I found interesting is that they explicitly said you can also use Claude from Anthropic through the Model Garden. This is honest. They are not forcing you into a single model. As someone who has built systems using multiple providers, I appreciate that kind of openness.
2. The Agent Development Kit (ADK)
This was the part that felt most relevant to my work. ADK is Google's framework for building modular agents. It connects to MCP servers, handles memory, manages sessions, and lets you define skills in a structured way. The fact that every Google Cloud service is now MCP-enabled by default was one of the bigger announcements of the week.
3. Agent Runtime
This is the serverless layer that runs and scales your agents. Sessions keep agents connected to users across interactions. Memory allows agents to learn from past sessions and carry that forward. This is the kind of infrastructure that used to take weeks to build manually.
4. Agent Gateway and Observability
Each agent gets a unique identity. The gateway enforces policies. Observability tools let you see what your agents are actually doing, debug reasoning loops, and track performance. This is something I have personally felt the pain of. Debugging agents without proper tooling is exhausting.
The Hardware Announcement That Got the Audience Excited
About 42 minutes into the Opening Keynote, Google announced the TPU 8t. Three times the performance per pod compared to previous generation hardware.
For most developers, you might not care directly about the chip architecture. But what it means in practice is:
✅ Faster model responses
☑️Lower latency for complex agent workflows
✔️ Ability to run longer context windows without things slowing down significantly
The TPU 8t was described as being designed specifically for the agentic era of computing. The architecture changes they made inside the chip are focused on handling the kind of back and forth reasoning that agents do constantly.
They also announced a new networking layer that links 134,000 chips together into what they called a unified AI supercomputer. That is a level of scale that very few companies in the world can match.
Real World Examples That Felt Grounded
One segment I genuinely enjoyed was the Walmart story. Walmart is using Gemini Enterprise to help field leaders get insights before they walk into their stores each day. The idea is that instead of spending time pulling reports manually, the agent surfaces what matters, tailored to the specific store and the specific leader's role.
This is exactly the kind of use case that makes sense to me. It is not AI trying to replace the person. It is AI giving the person better context so they can do their job better. The numbers shared were that some of their enterprise deployments hit 80% adoption among employees, which is genuinely high for any enterprise tool rollout.
There was also a story about a snowboarding AI project that used 3D models and motion analysis to help athletes understand their technique in ways that were not possible before. This one was more fun than practical for most developers, but it showed how computer vision and real time data pipelines can combine in interesting ways.
The Developer Keynote: Where Things Got Practical
The Developer Keynote was hosted by Richard Seroter and Emma Twersky. The energy was different here. More hands on. More code. Less executive messaging.
Brad Calder opened the session and made a statement that I wrote down immediately:
"In 2026, you are building applications in days that would have taken weeks or months just a couple of years ago."
He is right. I have felt this in my own work. The tools have gotten dramatically better, and the way we structure our thinking around building software is changing alongside them.
watch here: 👇
The Marathon Demo That Showed Everything Working Together
The main demo of the Developer Keynote was a Marathon Planner built using the Agent Platform. They simulated planning a marathon through Las Vegas for 10,000 runners.
The system had three agents working together:
- A Planner Agent that figured out the route
- An Evaluator Agent that scored the route against both deterministic criteria (exactly 26 miles 385 yards) and non-deterministic criteria (community impact, safety)
- A Simulator Agent that spawned thousands of virtual runners and watched how traffic was affected
What I found clever here was the Evaluator Agent design. It uses a separate, smaller model with limited context. Its only job is to judge the route. This is a pattern I have started using in my own work. Giving a subagent a narrow, well defined role makes the whole system more reliable.
The other thing that struck me was A2UI, which stands for Agent to User Interface. The idea is that the agent itself builds the interface it needs to communicate results back to you. Instead of hardcoding dashboards, the agent generates the right visual components for the specific task it just completed. This reduces the need for frontend developers to maintain a growing list of output templates.
A2A Protocol: Agents Talking to Agents
One announcement I want to highlight specifically for developers is the A2A protocol. A2A stands for Agent to Agent. Google created this protocol and donated it to the Linux Foundation, which means it is open and not locked to Google's ecosystem.
The problem A2A solves is communication between agents that were built independently. Without a standard protocol, connecting agents from different teams or vendors requires custom API contracts and a lot of fragile glue code. A2A defines a standard way for agents to advertise their capabilities through an Agent Card, discover other agents through the Agent Registry, and communicate without writing custom integration code.
I have run into this problem myself. When you start building systems where multiple specialized agents need to coordinate, the connection layer becomes its own maintenance burden. A2A is an attempt to make that layer standard and manageable.
What Surprised Me Personally
I went into these keynotes expecting mostly announcements about model updates and price changes. What I did not expect was how much of the Developer Keynote was focused on showing code, showing real tradeoffs, and being honest about where the hard problems still are.
The segment about Context Engineering genuinely resonated with me. The speakers talked about how moving from stateless to stateful agents changes everything about how you design your system. Sessions, Memory Banks, and RAG integrations are not optional add-ons. They are the foundation of any agent that needs to be useful across multiple interactions.
They also mentioned that the full demo code was being open sourced on GitHub during the keynote. Not after. During. That is the kind of move that actually builds trust with a developer community.
Something That Felt Missing
Honestly, I would have liked to see more about monitoring and debugging agent failures in production. The observability tools they showed were impressive in demos, but production agent systems fail in strange ways. I would love a deeper conversation about what happens when your agent gets stuck in a reasoning loop or when memory accumulates stale information that starts affecting decisions.
This is something I think about in my own work constantly. The tooling for building agents has gotten good. The tooling for understanding why agents fail is still catching up.
What You Should Actually Do After Reading This
If you made it here, here are three things worth doing:
Watch the Developer Keynote first. It is more practical and the demos are better for developers. The Opening Keynote is good context but starts with a lot of enterprise positioning.
Look up the ADK documentation. The Agent Development Kit is available now. If you are already building agents with other frameworks, it is worth understanding how ADK structures skills and tools. Some of the patterns are genuinely well thought out.
Try the open source demo code. The Marathon Simulator was released on GitHub. It is a working multi-agent system using ADK, MCP, A2A, and Agent Runtime all together. That kind of end-to-end reference is rare.
My Overall Feeling
I came away from both keynotes with a clearer sense of where the industry is heading. The shift from "we have a model" to "we have a complete agent infrastructure" is real. Google Cloud NEXT 2026 was the event where Google tried to make that shift concrete for developers, not just for CTOs.
The things I liked most were the openness around model choice, the A2A donation to Linux Foundation, and the fact that the demo code was released publicly. Those are developer friendly moves.
The things I want to see more of are better failure analysis tools, more honest discussions about prompt drift in production, and deeper guidance on memory management at scale.
But overall, this was a strong event with a lot of practical takeaways for anyone building agentic systems in 2026.
I am Aniruddha Adak from Kolkata. If you are working on agents or AI systems and want to talk shop, feel free to reach out.
Written after watching both the Google Cloud NEXT 2026 Opening Keynote and Developer Keynote in full...