The Agentic AI Digest (7 Nov) | Mastering Structured Output & Building Multi-Agent Systems with ADK
This week: We dive deep into using Structured Output to reliably parse data, and highlight Google's new guide for multi-agent systems and recent Gemini API enhancements.
Hi everyone,
Welcome to your weekly briefing from the Agentic AI Roundtable. Our goal is to cut through the noise and deliver the most relevant signals, patterns, and community wins to help you build more effectively.
Let’s dive in.
📒 From the Workbench: Patterns to Pocket
This week, we’re covering another powerful fundamental skill to have in your genai toolbox: structured output. This technique involves precisely constraining an LLM’s response to adhere to a specified JSON format. We’ll demonstrate its usefulness through a practical example: an RPC method designed to parse a PDF document by extracting the title and a summary of each section. Imagine this method as a component of a larger file ingestion and parsing system. We’ve included a picture of the definitions to make it clear what we’re trying to achieve:
What is it, and why is it useful?
The inherent challenge with LLMs is their tendency to generate free-form, unconstrained text. While incredibly versatile, this unstructured output poses a significant problem when we need to integrate it reliably into our code. How do we consistently extract specific data points from natural language into a predictable format? Simply “asking the model nicely” for a JSON response, while sometimes effective, isn’t a robust long-term solution.
Structured output solves this by enforcing the model to generate a JSON response that strictly adheres to a predefined schema. This means we can directly unmarshal the model’s output into a Go struct (or, in our example, a Protobuf message), eliminating the need for complex parsing logic or fragile regular expressions. We effectively transform an LLM into a powerful, schema-bound data extractor.
How does it actually work?
The specified schema is internally used to guide the model’s autoregressive generation. At each step of producing a new token, the model is only allowed to select tokens that are valid according to the schema at that specific point in the JSON structure. This is often achieved using Finite State Machines (FSMs), where each “state” represents a position in the schema (e.g., “expecting object key,” “expecting string value,” “expecting comma or closing brace”). The model’s output is constrained to tokens that transition to a valid next state.
In the code
Working with structured output is similar to unstructured output in the Golang Gen AI SDK. The main things to take note of are:
Define the schema using “genai.Schema”. These can be tricky to get right. I prefer to first create the golang struct that I’ll be unmarshalling the response into (in our example, it’ll be the rpc response message). I then ask an LLM to create the corresponding schema.
In the generation config, ResponseMIMEType must be set to “application/json”.
After generating, the model response can be unmarshalled using “json.Unmarshal”. We’ve wrapped it in a function “UnmarshalJson” to make it easer to use.
We’ve included the complete implementation of the rpc method:
Advanced structured output tips
Use protobuf objects for your schema to keep your code clean.
Structured output can degrade model performance when the tasks required are too complex and diverse. For complex schemas, consider splitting one model call into multiple model calls with smaller json schemas.
Handle optional fields in the schema by specifying the “Required" field.
As far as possible, avoid duplicating instructions in the prompt and schema - rather use the “Description” field in the schema itself to describe the schema.
Further resources
Gemini’s documentation for structured output.
Our agentic AI build and define repos, containing the sample code from all Agentic AI digest examples from 31 October 2025 onwards.
📡 On the Radar: What’s Moving the Needle
A curated look at the articles, papers, resources and updates that are worth your time this week.
Google Cloud released an in-depth developer’s guide to building collaborative, multi-agent systems using the Agent Development Kit (ADK). It provides a practical framework for designing and implementing systems where multiple agents can communicate and work together to solve complex problems, moving beyond single-agent architectures.
This week bought us a great post which details a how to optimizing the ADK’s importer to slash a 24-second cold start time in half. This is a must-read for anyone deploying agents on serverless platforms like Cloud Run, where cold starts are a major performance bottleneck.
Just in time for our “Patterns to Pocket” focus this week, Google announced enhancements to Structured Outputs in the Gemini API. Reliable agentic workflows depend on predictable outputs. Well worth a read.
🤝 Want to Get Involved in the Community?
This roundtable is driven by its members. To join the conversation, share your work, or ask a question, you have two great options:
Join our private Google Chat space for real-time discussions and to participate in the weekly Open Thread. [Link to Chat Space]
Send a message to our community Google Group at roundtable-community@agentic-ai.build.
We look forward to hearing from you.
The Agentic AI Roundtable Core Team