AI Agent Architecture Needs a Harbormaster

Most teams building AI agents make the same mistake early: they build one agent and ask it to do everything. Google Cloud's session at Ai4 2026 was a live coding demo built around the opposite idea, and it's a better blueprint for anyone shipping agents into production.

Building an ADK 2.0 Agent From Scratch

The presenter opened with the editor live on screen, working through base_agent.py inside a real project structure: an agents/ folder holding the base agent and specialized agents, a services/ folder for session handling, and a clean set of imports from Google's Agent Development Kit and Gemini. The point wasn't the code itself. It was how little of it there was. Running on a Gemini Flash model with simple, constrained instructions, the demo showed that a well-scoped agent doesn't need much surface area to be useful.

The full architecture, along with BigQuery telemetry logging and Vertex AI multi-turn session memory, is open source on GitHub at github.com/davenportjw/agent-telemetry, and the presenter pointed the room straight at it: "You are welcome to go and play with it, you can also test."

Stop Building Monolithic Agents

Here's the architectural principle the whole session hung on: don't write one agent that tries to do everything.

Split massive agents into focused sub-agents or, better yet, plain deterministic tools. Design single-purpose agent loops with tightly constrained system prompts. Break complex, multi-step processes into an orchestration of independent pieces instead of one long autonomous chain. If a piece of logic is going to produce the same output every time given the same input, expose it as a function call, not an autonomous decision loop.

Inside the Demo: A Multi-Agent System With Job Titles

To make the architecture concrete, the demo used a nautical-themed multi-agent system running as a Go microservice, coordinating Gemini models through Agent-to-Agent HTTP endpoints, MCP tool bindings, and the Google Agent Registry. Each specialist agent had a defined, narrow role:

• Harbormaster — central coordinator for the whole operation
• Pilot — navigation, route planning, and maritime rules
• Commodore — high-level strategic planning and regional discovery
• Specialist — technical task execution, weather and tide analysis
• Lookout — continuous safety monitoring and audit

The presenter's own explanation of why this works: "Each agent has like a cute label that kind of makes it easy for me to understand what it does." Simple framing, real payoff — when every agent has one job, you always know which piece to look at when something breaks.

Deciding When to Use a Tool vs. an Agent

The session's clearest decision rule was this: deterministic tools give you repeatable, testable, cost-effective execution for known tasks. Agents earn their place in open-ended reasoning, orchestration, and handling paths you didn't anticipate. For core system integrations, default to a tool — it enforces predictability and keeps your boundaries clean. Save the agent loop for the parts of the job that genuinely require judgment.

One practical habit worth stealing directly: if you notice an agent producing the same deterministic output every time, hard-code it and turn it into a tool. Lower token cost, more reliable result, easier to test.

Ditch the Chatbox-Only Mentality

The last point was less about architecture and more about product sense: stop assuming every AI interaction has to happen in a chat window. "When all you have is a hammer, everything looks like a chat window," the presenter said, pointing the room's own habits back at them. Forms, maps, and voice interfaces all have a place depending on what the user actually needs — a chatbot is one interface option, not the default answer.

What This Means for Anyone Building Agents Right Now

Build small, name your agents something you'll actually remember, and don't reach for an autonomous loop when a function call will do the job better and cheaper. The architecture that scales isn't one smart agent — it's a well-organized crew where everyone knows their job.

Thinking about how AI agents fit into your own product or ops stack? Winsome helps companies figure out where automation actually belongs — and where it doesn't. Talk to Winsome about your AI architecture.

 Source: Google Cloud's Ai4 2026 session, "Architectural Patterns for Reliable Agents"