CertifyDeck
Start for free
All cheat sheets
Professional Agentic Architect · CHEAT SHEET

Google Cloud Certified Professional Agentic Architect

Key concepts grouped by official exam weight.

Download as PDF (free, no sign-up)

1. Building agents using low-code tools

13–13%

Configuring agentic workflows and behavior using low-code tools

  • In Dialogflow CX flows each page is a state: routes (intent or condition) and event handlers decide responses and transitions according to their scope and evaluation order. CX Agent Studio reuses those flows as flow-based agents with explicit input and output variables, and Workflow Builder (formerly Agent Designer) chains triggers, steps, conditions and human approvals.
  • System instructions set role, goals, constraints and format, but they do not fully prevent leaks. CX Agent Studio restructures instructions into XML and supports global instructions, modular components and few-shot examples with tool_code and tool_outputs. Examples should be used sparingly with consistent formatting, and in chain-of-thought the reasoning comes before the final answer.

Connecting enterprise data to Gemini Enterprise

  • Gemini Enterprise connects data through data stores: federation queries in place with the user's credentials and keeps their permissions, while ingestion indexes data for better search but does not carry over BigQuery or Cloud SQL permissions. Access control needs an identity provider and ACLs, and organization policy constraints, VPC Service Controls and Agent Gateway govern which sources and MCP servers can be connected.
  • For documents with images, Gemini Enterprise offers the OCR parser (cheaper, PDF only) and the layout parser, which requires chunking and can annotate images and tables. Gemini models on Agent Platform process video and audio from Cloud Storage, with clipping, adjustable fps and timestamps; bucket permissions are not imported.

2. Using coding agents for application development

17–17%

Using coding agents effectively

  • Antigravity defines MCP servers in mcp_config.json (local stdio or remote Streamable HTTP), with ADC, OAuth, enabledTools and Deny > Ask > Allow rules; workspace skills live in .agents/skills. Google Cloud MCP servers need mcp.tools.call plus resource permissions and support toolsets and IAM deny policies; Claude Code uses Agent Platform with roles/aiplatform.user.
  • Agent Sandbox on GKE isolates untrusted code with gVisor or microVMs, uses SandboxTemplate, SandboxWarmPool and SandboxClaim, and creates a default-deny NetworkPolicy per template; Agent Substrate suspends idle agents. Cloud Workstations in a VPC Service Controls perimeter needs a private cluster without public IPs, and the Antigravity sandbox blocks sensitive files and limits network access.
  • In Antigravity, /plan explores code and drafts a reviewable plan before edits, /boost uses several agents for concurrency bugs, optimizations and intricate refactors, and /teamwork coordinates multi-day migrations. CodeMender finds vulnerabilities, verifies them with a proof-of-concept exploit and generates tested patches; diff scans gate pull requests and deep scans serve audits.

Customizing coding agents for enterprise workflows

  • In Antigravity, rules (AGENTS.md or .agents/rules with always_on, model_decision, glob or manual triggers) set constraints and skills (folders with SKILL.md) describe multi-step workflows. Hooks in hooks.json run scripts before or after agent actions, custom subagents live in .agents/agents, and a plugin with plugin.json packages everything into one versioned unit.
  • Agents CLI installs seven ADK lifecycle skills into Antigravity and other coding agents and also runs standalone from the terminal. Its commands scaffold, evaluate, deploy to Agent Runtime, Cloud Run or GKE with Agent Identity and Agent Gateway, publish to Gemini and enable tracing and BigQuery analytics; extensions override or add commands pinned to a commit.

3. Developing custom agents

33–33%

Designing and building agentic workflows in code

  • Pick the cheapest model that meets quality and latency, and route: simple tasks to a small model and complex reasoning to a larger one. Managed models (Gemini, partners, MaaS) minimize operations and suit variable traffic; self-deploying an open model from Model Garden or on GKE gives control of weights, hardware and network for strict regulation and predictable volume.
  • In ADK, an LlmAgent combines a model, instructions, tools and output schemas; the LLM picks tools from their name, docstring and parameters. Callbacks (before/after agent, model and tool) observe or replace steps to build deterministic guardrails, and plugins are registered once on the Runner or App for global policies. Artifacts store binary files.
  • A session holds one conversation's events and state; production needs a persistent service such as Agent Platform Sessions, automatic when deploying to Agent Runtime. The user:, app: and temp: prefixes set state scope. Memory Bank uses an LLM to extract meaningful facts, consolidates them per scope and retrieves them by similarity, with configurable topics, TTL and asynchronous generation.
  • Agents CLI works with a coding agent, into which agents-cli setup installs seven skills (global by default, --workspace for the project, --agent to pick agents), or without one from the terminal: -i enables prompts for human use and -y skips them. Extensions override or add commands and copy skills into .agents/skills, pinned to a commit that agents-cli install restores.

Integrating enterprise domain knowledge

  • RAG Engine covers ingestion, chunking (size and overlap), embedding, indexing into a corpus and retrieval, with reranking through the ranking API or an LLM; the embedding model is fixed for the corpus. Vector Search offers ANN indexes with restricts and dense plus sparse hybrid search; Agent Retrieval manages collections of data objects with automatic embeddings, RRF fusion and VertexRanker.
  • Agent Identity gives each agent its own SPIFFE identity that is not shared, has no long-lived keys and cannot be impersonated; roles are granted with allow policies on its principal (principalSet for the whole project) and removed with deny policies. Each redeployment creates a new principal, and deleting an agent does not remove its IAM bindings.
  • Google Cloud remote MCP servers (Cloud SQL, BigQuery and others) turn on with their API, register themselves in Agent Registry and are controlled with IAM (MCP Tool User role, read-only deny policies) and Model Armor. Your own APIs become MCP servers through Apigee or Cloud Run; external servers are registered manually with a toolspec.json and their credentials live in auth manager through bindings.

