HOW WE ENGAGE

Three rungs. Fixed scope. Fixed price.

Pilot, Production, Platform. Same delivery muscle, three commitment shapes — pick the rung that matches your readiness.

PILOT · 2 WEEKS

Validate the scope. Ship the proof.

Duration: 2 weeks
Deliverable: A working agent in your repo
Pricing: Fixed scope, fixed price

Two weeks. We pick one workflow that actually hurts, sit with the team that owns it, and ship the first agent against it before the engagement closes. Week one is discovery — we walk the current process with the operator who runs it, inventory the data sources the workflow already touches, and write the eval set against the outcome we agreed to hit. Week two is build — the agent lands in your repo on the Agent Development Kit (ADK) v1.0, with Model Armor wired to your policy and the eval set running on every commit. You finish the Pilot owning a real agent your engineers can read end-to-end, not a slide deck or a vendor demo. We also leave behind a scoped architecture brief for the Production rung, so the conversation about what to ship next is grounded in evidence the team produced together, not in estimates. No black box, no vendor lock — the code is yours from the first commit, and your team can keep building against it the day we hand it off.

Week by week

Week 1
Discovery + data inventoryWalk the workflow with the operator who runs it. Inventory data sources, agree the success metric, write the eval set against the outcome we hit.
Week 2
Build + first eval passThe agent lands in your repo on ADK with Model Armor wired to your policy and the eval set running on every commit. Handoff: your engineers own the code.

In scope

Discovery with the workflow owner and a single named workflow.
One agent on ADK in your Git org, with prompts and tools your team owns.
Eval set written against the agreed metric, running on every commit.
Model Armor policy wired against your existing identity and gateway.

Not in scope

Production deployment on Agent Runtime (that is the Production rung).
Multi-agent orchestration or A2A wiring (that is the Platform rung).
On-call rotation, runbooks, or post-launch operator support.
Third-party integrations beyond what the workflow already touches.

Screenshot of the Google Cloud Agent Development Kit product page showing the ADK landing surface in light mode. — Agent Development Kit on Google Cloud — the Pilot ships against ADK Python v1.0.

Start a Pilot

PRODUCTION · 6 WEEKS

Ship the agent. Govern it from day one.

Duration: 6 weeks
Deliverable: One agent in production
Pricing: Fixed engagement, named outcome

Six weeks to take the Pilot agent from runnable in a sandbox to operated in production. Weeks one and two are hardening — we deploy onto Agent Runtime with autoscale, retry shapes, and structured tracing into your existing observability stack. Weeks three and four wire the persistence and identity layer: Memory Bank for per-user state, Agent Registry enrollment with the policy and audit envelope your team already runs, Model Armor enforcement at the gateway. Weeks five and six are the operator handoff — runbooks the on-call engineer can actually follow, alerting wired to the channels your team watches, evals running in CI, and a four-week post-launch support window so the first production incident is one we work through together. You leave the engagement with a single named outcome shipped, one production agent, one accountability line your team owns end-to-end. No staff augmentation, no permanent embed — the muscle stays with your team after we hand it off.

Week by week

Weeks 1–2
Runtime hardeningAgent Runtime deployment with autoscale, retries, and structured tracing into your observability stack. CI/CD pipeline wired against your repo.
Weeks 3–4
Instrumentation + governanceMemory Bank for per-user state, Agent Registry enrollment with policy and audit envelope, Model Armor enforcement at the gateway.
Weeks 5–6
Handoff + post-launch supportRunbooks, alerting wired to your on-call, evals in CI, and a four-week post-launch support window so the first incident is worked together.

In scope

Hardening the Pilot agent onto Agent Runtime with autoscale and retries.
Memory Bank for state, Agent Registry enrollment, Model Armor at the gateway.
Operator runbooks, alerting against your on-call, and CI/CD against your repo.
Four-week post-launch support window after the production handoff.

Not in scope

Multi-agent platform wiring or A2A interop (that is the Platform rung).
Custom model fine-tuning or in-house base-model training.
Permanent staff augmentation or long-term operator embedding.
Agentizing additional workflows beyond the Pilot scope.

Screenshot of the Gemini Enterprise Agent Studio console showing the agent build and deployment interface in light mode. — Agent Studio — the console surface Production agents are operated from.

Plan Production

PLATFORM · 10 WEEKS

Multi-agent systems, A2A by default.

Duration: 10 weeks
Deliverable: A multi-agent platform
Pricing: Fixed engagement, named platform shape

Ten weeks to wire a platform, not a one-off agent. Weeks one through three are architecture — we map the domain into the agents that should exist, agree the boundaries between them, and pick the Agent2Agent (A2A) v1.2 contract shape every agent will speak. Weeks four through six are the multi-agent build — two or more first-party agents land on Agent Runtime with shared Memory Bank state, registered in your Agent Registry, with third-party agent interop where the workflow demands it. Weeks seven through ten are fleet ops — cross-agent evals, Agent Analytics dashboards your team operates day one, on-call rotation against the platform rather than against any single agent, and the governance envelope that makes adding the next agent a one-day exercise instead of a one-month project. You leave with a platform your team operates, not a system that operates around them — the registry, the evals, and the analytics are infrastructure you own, and the next agent ships against the platform you already run.

Week by week

Weeks 1–3
Architecture + A2A contractMap the domain into agents, agree boundaries, pick the A2A v1.2 contract every agent speaks. Architecture brief signed before the build starts.
Weeks 4–6
Multi-agent buildTwo or more first-party agents on Agent Runtime with shared Memory Bank, Registry enrollment, and third-party interop where the workflow requires it.
Weeks 7–10
Fleet ops + handoffCross-agent evals, Agent Analytics dashboards, on-call against the platform, and the governance envelope that makes the next agent a one-day exercise.

In scope