EVERY ROUTE RIGHT, BOTH RUNS
The routes did not move.
All four alerts took the correct route, and the same route in both runs. The route is chosen by rules in code, so it cannot change when the model's wording does.
FLAGSHIP · AGENT WORKFLOWS ON GOOGLE ADK
Agents that get context by rule, not by guess.
We design and build agent workflows on Google's Agent Development Kit. The context each step needs is fetched by bounded, deterministic code — not chosen by the model. The agent at that step works with exactly what it was given, and its output moves to the next layer. Every step can be tested on its own, and none of it is locked to a single model.
HOW THE WORKFLOW RUNS
Fetch. Reason. Hand on.
A common way agents break in production is context: the model fetched the wrong thing, or too much of it, or decided on its own what it needed. This pattern takes that decision away from the model and gives it to code.
01 · BOUNDED FETCH
Code fetches the context, not the model.
Each step declares what it needs. A bounded script retrieves exactly that — from your APIs, databases or documents — and writes it into the workflow's state. No model decides what data it gets to see.
02 · AGENT NODE
The agent works with what it was given.
The agent at that step reasons over the context it was handed and nothing else. Its reach is set by the fetch that came before it, not by what its prompt talks it into.
03 · NEXT LAYER
Output moves forward along explicit edges.
ADK runs a workflow as a graph: each step is a node, and the edges between them are declared in code. Each result carries forward in shared state to the next layer.
04 · DECISION POINTS
Where the flow branches, the branch is explicit.
Branching lives in code you can read and test. Where a judgement is genuinely uncertain, it goes to a person rather than being guessed.
PROOF · WE BUILT ONE FIRST
Own your agent orchestration instead of renting it.
Context from every vendor you run, your rules in code, built on open-source components — Google's ADK and open models — and delivered into your own repository. To show that rather than claim it, we built one: cross-vendor alert triage on ADK, with Gemma 4 running on a single machine and every claim it makes checked by TypeSafe's Jev.
FETCH · CODE · IN PARALLEL
- Service catalogOwner, on-call, tier
- DeploysWhat shipped recently
- Incident managementWhat is already open
- Issue trackerWhat is already known
ASSESS · MODEL
Likely causeReads only what was fetched, and cites every source by reference
CHECK CLAIMS · JEV
Claim checkTypeSafe's Jev tests each sentence against the records it cites
CHECK & ROUTE · CODE
Citations, then rulesA source it was never given, or a claim that failed? A human takes it. Otherwise the rules pick the route.
ROUTE
- Attach to open incident
- Page the owner
- Open a ticket
- Notify on-call
- Hold for a human
| Alert | Route · both runs | Why, in code | Model's evidence | Seconds · run 1, 2 |
|---|---|---|---|---|
| checkout-api5xx error rate 7.4% | Page the owner | Tier-1, deployed 22 minutes before the alert | Same both runs | 42.8 · 30.0 |
| payments-workerp95 job latency 41s | Attach to open incident | An incident was already open | Varied | 40.3 · 53.8 |
| docs-sitep95 page load 3.8s | Open a ticket | Tier-3 at warning severity | Same both runs | 20.2 · 17.8 |
| search-indexerIndex queue backlog 12,400 | Notify on-call | No rule matched | Same both runs | 51.6 · 31.2 |
CLAIM CHECK · TYPESAFE'S JEV
A second model checks what the first one said.
After Gemma writes its assessment, TypeSafe's Jev checks every sentence against the records Gemma cited: supported, contradicted, or not addressed. Anything not clearly supported goes to a person.
- 40 / 40scored runs matched the expected result
- 0correct claims flagged
- 0flawed claims let through
- 155 msmedian per check, network included
- A plainly wrong claim (control)"Deploy d-1042 went out about nine hours before the alert fired." It went out 22 minutes before. Contradicted at 1.00 in all five runs.
- Gemma's real mistake"…(deploy:d-1039) occurred shortly before the alert fired…" It went out about nine hours before. Flagged in all five runs. The sentence is half right and half wrong, so Jev split close to evenly and it went to a person.
- Gemma's correct claim"A recent deployment (deploy:d-1042) changed the payment-token cache TTL from 300s to 30s." Passed at 0.98 in all five runs.
- Vague wording"A recent deployment (deploy:d-1039) bumped the queue client library…" That deploy was about nine hours earlier, and the claim passed. The check asks whether a claim is backed by the records, not whether the wording is well chosen.
THE MODEL EARNED ITS PLACE
It connected two vendors' records.
On checkout-api it tied a deploy that cut the payment-token cache lifetime from 300 to 30 seconds to an open ticket reporting the token cache hit rate had dropped — the cross-vendor connection a person would otherwise make by hand.
AND IT WAS NOT ALWAYS RIGHT
So a second model checks it.
In one run it left an open incident out of its evidence; in an earlier run, on 16 September, it said a deploy made about nine hours earlier happened "shortly before" the alert. Code catches a model citing a source it was never given. Jev checks whether each claim is backed by the records it does cite, and it flagged that one. The route still never depends on the model's wording.
SLOW TO WRITE, FAST TO CHECK
18 to 70 seconds, then 0.3 seconds.
Each alert takes 18 to 70 seconds with the local model writing the assessment. Jev checks every sentence of it in one call: 155 milliseconds median across 50 calls, and 283 and 271 milliseconds in the two full workflow runs that used it.
The code is private and available on request — along with a walk-through of how the same workflow reads from your own systems instead of reference data.
Book a call →WHY GOOGLE ADK
A kit built for exactly this shape.
ADK is Google's framework to build, evaluate and deploy agents. Everything below is from Google's documentation or the ADK release we build on, not our marketing.
Optimized for Gemini, and documented to work with Claude, OpenAI, Gemma and open models through Ollama, vLLM and LiteLLM. Models plug in through one interface, so the workflow is not tied to a single provider.
Workflows are graphs: steps are nodes, edges and routes are declared in code, independent fetches run in parallel, and each step can carry its own retries and timeout — orchestration that does not depend on a model's choices.
Python, TypeScript, Go, Java and Kotlin. The build fits the stack your team already maintains.
Deploys to Cloud Run, Google Kubernetes Engine, or Google's managed Agent Runtime.
Multi-turn evaluation datasets, run locally from the command line or a dev UI, so a change to a prompt or a model is tested before it ships.
Logging, metrics and traces are part of the kit, and MCP tools are supported natively — so every tool call can be recorded if you need an evidence trail.
WHAT YOU GET
A build you own, and the means to change it safely.
Scoped on the call to the workflow you actually need. Delivered into your repository and your cloud, with nothing that stops working when the engagement ends.
01
Workflow design
The steps, the context each step is allowed to see, where the flow branches, and who reviews the calls a machine should not make alone.
02
A working build
An ADK workflow in your repository, deployed to your Google Cloud project. Code you own, on infrastructure you control.
03
An evaluation suite
ADK evaluation datasets for the paths that matter, so the next change is measured rather than hoped about.
04
Observability
Logging, metrics and traces wired in from the start. MCP tool calls recorded with Witness if you want a tamper-evident record.
05
Handover
A runbook and a readout with the team that will run it after we leave.
WHO IT'S FOR
Teams past the demo.
For engineering, platform and product leaders who have seen what an agent can do and now need it to do the same thing reliably.
YOU ARE BUILDING
Agents that touch real systems, and they need to behave the same way on the hundredth run as on the first.
YOU HAVE
A prototype that works in a demo and loses the plot in production — usually because the model is choosing its own context.
YOU WANT
A build your security and platform teams can review line by line, rather than a black box with a prompt inside.
ALREADY RUNNING AGENTS?
Start with the evidence.
If agents are already acting in your estate, an Agent Flight Check first shows what they actually do — and gives the new build a baseline to measure itself against.
See the Agent Flight Check →SCOPED ON THE CALL · YOUR REPO · YOUR CLOUD
Tell us the workflow.
Thirty minutes to walk through what the agent needs to do, what it should be allowed to see, and whether ADK is the right foundation for it. If it isn't, we'll say so on the call.