Build
Two agents. One adjudicates, one routes the exceptions.
ADK · Agent Studio · Model Garden
BLUEPRINT · HEALTHCARE · MULTI-AGENT
Claims Processing Adjudication
Adjudicate routine claims end-to-end; escalate the exceptions.
Adjudicate routine claims end-to-end; escalate the exceptions. Named scope, named timeline, named stack — ADK · A2A · Memory Bank · Model Armor · 10 weeks.
Design ceiling
Routine claims adjudicated end-to-end. Exceptions routed to a named adjudicator with the case file already assembled.
The agent system is designed to clear the high-volume, low-complexity bulk of the queue without human touch — and to hand the rest off with the audit trail intact.
The problem
Routine claims do not need a human. The exceptions do.
A regional payer adjudicating a few hundred thousand claims a month is paying skilled adjudicators to clear the same patterns over and over — a clean visit, a clean code, a clean policy match. The work is repetitive, the rules are codified, and the exceptions are rare. The cost is the queue depth, the cycle time, and the adjudicators burning out on rote review.
The job is to clear the routine bulk without a human in the loop, and to hand the exceptions to a named adjudicator with the case file already assembled — the policy clauses cited, the prior history surfaced, the conflicts flagged. Two agents, A2A handoff, Memory Bank holding the case state across the conversation, Model Armor at the gateway, every decision audit-trailed.
Agent architecture
Four pillars, this blueprint’s stack.
The platform’s four pillars, mapped to the components this agent system actually exercises.
Scale
Adjudicator and router talk over A2A. Case state lives in Memory Bank.
Agent Runtime · A2A v1.2 · Memory Bank
Govern
Every PHI access policy-checked. Every decision audit-trailed.
Agent Registry · Model Armor · Gateway · Identity
Optimize
Eval set covers the cleanest, the messiest, and the policy edges.
Evals · Observability · Agent Analytics
Engagement · 10 weeks
Week by week.
Fixed scope, fixed price, fixed timeline. Here is what happens when.
Week 1-2
Discovery and data inventory.
Walk the current adjudication workflow with the ops lead. Inventory the policy library, the claims pipeline, the exception types. Agree the scope and sign the SOW.
Week 3-4
Adjudicator agent build.
Stand up the ADK adjudicator agent against the policy library. First eval pass on a sampled month of historical claims. Tighten prompts and tool definitions against the eval results.
Week 5-6
Router agent and A2A handoff.
Build the exception-routing agent. Wire the A2A protocol between adjudicator and router. Memory Bank carries the case file across the handoff.
Week 7-8
Governance and observability.
Register both agents in Agent Registry. Configure Model Armor policies for PHI handling. Stand up the Agent Analytics dashboard so ops can see queue depth and exception rate live.
Week 9
Staging and shadow run.
Run the agent system in shadow against live traffic. Compare adjudications to the human queue. Tune the eval set against any drift.
Week 10
Production cutover and handoff.
Deploy to Agent Runtime. Walk the runbook with the ops lead. Hand the team the repo, the eval harness, the dashboard, and the on-call playbook.
What it looks like in code
ADK Python — the agent definition.
The actual shape of the code your team owns at engagement end. Real ADK, real tools, real instruction copy.
agents/adjudicator/agent.py
python
from google.adk.agents import LlmAgentfrom google.adk.tools import FunctionToolfrom .tools import ( fetch_policy_clauses, fetch_member_history, record_adjudication, handoff_to_router,)adjudicator = LlmAgent( name="claims_adjudicator", model="gemini-2.0-pro", instruction=( "You adjudicate medical claims against the policy library. " "For every claim: cite the policy clauses you applied, record " "the decision, and hand any exception to the router agent." ), tools=[ FunctionTool(fetch_policy_clauses), FunctionTool(fetch_member_history), FunctionTool(record_adjudication), FunctionTool(handoff_to_router), ],)What you walk away with
Code your team owns. Governance baked in.
Every blueprint hands the engineering team a deployed agent and the artefacts to run it themselves. No black box, no lock-in.
- Two ADK agents (adjudicator + router) deployed on Agent Runtime, in your Google Cloud project.
- The Git repo your team owns, with the agent code, tools, prompts, and tests.
- CI/CD pipeline wired to your repo, deploying on merge.
- Eval harness with a sampled-month corpus and a drift-watch baseline.
- Governance bundle: Agent Registry entries, Model Armor PHI policies, Gateway access controls.
- Agent Analytics dashboard plus an on-call runbook for the ops lead.
Book this blueprint as a pilot.
Two weeks. Named scope. Working agent on Agent Runtime at the end.
Code
Lives in your Git org, owned from commit one.
Governance
Model Armor and Agent Registry on day one.
Speed
Two weeks to a runnable pilot. Eight to production.
Not ready to talk? Take the 4-min readiness assessment