In December 2025, Google’s Agent Development Kit (ADK) team published a developer’s guide to multi-agent patterns. I’ve found myself thinking about how to take these patterns and apply them to government services. Their argument (and others) is that a single AI agent given too many responsibilities degrades the same way a monolith does: instruction adherence drops as complexity rises, errors compound, and more. The recommendation is to break the work into specialists, and you get something modular and testable.
Government agencies and processes already work this way. Think about how a benefits application moves: from an intake caseworker to an eligibility technician to a supervisor. Or background checks: criminal records, credit, employment verification, and education verification — running concurrently then combined at the end.
The handoffs, the specialization, the escalation to a human with signature authority: that architecture already exists. Often it is written into statutes, regulations, standard operating procedures, and so on. Similar to legacy software being globbed onto over the decades.
I’ve found myself wondering about:
what pattern(s) government employees, processes, and technologies already use
what breaks when you swap a human with decades of experience for an AI agent
how we effectively measure and evaluate the AI agent and outcomes
how we combat automation bias and rubber-stamping outputs
and so on…
Let’s explore the eight core patterns from the Google post and how to apply them in a government context:
Sequential Pipeline
Coordinator / Dispatcher
Parallel Fan-Out
Hierarchical Decomposition
Generator and Critic
Iterative Refinement
Human in the Loop
Composite Patterns
The legal constraints that change the architecture
Before getting into the AI agent patterns, I want to highlight six requirements rooted in U.S. federal law. These six requirements shape which patterns are safe where and how they can be applied. Each requirement has some architectural consequences.
Every handoff is a federal record. Under the Federal Records Act, agency decision-making must be preserved and auditable. In a multi-agent system, the state passed between AI agents is part of the decision record. If an eligibility agent writes a determination recommendation to session state and a downstream agent overwrites it, you have destroyed a record. This makes ADK’s
output_keydiscipline part of compliance control.Adverse determination recommendations require an explanation the claimant can appeal. A person that is denied benefits gets told why, in plain-language terms, specific enough to contest. An AI agent chain that produces a correct recommendation with no traceable reasoning is a liability — even when the answer it provides is correct. Every pattern below needs to be able to answer: can you reconstruct which AI agent concluded what, and on what evidence?
Plain language is a statutory requirement. The Plain Writing Act of 2010 requires covered documents to be written clearly. Any AI agent generating citizen-facing text needs a critic checking reading level.
Section 508 applies to generated output. If an AI agent produces a PDF, a form, or a web response, accessibility is a requirement. Generated output needs an accessibility check in the loop.
The Privacy Act limits what crosses AI agent boundaries. Records in a system of records have use limitations. When a coordinator routes a case to three specialist AI agents, you have potentially disclosed personally identifiable information (PII) to three contexts. AI agent boundaries are disclosure boundaries. I look at this as the Principle of Least Privilege.
ATO boundaries are system boundaries. An AI agent touching a FedRAMP-authorized system and an AI agent touching an unauthorized one cannot share state. The authorization boundary constrains the implementation.
Keep these six constraints in the back of your mind while reading the patterns below. They help determine which ones you can deploy and which need a human in the loop.
1. Sequential pipeline
Note: Animated graphics generated using Claude
Government processes are often sequential with defined handoffs.
Where this could fit:
FOIA request handling: Request Intake → Classification → Records Search → Redaction → Review → Response Generation
Permit applications: Application Parser → Code Compliance Checker → Environmental Impact Reviewer → Fee Calculator → Approval Generator
Benefits application processing: Intake → Eligibility Recommendation → Documentation Review → Approval → Notification
ADK’s SequentialAgent runs sub-agents in order. Each writes to shared session.state under an output_key, and the next AI agent reads it.
2. Coordinator / dispatcher
A coordinator AI agent reads intent and routes to a specialist, then steps out of the way.
Where this could fit:
311 citizen service centers routing requests to Trash and Recycling, Permits, Tax Questions, Public Safety, Parks & Recreation
Health system navigation routing to Benefits, Healthcare Scheduling, Prescription Management, Claims Status
Taxpayer assistance routing to Filing Questions, Payment Plans, Audit Support, Tax Law Interpretation, Refund Status
As you can see, routing runs on LLM-driven delegation. You define a parent with sub_agents, and ADK’s AutoFlow transfers control based on each child’s description.
My gut tells me that the Privacy Act constraint mentioned above applies at the routing decision. The coordinator needs only enough information to route and no more.
3. Parallel fan-out and gather
Independent checks run at the same time, and a synthesizer combines them.
Where this could fit:
Background checks: Criminal Records, Credit, Employment Verification, Education Verification, running concurrently
Building permit review: Structural Safety, Fire Code, Electrical Code, Plumbing Code, Zoning Compliance, reviewed simultaneously
Grant application screening: Eligibility, Conflict of Interest, Budget Review, Technical Merit, concurrent
ParallelAgent runs sub-agents at once, then a downstream AI agent reads all their outputs. Two things of note:
Having many parallel AI agents running in separate threads with a shared state will create race conditions.
Do not let the output consolidator flatten the findings. For example, do not remove cited fire code specifics; include why something passed or failed with grounded information.
4. Hierarchical decomposition
A parent delegates part of a task, waits for the result, and continues its own reasoning. While this may seem the same as the sequential routing example above, this one is a bit different. The hierarchical parent gets an answer back and keeps working.
Where this could fit:
Environmental impact assessment: a project coordinator AI agent delegates to Air Quality, Water Resources, Wildlife Impact, and Cultural Resources specialists, then writes an integrated assessment that reasons across all four
Federal procurement review: a procurement officer AI agent calls Federal Acquisition Regulation Compliance, Small Business Set-Aside Analysis, and Price Reasonableness, then makes an award recommendation informed by all three
Policy research: a lead AI agent calls a research assistant that manages Federal Register search, case law lookup, and Government Accountability Office report retrieval, then drafts against what came back
My understanding is that you can wrap a sub-agent in AgentTool to make this work. The parent calls the sub-agent’s entire workflow as a single function call and receives the result.
5. Generator and critic
A good rule of thumb that I like to follow when creating agentic systems is to split creation from validation. A generator drafts output, a critic checks against explicit criteria. Failures route back with specific feedback until the draft passes. This is also known as a Ralph Loop or setting a Goal in Codex.
Where this could fit:
Guidance documents: the critic validates against the Code of Federal Regulations, plain-language standards, and Section 508 accessibility requirements
Public notices: the critic checks accuracy, required disclosures, and reading level
Grant scoring: the critic validates against the published rubric and flags scoring inconsistent with it
This is the pattern that statutory constraints demand. The Plain Writing Act and Section 508 are “pass/fail” criteria, which is exactly what a critic is for.
Since this is essentially a where loop, you should have explicit and enumerated criteria for the critic to hit, along with escalation paths or failsafes (like max_iterations) to ensure that the loop does not run indefinitely.
6. Iterative refinement
The same loop shape aimed at improvement rather than correctness. Generator drafts, critic writes optimization notes, refiner rewrites.
Where this could fit:
Rulemaking: the critic identifies legal ambiguity and economic impact and the refiner incorporates comments
Congressional reports: the critic checks factual accuracy, citation quality, and balance
You should be cautious with this approach since the refiner will overwrite text on each pass. Ensure that you are tracking draft history and how the language evolved with a version/iteration key.
7. Human in the loop
This is arguably the most important pattern in this list as it relates to government services.
AI agents do the groundwork and a human authorizes anything irreversible or high-consequence.
Where this could fit:
Benefits recommendation: it could surface other programs for individuals with a human caseworker approving before sending
Security clearance recommendations: AI could flag patterns and a human adjudicator decides
Regulatory recommendations: an officer approves before action
For a large share of government decisions this is not optional. Where a statute or delegation of authority assigns a determination to a named official, an AI agent can prepare the decision, but it cannot make it.
Two really important items to capture when implementing this are:
Who reviewed/approved the AI output
Whether or not they changed the AI recommendation
Also, being able to think about and combat Automation Bias in AI is critical.
8. Composite systems
I’d be remiss not to mention that no government system or process is singular. Most combine the patterns above. Take a few moments to think about a government process that you interacted with recently. This could be as mundane as renewing your passport or applying for a grant.
These flows appear simple on the surface, but have decades of processes built up behind the scenes. Both of these examples end the same way: with a human making an informed decision.
Final thoughts
For work in government and civic tech, we should be thinking about where can we implement automation to free us humans up to do more impactful work. How can we add AI agents to reason and act where mistakes are cheap and reversible?
FOIA request classification, permit intake parsing, and 311 routing could be good first targets. They’re high volume, the failure mode is a rerouted request rather than a denied benefit, and every one of them has a human already positioned to catch errors.
Adjudication is the last thing you automate — not the first — and even then the AI agent prepares the decision for a human who signs it.
Have you been exploring multi-agent architectures? Do you see opportunities or concerns?