Orchestrating and coordinating agentic workflows

  • MCP connects an agent to its tools and resources; A2A connects independent, opaque agents that share no memory or tools, through Agent Cards, stateful tasks, contextId, SSE streaming and push notifications. In ADK, to_a2a() exposes an agent and RemoteA2aAgent consumes it; local sub-agents remain the better fit for low-latency internal logic with shared state.
  • ADK offers deterministic SequentialAgent, ParallelAgent and LoopAgent, graph workflows with routes, JoinNode and human input nodes, and collaborative teams with chat, task or single_turn modes. On Google Cloud, Agent Registry resolves subagents and tools at runtime, Agent Identity gives each agent its own IAM principal, and Agent Gateway blocks by default anything a policy does not allow.

4. Evaluating and deploying agentic workflows

22–22%

Evaluating agents in development and in production

  • In ADK, each evalset case stores per turn the query, the expected tool trajectory, intermediate responses and the final response, plus an initial session state; adk web turns real sessions into cases. For edge cases without hand-writing them, user simulation generates scenarios (starting prompt, plan and persona) and environment simulation injects tool errors.
  • In CI, ADK evaluates with pytest (AgentEvaluator), adk eval or adk conformance test; tool_trajectory_avg_score checks the trajectory with EXACT, IN_ORDER or ANY_ORDER matching. In production, Agent Platform online monitors sample Cloud Trace traces, score metrics such as Tool Use Quality and export scores to Cloud Monitoring, where alerting policies flag drift.
  • ADK evalsets evaluate agents in development with deterministic criteria (trajectory, ROUGE-1) or with an LLM judge (rubrics, hallucinations). The Gen AI evaluation service offers adaptive rubrics (recommended), static rubrics and computation-based metrics; for your own criteria, custom LLM or code metrics are registered in the Metric Registry and reused offline and online.
  • In ADK, the golden dataset lives in test files (one session, unit tests) or evalsets (many long sessions, integration tests), holding expected tool calls and a reference answer. The criteria tool_trajectory_avg_score (EXACT, IN_ORDER, ANY_ORDER), final_response_match_v2 and hallucinations_v1 measure retrieval, meaning and grounding.

Deploying and scaling production workloads

  • Agent Runtime is the fully managed runtime with built-in Sessions, Memory Bank and observability, but it does not host custom MCP servers. Cloud Run runs serverless containers that scale to zero and need external storage for state. GKE gives the most control (node pools, accelerators, network policies) at the cost of more operational overhead.
  • Cloud Trace spans show whether time goes to model or tool calls; synchronous tools prevent parallel execution. Loops are bounded with max_iterations or escalate in a LoopAgent and with max_llm_calls in RunConfig. Drift is detected with online monitors and quality alerts, and deployment failures are diagnosed from the linked logs.
  • Agent Platform provides per-agent observability views (latency per tool and model, tokens, usage) and traces with model inputs, responses and tool calls to locate logic errors. On Agent Runtime, min_instances mitigates cold starts and container_concurrency reduces queuing for asynchronous agents. Online monitors and quality alerts detect drift and hallucinations; in ADK, hallucinations_v1 and the efficiency criteria measure grounding and cost.

5. Securing and governing agentic workflows

15–15%

Configuring agent security and governance

  • Agent Identity gives each agent a non-shared SPIFFE identity with no long-lived keys and tokens bound to its certificate. On its own authority it uses its identity for Google Cloud, OIDC ID tokens, 2-legged OAuth or API keys; on behalf of a user it uses 3-legged OAuth with consent. Auth manager stores credentials, automates consent and refresh, and ADK injects the headers into tool and MCP server calls.
  • A principal access boundary (PAB) policy is bound to principal sets, such as a project's agent identities, and defines which resources they are eligible to access even if they hold roles elsewhere. It never grants access, is additive, fails closed and depends on its enforcement version. For agents it is evaluated on outbound calls, and Agent Gateway can enforce it through IAP.
  • Agent Gateway is the entry and exit point for agentic traffic: it requires an Agent Identity per agent, checks destinations in Agent Registry and denies by default anything no IAM policy allows. Policies should be tested in dry-run mode, which only logs violations, before ENFORCE. Its request logs record decisions, the MCP tool and the registry resource, and OpenTelemetry tracing correlates with them.
  • Agent Registry catalogs agents, MCP servers, endpoints and skills; IAM policies bind the registered resource name and the agent principal, never the URN, and a management boundary aggregates components across projects. Model Armor screens prompts and responses with templates; floor settings prevent less strict templates, and you should start with Inspect only before blocking.

Implementing secure agent behavior and execution

  • Agent Gateway enforces policies: IAP through REQUEST_AUTHZ for identity, and Model Armor or semantic governance through CONTENT_AUTHZ; test in DRY_RUN before ENFORCE. Semantic governance checks each tool call against user intent and natural language rules. For human-in-the-loop, ADK offers tool confirmation and RequestInput nodes, and Workflow Builder offers review steps.
  • Agent Identity separates three identities: the user's, verified at ingress by Agent Gateway; the agent's, for its own authority; and the delegated one, with 3-legged OAuth brokered by auth manager, which must satisfy both the agent's policies and the user's permissions and logs both. Agent Registry binds agents to endpoints and auth providers without secrets in code.
Practice this certification