Google Cloud Professional Agentic Architect — Complete Exam

When you hear 'low-code,' your first instinct might be to file it under easy mode — the thing you use when you can't, or don't want to, write code. On this exam, that instinct will cost you points, because the exam treats low-code as a first-class architecture choice, not a concession.

What this lecture covers:

- Low-code is an architecture choice

- Two builders, one philosophy

- The decision: low-code or ADK

- The bank billing-dispute example

- Exam traps and trigger words

Everything in CX Agent Studio is a state machine, and the state machine has exactly three moving parts — pages, transition routes, and event handlers. Those three primitives carry the entire exam weight of this topic, so let's build them carefully.

What this lecture covers:

- The state-machine model: pages

- Transition routes: the edges between states

- Event handlers: the safety net

- The billing-dispute flow, fully wired

- What fires when: the exam drill

- Recap

When a low-code agent speaks, four layers of instruction compete — and their precedence is fixed. This is one of the most testable facts in the whole section, so let's state it as a ladder.

What this lecture covers:

- The prompt hierarchy, in order

- System instructions: the bank support example

- Templates, few-shot, and CoT: each one's job

- Temperature: the determinism dial

- Why hidden reasoning is never the audit record

A low-code agent is only as useful as the company knowledge it can reach. That's where Agent Search comes in — the managed enterprise search surface that connects agents to documents, tickets, and knowledge bases.

What this lecture covers:

- Agent Search: the managed search surface

- ACL-aware retrieval: the junior analyst and the memo

- Three wrong designs the exam dangles

- The RAG-vs-fine-tune rule

- Exam patterns and recap

Enterprise knowledge doesn't arrive as clean text. It arrives as 400-page policy PDFs full of tables — coverage limits, exclusions, plan tiers — plus recorded sales calls, screenshots, and scans.

What this lecture covers:

- Parse PDFs preserving structure

- Meaningful representations for every modality

- Ingest quality IS retrieval quality

- The exam angle: jumbled tables

- Recap and the section bridge

Before we configure anything, kill one idea: a coding agent is not autocomplete on steroids. Autocomplete finishes the line you were already writing.

What this lecture covers:

- Not autocomplete

- The loop: read, plan, edit, run

- Antigravity: the agent-orchestrating IDE

- Claude Code on Google Cloud

- The mental model

- Recap

You know the loop; now meet the workflow — the way Google teaches you to run a whole coding task with agents. It has four beats: start Antigravity, plan the work, orchestrate agents working in parallel, then integrate what they built.

What this lecture covers:

- The workflow in one line

- Walking the four beats

- Google's example, part one: "Hello, World(s)!"

- Part two: building the "Voyager" game in parallel

- The exam angle

- Recap

Your agent can read and edit code — but real work needs more: the issue tracker, the metrics backend, the migration system, the artifact registry. The naive move is ad-hoc integrations: a custom script here, a pasted API key there, a one-off webhook everywhere.

What this lecture covers:

- The integration spaghetti problem

- How MCP fits together

- Every server is a grant you chose

- Read-only versus write-capable

- Good config versus dangerous config

- Recap

Your agent can write a database migration. So can your teammate's agent.

What this lecture covers:

- The consistency problem

- What a custom skill is

- The exam's favorite sentence

- What skills are not

- Recap

The agent runs the loop, and the loop runs somewhere. That somewhere is the sandbox — the operational boundary the agent executes inside.

What this lecture covers:

- The sandbox is the boundary

- GKE: the policy boundary

- Cloud Workstations: the managed environment

- Antigravity and the Agent Sandbox

- The decision table

- The exam trap

Coding agents get hired for three jobs, and the exam names all three: refactor source code, optimize execution runtimes, and patch application-layer vulnerabilities. They look like different tasks — restructuring, speeding up, securing — but underneath they share one execution discipline: the safe change loop.

What this lecture covers:

- Three jobs, one discipline

- Job 1: Refactor

- Job 2: Optimize

- Job 3: Patch vulnerabilities

- The safe change loop

- The trap and the recap

Out of the box, a coding agent is a talented generalist with no knowledge of your company. It can write code in any style, follow any process, obey any convention — which means it follows none of yours.

What this lecture covers:

- The talented generalist

- The six mechanisms

- Skill versus rule

- Matching drills

