Google Cloud Agentic Architect

Many agents need no custom code. You configure state-based workflows and system instructions in Gemini Enterprise tools and CX Agent Studio, control how an agent moves between steps, and test behavior before real users see it.

• State-based workflows: steps, conditions and handoffs
• Writing system instructions that constrain behavior
• Building conversational agents in CX Agent Studio
• Multi-step business processes with Workflow Builder
• Testing and iterating on agent behavior
• Knowing when low-code has reached its limit

You build A low-code agent with a state-based workflow and tested system instructions.

Agents are only as useful as the information they can reach. You connect enterprise sources through Agent Search, keep access permissions intact, and bring images, audio, video and documents into the same agent.

• Connecting enterprise data sources to an agent
• Agent Search: indexing and retrieval for agents
• Respecting document-level permissions
• Handling images, audio, video and documents
• Keeping connected data fresh
• Judging answer quality over connected data

You build An agent that answers questions over enterprise documents and images with permissions respected.

Coding agents change how software gets built, and they need boundaries. You give them tools through MCP servers, shape their behavior with skills and plugins, run them in secure sandboxes on GKE and review what they produce.

• What coding agents do well and where they need oversight
• Connecting tools through MCP servers
• Working with Antigravity
• Skills and plugins that carry team conventions
• Running agents in sandboxes on GKE
• Reviewing and testing agent-written code
• Customizing coding agents for enterprise workflows

You build A coding agent setup with MCP tools, shared skills and a sandboxed runtime.

Custom agents begin with a model and a framework. You choose between Gemini models on quality, latency and cost, then build agents with the Agent Development Kit, define their tools and compose single and multi-step agents.

• Choosing a model on quality, latency and cost
• Prompts and instructions for agents
• ADK basics: agents, tools and the runner
• Writing tools a model can call reliably
• Workflow patterns: sequential, parallel and loop
• Structured output and validation

You build An ADK agent with three tools and a workflow that handles tool failure.

A useful agent remembers the right things. You manage conversation sessions, keep working state between steps, and add longer-term memory without letting context grow until the agent loses the thread.

• Sessions and session state in ADK
• Short-term context versus long-term memory
• Memory services and what to store
• Trimming and summarizing context
• Isolating memory between users
• Retention and deletion rules for stored memory

You build An agent that remembers user preferences across sessions and honors deletion requests.

Retrieval is how most enterprise agents learn your facts. You prepare and chunk content, create embeddings, query vector search and rerank results, then measure whether retrieval actually improves answers.

• Preparing and chunking source content
• Embeddings and vector search
• Hybrid retrieval and reranking
• Grounding answers with citations
• Evaluating retrieval separately from generation
• Handling multimodal sources in RAG

You build A RAG pipeline over real documents with a retrieval quality report.

Several specialist agents often beat one general agent, if they hand off work cleanly. You design topologies, share tools through MCP, connect agents across teams with A2A, and give each agent its own identity.

• Supervisor, peer and pipeline topologies
• Handoffs and shared state between agents
• Exposing tools through MCP
• Agent-to-agent communication with A2A
• Identity for each participating agent
• Debugging a conversation between agents

You build Two agents from different teams that cooperate over A2A and share tools through MCP.

A demo is not evidence. You build golden datasets from real tasks, score both final answers and the steps an agent took, and make evaluation a continuous check that catches regressions and drift.

• Building a golden dataset from real tasks
• ADK evalsets and how to run them
• Scoring final answers versus tool trajectories
• Model-based judges and their limits
• Continuous evaluation on samples of live traffic
• Regression gates before release

You build An evaluation set and a continuous check that scores every change to an agent.

Where an agent runs shapes its scaling, cost and control. You compare Agent Runtime, Cloud Run and GKE, package and release agents safely, and size capacity for uneven, long-running work.

• Comparing Agent Runtime, Cloud Run and GKE
• Packaging an agent as a service
• Scaling stateful and long-running agent work
• Release strategies and rollback for agents
• Configuration, secrets and environments
• Cost and latency of deployed agents

You build An agent deployed to a managed runtime with a staged release and rollback.

Agents drift, loop and slow down once real users arrive. You monitor quality, cost and latency, read traces to find the cause, and fix reasoning loops, slow tool calls and drift.

• Tracing agent runs and tool calls
• Dashboards for quality, cost and latency
• Detecting drift and silent quality loss
• Breaking reasoning loops
• Finding and fixing slow tool calls
• Feeding production failures back into test sets

You build A monitoring setup with traces and alerts that catches an injected reasoning loop.

An agent that can act needs the least access that still lets it work. You assign identities, set access boundaries, and authenticate tool calls with OAuth 2.0 so actions run with the right user’s rights, not a shared super account.

• Agent identity and service accounts for agents
• Setting access boundaries with IAM
• OAuth 2.0 flows for tool calls
• Acting on behalf of a signed-in user
• Storing and rotating credentials
• Auditing what an agent did

You build A tool-calling agent that acts for a user with scoped OAuth access and an audit trail.

Controls around the agent matter as much as the agent. You route traffic through Agent Gateway, screen prompts and responses with Model Armor, track agents in a registry and decide where a person must approve.

• Routing agent traffic through Agent Gateway
• Screening prompts and responses with Model Armor
• Prompt injection and tool abuse defenses
• Registering and governing agents with Agent Registry
• Human-in-the-loop approval points
• A policy for what an agent may never do

You build A guarded agent with gateway routing, Model Armor screening and an approval step, tested against attacks.

Everything meets in one workflow. You pick the right mix of low-code and custom agents, connect data, evaluate, deploy and secure the result, then defend the design on quality, cost and control.

• Scoping a workflow and its constraints
• Combining low-code and custom agents
• Connecting data, tools and identities
• Evaluating, deploying and monitoring
• Applying gateway, guardrails and review
• Presenting and defending the design

You build A deployed agentic workflow with evaluation, monitoring, security controls and a design record.