- MCP versus the rest

- Recap

Three developers are experimenting with coding agents. A year later, every team uses governed agents in CI.

What this lecture covers:

- From experiments to fleet

- Build, then scale

- Govern, then optimize

- Individual versus fleet

- Trigger words

- Recap and the road ahead

Let's build the mental model you'll use for the rest of this course. In the Agent Development Kit, an agent is two things at once: a specification and an engine.

What this lecture covers:

- The spec and the engine

- The seven components

- Chatbot vs system

- The minimal design sequence

- Which component owns the failure

Last lecture gave you the mental model: the agent is the specification, the Runner is the engine, and seven components each do one job. Now we make it concrete: your first ADK agent.

What this lecture covers:

- From anatomy to artifact

- Name, model, description vs instruction

- Three run modes

- YAML declarative setup

- The order-status walkthrough

- What the model decides, what code decides

- Recap

Every custom agent you build starts with the same question: which model powers it? A large language model gives you maximum reasoning power — and maximum cost.

What this lecture covers:

- The question

- The three decision axes

- The five trade-off pairs

- The deployment matrix

- The decision checklist

- The logistics worked example

- The exam pattern

- Recap

Last lecture gave you the framework — five trade-offs, one checklist. Now the two classes you'll actually reach for on Gemini, in practice.

What this lecture covers:

- Flash-class vs Pro-class

- Temperature as a control knob

- Context discipline

- The optimization ladder

- Exam angle and recap

Instructions are the agent's job description — and most agents are hired with a two-sentence posting and then blamed for underperforming. Basic prompting says 'help users with their orders' and hopes for the best.

What this lecture covers:

- Instructions are the job description

- Persona, role, communication style

- Boundaries as instructions

- Grounded instructions

- ADK best practices

- Exam angle: instructions never enforce

Every production agent eventually hits this wall: the model emits free text, and downstream code parses it with hope. A regex here, a string split there, a prayer that the model phrases things the same way tomorrow.

What this lecture covers:

- Parsing with hope

- The contract, validated before acting

- The retry pipeline

- Examples help, contracts enforce

- Exam angle and recap

The default agent loop is reactive: see the request, pick a tool, look at the result, pick another tool, repeat. For simple tasks that's perfect — one lookup, one answer, done.

What this lecture covers:

- The wandering loop

- What BuiltInPlanner does

- When planning wins

- Plan quality is map quality

- Exam angle and recap

A multi-turn agent that can't remember where it stands is just a chatbot with amnesia. 'And when was it shipped?' is meaningless unless the agent knows which order you're talking about and what it already looked up two turns ago.

What this lecture covers:

- The "where are we" problem

- State dict vs conversation history

- Dynamic instructions with {var} templating

- Tenant isolation

- State namespaces

- Exam angle and recap

The word 'memory' hides four different things, and the exam will hand you a piece of information and ask where it belongs — get the layer wrong and the design fails. Layer one: turn context — this single model call, living for seconds, gone when the turn ends.

What this lecture covers:

- Four layers of "memory"

- How the Memory Bank works

- The write policy

- The retrieval policy

- Three exam traps

- Recap

Everything so far — the model, the instructions, the memory — lives inside the agent's head. Tools are how it touches the world: the model reasons, tools act.

What this lecture covers:

- Tools are the hands

- Built-in tools

- Custom function tools

- The design rules

- Written for a smart, literal reader

- Recap

Function tools cover code you own — functions in your codebase, with your schemas and your tests. But agents also need capabilities that live elsewhere: third-party APIs, proprietary systems, whole specialist agents built by other teams.

What this lecture covers:

- Beyond function tools

- MCP: the shape

- Combining tools and agents-as-tools

- Error handling

- Tool output is data, never instructions

- Exam angle and recap

The most expensive RAG mistake is treating retrieval as one knob: 'we plugged in vector search and the answers are bad, so vector search must be bad' — followed by months of tuning the wrong stage. Retrieval-augmented generation is a ten-stage pipeline, and quality problems almost always live in exactly one stage.

What this lecture covers:

- A pipeline, not a toggle

- Ingest, parse, chunk

- Embed, index, retrieve

- Retrieval modes

- Filter, then rerank

- Ground and evaluate

- Picking the service

- Exam angle and recap

Here's a principle the exam treats as non-negotiable: agents never touch production databases directly. No database credentials in the agent's configuration, no SQL generated by the model against your production tables, no direct connection the agent could misuse — or that a prompt injection could ride straight into your data layer.

What this lecture covers:

- Agents never touch production databases

- The three tiers

- Inside Tier 2

- Tier 3: the agent authenticates and consumes

- The insurance-adjuster example

- Exam angle and recap

Every tool call an agent makes passes a checkpoint with one question: who is acting? Not what the agent's instructions say — instructions are words, and words don't authenticate.

What this lecture covers:

- Who is acting?

- Six layers, one question each

- Do not collapse the layers

- The hr-ticket-create micro-scenario

- Exam angle and recap

A skill is a portable package of domain knowledge: the procedures, examples, and know-how an agent needs for one area of expertise — say, the refunds playbook, or the deployment runbook, or the support escalation ladder. Packaged once, it travels: the same skill slots into Antigravity, into ADK agents, and into the enterprise Skill Registry.

What this lecture covers:

- Skills are portable knowledge

- Scaffold and test locally

- The Skill Registry

- Agents CLI and 24/7 cloud agents

- Configuring skills with Agents CLI

- Exam angle and recap

Two infrastructure pieces close out the capability story: the Agent Registry and Google Cloud's managed MCP servers. And the sentence that governs the first one — the sentence the exam will test you on — is this: the Agent Registry is a phone book, not a firewall.

What this lecture covers:

- A phone book, not a firewall

- The Agent Registry

- Managed Google Cloud MCP servers

- Prebuilt vs custom, and the remote-tool checklist

- Exam angle and recap

Agents need two kinds of relationships with the outside world, and the exam tests whether you can tell them apart — because confusing them is expensive in both directions. Sometimes the agent needs a capability: call this tool, read this data, execute this function.

What this lecture covers:

- Two relationships

- Capability vs collaborator

- The Meridian Analytics worked example

- Why not inverted

- The handoff contract and stem signals

- Exam angle and recap

Before the patterns, the principle — and it's the most violated principle in agentic design: use one agent by default. One agent with good tools handles a surprising amount — research, retrieval, tool calls, synthesis — in a single trace with a single latency budget.

What this lecture covers:

- One agent by default

- Six patterns

- Draw the dependency graph

- Hierarchies and flow controls

- The multi-agent tax

- Loop stop conditions

- Exam trap and recap

Watch an agent demo and it looks like magic: it chats, it calls tools, it closes the loop. Here is the uncomfortable truth this section opens with — a demo is a script, and production is a storm.

What this lecture covers:

- Demo magic, production storm

- The invoice story

- The four-part quality gate

- Grade the trajectory, not the prose

- The four failure classes

- Recap

Last lecture gave you the quality gate. Now the hard question: what do you measure it against?

What this lecture covers:

- Your eval set is a mirror

- Categories one to three: outcomes, determinism, trajectory

- Retrieval, adversarial, ambiguous, multilingual, edge

- Failure modes, abstention, sanitized sourcing

- The exam trap

- Recap

You have the dataset. Now: what runs it?

What this lecture covers:

- Three modes, three jobs

- ADK evalset: the local regression loop

- Gen AI evaluation service: managed scale

- Custom autorater: your domain rules

- The four judge types

- The exam trap: deterministic property, deterministic judge

- Recap

Evaluation is not a phase you finish. It is a loop that never closes — because production never stops changing.

What this lecture covers:

- The loop that never closes

- Define, Baseline, Compare

- Gate by risk category

- Worked example: green averages, red safety row

- Curate, Monitor, Refresh — plus canary and holdout

- Recap

Here is a mindset shift the exam rewards: your agent is software, so it gets the software treatment — automated builds, automated tests, gated deployments. A prompt edit is a code change.

What this lecture covers:

- Agents are software; ship them like software

- Quality gates live inside the pipeline

- The lab shape: build, evaluate, gate, deploy

- Immutable, versioned artifacts

- Separate environments and identities

- Recap

The pipeline is built. The gates are green.

What this lecture covers:

- The runtime question

- Agent Runtime: the managed default

- Cloud Run: the custom container

- GKE: only with a Kubernetes-specific requirement

- The decision flow and the classic trap

- The reverse trap: the sidecar

- Recap

Last lecture made Agent Runtime the default. This lecture opens the hood: what does 'managed' actually buy you?

What this lecture covers:

- What "managed" actually buys you

- Local first, then deploy the same agent

- Control plane vs data plane

- The Agent Sandbox, sessions, and Memory Bank

- The exam patterns

- Recap

Something is wrong in production. The instinct is to guess — tweak the prompt, restart the service, blame the model.

What this lecture covers:

- Pull one failing trace

- The six-link chain

- Symptom table, part one: drift, latency, loops

- Symptom table, part two: hallucination, failure, cost, side effects

- Worked trace: the duplicate refund

- Recap

Last lecture assumed the traces exist. This lecture makes sure they do.

What this lecture covers:

- The four-layer stack

- Instruments, times, records

- Log the trace, sanitize the content

- SLOs for agents

- The exam trap: wrong bottleneck

- Recap

Everything in this section so far has treated quality as the goal. This lecture treats money as the constraint — because every token your agent burns has a price, and agentic workloads burn tokens the way sports cars burn fuel.

What this lecture covers:

- The bill arrives

- The cost drivers

- The reduction levers

- Cost per successful task

- The FinOps loop

- Recap

Welcome to Section 5: securing and governing agentic workflows. Fifteen percent of the exam, and the section where candidates bleed the most points.

What this lecture covers:

- The chain that resolves a third of the questions

- Authentication proves who; authorization permits what

- OAuth 2.0 and the Auth Manager

- Semantic governance and IAM are complements, not substitutes

- Running the chain on a real call

- Exam trap: hygiene is not authorization

- Recap

Every agent gets its own distinct principal. An Agent Identity is a dedicated service account or workload identity that exists solely for that one agent.

What this lecture covers:

- One agent, one principal

- Least privilege at the narrowest scope

- PAB: the ceiling you never exceed

- Short-lived credentials, per-agent revocation

- Worked example: the support agent

- Trap roundup: the identity greatest hits

- Recap

The Agent Gateway sits in the middle of agent-to-tool traffic. Every call the agent makes to a tool passes through it — and that position lets it do three things.

What this lecture covers:

- The gateway sits in the middle of every call

- What the gateway does NOT do

- Deterministic control that survives model failure

- The audit trail: every call, recorded

- Exam trap: match the layer to the threat

- Recap

This lecture is the layered-control table — what each governance control does, and just as importantly, what it does not do. The exam's favorite wrong answer is a real control doing someone else's job, so learn the table as pairs: the job, and the job it never does.

What this lecture covers:

- The registries: metadata, not muscle

- Model Armor screens text; Sensitive Data Protection classifies data

- Logging: the flight recorder, not the seatbelt

- The multi-select rule

- The greatest-hits traps

- How the layers stack: defense in depth

- Recap

Guardrails are the deterministic checkpoints you bolt onto a probabilistic agent. The mechanism is callbacks — code that runs before or after model calls, tool calls, and agent steps.

What this lecture covers:

- Callbacks: deterministic guardrail points

- Where to put human-in-the-loop

- Anatomy of a well-designed approval request

- The loop guard: budgets that escalate

- Approvals are scoped, expiring, single-use

- Recap

The confused deputy is the classic privilege-escalation shape in agentic systems, and the exam loves it because it hides inside architectures that look reasonable. The setup is simple: the agent legitimately holds more privilege than the invoking user.

What this lecture covers:

- The confused deputy

- The four-part defense

- Worked example: the doc summarizer that leaked

- The half-measure traps

- Authorize at action time, not login time

- The mantra

Part 1 is behind you. You passed the multiple-choice exam, Pearson confirmed it, and now a new door opens — the Part 2 hands-on labs.

What this lecture covers:

- The second gate

- What the labs actually validate

- Preparing the mechanics

- Working the lab: constraints, ladder, clock

- Traps to avoid

- The builder's mindset

Exam day has two parts to plan: the format and yourself. The format first.

What this lecture covers:

- The logistics

- Read constraints first, adjectives second

- The determinism ladder as an answering tool

- The classic traps

- Score, results, and sleep

You have finished the course. You understand the five domains, the determinism ladder, the deployment tradeoffs, the governance controls.

What this lecture covers:

- Knowledge isn't readiness

- The practice-tests course

- The protocol

- Go prove it