Certification Study Notes

Gemini Enterprise & Low-Code Agents

Employee-facing agents on Gemini Enterprise (formerly Agentspace) — editions, connectors and permissions-aware grounding, Google-made agents, the Agent Gallery, Agent Designer (now Workflow Builder), registering custom ADK and A2A agents, and admin governance — plus customer-facing agents in CX Agent Studio (the evolution of Dialogflow CX): instructions, tools, callbacks, evaluation, flows and human handoff, closed by a low-code vs pro-code decision matrix.

Author: Michaël Bettan

Track: Google Cloud / Professional Agentic Architect

Test Yourself: Gemini Enterprise Practice Quiz →

Overview & Mental Model

Gemini Enterprise (formerly Google Agentspace) is Google Cloud's employee-facing agent platform: an intranet search engine, an AI assistant, and an agentic platform in one web app. It answers from permissions-aware search across Google and third-party data, runs Google-made agents, lets employees build their own no-code agents, and hosts custom agents built by developers. Customer-facing conversational agents live in a sibling product, Gemini Enterprise for Customer Experience (CX), whose builder is CX Agent Studio. Pro-code agents are built with ADK on the Gemini Enterprise Agent Platform (the evolution of Vertex AI).

Layer	Product	Primary audience	Build style
Employee-facing app	Gemini Enterprise (search, assistant, Agent Gallery, Workflow Builder)	Employees inside the company	No-code / low-code (Workflow Builder) plus registered custom agents
Customer-facing conversations	Gemini Enterprise for CX — CX Agent Studio (console at ces.cloud.google.com)	End customers on chat and voice channels	Minimal-code, built on ADK, with optional Python callbacks and tools
Builder platform	Gemini Enterprise Agent Platform — ADK, Agent Runtime, Agent Studio, Agent Search, Agent Gateway, Agent Registry	Developers and platform teams	Pro-code (ADK) and low-code prototyping (Agent Studio)

Old / legacy name	Current name	Note
Google Agentspace	Gemini Enterprise	Same product line, broadened to an agent platform
Agent Designer	Workflow Builder	The exam guide still says "Agent Designer"; the docs now say Workflow Builder
NotebookLM Enterprise	Gemini Notebook Enterprise	Included with Standard and Plus editions
Vertex AI	Gemini Enterprise Agent Platform	Pro-code builder platform
Vertex AI Agent Engine	Agent Runtime	API resource name is still `ReasoningEngine`
Vertex AI Studio	Agent Studio	Low-code designer for prompts, system instructions, and agent workflows
Vertex AI Search	Agent Search	Grounding and search apps for custom builds
Dialogflow CX	CX Agent Studio (evolution)	Dialogflow CX flows can still be called from CX Agent Studio

Tip — The one-line mental model

Employees → Gemini Enterprise (Workflow Builder first, register ADK/A2A agents when no-code runs out). Customers → CX Agent Studio. Developers who need full control of code, runtime and evals → ADK on Agent Runtime, then surface the agent in Gemini Enterprise or behind CX Agent Studio.

1. Editions & Product Map

Edition choice decides which builder features, data volume and security controls are available. Read the table as "what blocks me" rather than as a price list (prices are out of scope and change often).

Edition	Seats	Pooled storage	Defining traits
Business	1–500 users	25 GiB	SaaS at business.gemini.google with no Google Cloud console or IAM; no full connector ecosystem, no Data Insights, no own full-code agents, no Agent Marketplace, no enterprise-grade security and compliance controls
Standard	1+ users	30 GiB	Full Google Cloud administration; includes Gemini Notebook Enterprise
Plus	1+ users	75 GiB	Everything in Standard with a larger storage pool and higher quotas; includes Gemini Notebook Enterprise
Pay-as-you-go	1 seat minimum	Pay-as-you-go	Billed to an invoiced Cloud Billing account
Frontline (add-on)	Requires 150+ Standard or Plus users	2 GiB	For frontline workers; uses only admin-provisioned agents; cannot author no-code agents or create or upload skills

What changes between editions

Deep Research is available in all editions; Data Insights (preview) is in Standard, Plus, Pay-as-you-go and Frontline, not Business.
No-code agent building (Workflow Builder, formerly Agent Designer) is GA per the release notes; which editions include it can change, so check the edition comparison.
Custom full-code agents (ADK, A2A) and Agent Marketplace require a Google Cloud–administered edition, not Business.
Agent creation quota applies to registrations: Standard 1 agent per user per day, Plus 10 per user per day (pooled), Frontline 0.

Choosing between the three Google products

Gemini Enterprise — you want a ready-made, permissions-aware assistant and agent hub for employees.
Gemini Enterprise Agent Platform — you are building your own agentic application, model pipeline, or search experience with code (ADK, Agent Runtime, Agent Search).
Gemini Enterprise for CX — you are serving customers on web chat, apps or telephony with CX Agent Studio and Agent Assist.

Exam trap — Business edition is a dead end for platform requirements

If the scenario needs IAM, VPC Service Controls, CMEK, custom ADK or A2A agents, or the full connector catalog, Business edition is the wrong answer even for a small team. Choose Standard or Plus.

2. Connectors, Data Stores & Grounding

Gemini Enterprise grounds answers in data stores fed by connectors. A connector creates a separate data store per entity type — for example, a Jira connector yields stores for issues, comments, attachments and worklogs — and search respects source-system permissions.

Mode	How it works	Strengths	Trade-offs
Federated search	Query is sent live to the third-party API; nothing is copied or stored	No storage cost, no copy of data, near-real-time	Lower answer quality; subject to the third-party's terms and rate limits
Data ingestion (indexing)	Content and ACLs are copied into a Gemini Enterprise data store and indexed	Best search and answer quality, semantic ranking	Uses storage quota, needs sync time and scheduling

Sync type	Covers	Exam-relevant gotcha
Full sync	All entities, including deletions and identity/ACL changes	Needed to propagate removed documents and permission changes
Incremental sync	New and changed entities only	Does not propagate deletions or identity changes
Entity sync vs identity sync	Content records vs user and group membership	Both must run for ACL-correct answers

Data store options

Structured vs unstructured stores; regions global, US or EU for data residency; CMEK for customer-managed encryption keys.
Parsing: the layout parser is the default for PDF, HTML, DOCX, PPTX, XLSX and XLSM and does content-aware chunking; the OCR parser handles scanned PDFs; the digital parser handles machine-readable text; you can also bring your own parsed documents.
Chunking splits documents into retrievable chunks for retrieval-augmented generation (RAG); chunk quality drives answer quality.

Parser choice

The parser is set when the data store is created, as a default plus optional per-file-type overrides (pdf, html, docx, pptx, xlsx, xlsm).

Parser	What it detects	File types	Choose it when
Layout parser (default, recommended)	Paragraphs, tables, lists, titles, headings and images; adds generated descriptions for images and tables	PDF, HTML, DOCX, PPTX, XLSX, XLSM	Documents carry structure (sections, tables, figures) and you want layout-aware chunks
OCR parser	Paragraph text recognized from page images; only the first 500 pages of a PDF are processed	PDF only; other types fall back to the digital parser	PDFs are not searchable (scans, text inside images); set `useNativeText` to merge embedded text for mixed PDFs
Digital parser	Machine-readable text blocks only; no tables, lists or headings	All supported types, including TXT	Content is plain machine-readable text with no structure worth keeping
Bring your own parsed document (preview)	Whatever your own pipeline emits, as JSON text, table and list blocks	Pre-parsed JSON	You already parse elsewhere, for example with a Document AI layout parser processor

Fallback rule: when the chosen parser does not support a file type, the digital parser handles it (TXT files under a layout-parser store, non-PDF files under an OCR-parser store).
API default: a data store created through the API without documentProcessingConfig.defaultParsingConfig uses the digital parser, so request the layout parser explicitly (layoutParsingConfig).
Gemini-based parsing: Document AI offers layout parser processor versions powered by Gemini 2.5 Flash and Gemini 2.5 Pro (preview) for better layout analysis of PDFs. Running them outside the data store and importing the result as a parsed document is a design option, not a built-in Gemini Enterprise parser setting.
Federated connectors: connectors in federated mode (such as SharePoint and OneDrive) also use the layout parser, but real-time queries leave less room to analyze complex PDFs; use data ingestion mode when deep parsing matters.
HTML cleanup: excludeHtmlElements, excludeHtmlClasses and excludeHtmlIds drop navigation menus, headers, footers and sidebars before indexing.

Chunking options

By default a search data store is tuned for document retrieval (whole documents as results). For RAG, turn on chunking at data store creation, together with the layout parser.

Setting	Values	Effect
Layout-aware chunking (`layoutBasedChunkingConfig`)	On or off at creation	Text in each chunk comes from a single layout entity (a heading section, a list), which keeps chunks coherent
`chunkSize`	100 to 500 tokens; default 500	Smaller chunks give tighter matches on specific facts; larger chunks keep more surrounding context
`includeAncestorHeadings`	`true` or `false`; default `false`	Prepends the title and headings at all levels, so a chunk from mid-document keeps its context during retrieval and ranking
Search result mode	`chunks` in `ContentSearchSpec.SearchResultMode`	Returns chunks instead of documents in search responses
Bring your own chunks (preview)	Pre-segmented JSON per document	Replaces built-in chunking when you control segmentation

Note: chunk size is a trade-off, not a benchmark

The smaller-versus-larger chunk trade-off is general retrieval guidance, not a documented Gemini Enterprise benchmark. Inspect real chunks (Chunks.list, getProcessedDocument) before settling on a size.

Multimodal content

The layout parser annotates images (BMP, GIF, JPEG, PNG, TIFF embedded in documents) and tables with generated descriptions, so a chunk can be retrieved by what an image or table shows.
Standalone audio and video files (MP3, WAV, MP4, MOV and similar) are not on the unstructured data store format list, so the data store never parses or chunks a raw recording. Turn the recording into text first or use one of the other patterns in the standalone audio and video card below.
The assistant itself can analyze uploaded PDFs and images inside a conversation.

Need	Approach
One-off question about a single file	Upload it to the assistant; Gemini reads it in the conversation and nothing is indexed
Charts, diagrams or tables inside documents must be findable	Layout parser, whose image and table descriptions become retrievable text
Searchable archive of recordings or videos	Transcribe or describe first, then ingest the text with metadata (source, timestamps) so it is parsed, chunked and searchable like any document
Scanned paper records	OCR parser, with `useNativeText` when some pages already contain digital text

Standalone audio and video

Unstructured data stores accept TXT, PDF, HTML, DOCX, PPTX, XLSX and XLSM (Agent Search also lists JSON and Markdown), with files under 200 MB and up to 100,000 files per import. Audio and video need one of four patterns, chosen by corpus size, how much visual detail matters and who may see what.

Pattern	What gets indexed	Timestamps	Access control	Limits to remember	Weak spot
Transcribe or caption first, then an unstructured data store	Text segments (transcripts, scene descriptions) as HTML or TXT, with a JSONL metadata row per segment pointing back to the recording	Your own `structData` fields per segment (start, end, source URI)	`acl_info` readers in each metadata row, on a store created with access control enabled	Normal document limits	Visual and non-speech cues vanish unless the captioning step writes them down; you own the conversion pipeline
Agent Retrieval (formerly Vector Search 2.0) with `gemini-embedding-2`	One Data Object per short clip in a Collection, with embeddings autogenerated from the clip	Clip-level: store each clip's offsets as data fields	Enforced by your app, for example with filters on Data Object fields	Per embedding call: 8,192 input tokens, one video of up to 120 s (about 80 s with audio track extraction; MP4 or MPEG only, so convert MOV first), audio up to 180 s	Retrieves clips but does not answer; long recordings must be split first
Direct Gemini prompt with a Cloud Storage URI	Nothing; the file is read at request time	Audio: turn on `audio_timestamp` in the generation config; video: ask for `MM:SS` references in the prompt	Whoever can call the app and whatever objects it can read; no per-document ACLs	One audio file of about 8.4 hours (1M tokens) per prompt; up to 10 videos of about 45 min with audio or 1 hour without, on 1M-context models	Cost and latency on every question; does not scale to an archive
Agent Search media data store	Catalog records (required `title`, `uri`, `categories`, `available_time`; `duration` when optimizing watch time) plus user events such as `media-play` and `media-complete`	Item-level only	Catalog filters	User events are required for media apps	Never looks at frames or waveforms; it ranks on the record text you supply (including an optional `transcript` field) and on behavior

Transcribe or caption first: choose it when employees search thousands of meetings, calls or trainings inside Gemini Enterprise and each answer must respect source permissions; return the segment start time so users jump to the right moment.
Agent Retrieval with gemini-embedding-2: choose it when a custom agent must match a text query to what a clip shows ("forklift near the loading dock") across a large clip library; pass the top clips to Gemini in a second step when the user needs an explanation.
Direct Gemini prompt: choose it when a handful of known recordings (an outage bridge call, a screen-share bug report) need detailed questions answered now, with timestamps, and no index is worth building.
Media data store: choose it when a streaming or learning portal needs search and personalized "watch next" ranking driven by catalog metadata and viewing events.
Model support: the autogeneration table in Agent Retrieval lists text, image, video and PDF for gemini-embedding-2; the model also accepts audio when called directly, so audio-only clips can be embedded yourself and loaded as your own embeddings.

JSONL: transcript segment metadata (wrapped here; one line per record in the file)

{"id": "townhall-q3-seg-014",
 "structData": {"title": "Q3 town hall", "recording": "gs://media/townhall-q3.mp4",
   "start": "00:14:20", "end": "00:16:05"},
 "acl_info": {"readers": [{"principals": [{"group_id": "all-staff@example.com"}]}]},
 "content": {"mimeType": "text/html", "uri": "gs://media-text/townhall-q3/seg-014.html"}}

Anti-patterns: media store as a video brain, whole recordings as embeddings

A media data store only knows the catalog fields and user events you send it, so loading recordings into one and expecting answers about what a speaker said or showed fails. Sending an hour-long video to gemini-embedding-2 in one call also fails quietly: input past the token window is silently truncated, so split into clips that fit the per-call limits. The duration limits above come from the model capability tables (Gemini 2.5 and 3.x Flash and Pro families) and vary by model; check the specific model page before sizing a design on them.

Identity and access

Identity provider: Google Identity (recommended) or Workforce Identity Federation (the workforce pool must be global); one IdP type per location.
Search enforces source ACLs — users never see documents they cannot open in the source system (no privilege escalation). Third-party SaaS identities are mapped to the IdP identities.
A document's ACL can include up to 3,000 readers.

Exam trap — Federation is not "free quality"

Federated search avoids copying data but gives lower-quality answers than ingestion. When the requirement is "best answer quality on Confluence content", pick ingestion; when it is "data must never be copied out of the SaaS tool", pick federation.

Key fact — Agent Search for custom builds

When you build your own app or ADK agent instead of using the Gemini Enterprise web app, ground it with Agent Search (formerly Vertex AI Search) on the Agent Platform. Gemini Enterprise is the packaged employee experience; Agent Search is the developer building block.

3. Google-made Agents, Agent Gallery & Sharing

Agent type	Who builds it	Examples / notes
Google-made agents	Google	Core assistant, Deep Research, Gemini Notebook, Data Insights (preview), Co-Scientist
Workflow Builder agents	Employees (no-code)	Chat agents and workflows; admin must turn on "Enable Workflow Builder"
Custom ADK agents	Developers	Hosted on Agent Runtime, then registered in Gemini Enterprise
Custom A2A agents	Developers or partners	Registered via agent card (preview) or imported from Agent Registry
Dialogflow agents	Conversational designers	Existing Dialogflow agents surfaced in Gemini Enterprise
Marketplace agents (preview)	Partners	A2A agents procured from Google Cloud Marketplace and integrated by an admin

Agent Gallery

Filters: All, Pinned, Made by Google, From your organization, Your agents, Marketplace; users can pin favorites.
+ New agent opens Workflow Builder; users invoke an agent in chat with @agent_name.
Agents can also be invoked programmatically through the StreamAssist API or the agent's Agent Registry A2A endpoint.
Admins can view each agent's identity (a SPIFFE ID, falling back to the Agent Registry resource ID).

Agent state	Visible in gallery?	Users can interact?
Private	Only to the owner	Owner only
Enabled	Yes	Yes
Suspended	Yes	No
Disabled	No (hidden)	No

Sharing controls (admin)

Enable agent sharing — allow users to share agents they built.
Enable agent sharing without admin approval — skip the approval step.
Enable End Users to share with Groups — allow sharing to Google Groups instead of individuals.

Exam trap — Idea Generation is gone

The Idea Generation agent (preview) was removed in July 2026. Scenarios about brainstorming or hypothesis generation should point to the assistant, Deep Research, or Co-Scientist.

4. Agent Designer → Workflow Builder

Workflow Builder (renamed from Agent Designer) is the no-code / low-code builder inside Gemini Enterprise. It produces two artifact types.

Artifact	Behavior	How it starts	Best for
Chat agent	Conversational and non-deterministic; single- or multi-step with subagents	User chats with it (@name); can also be scheduled	Q&A over team knowledge, drafting, research helpers
Workflow	Ordered steps with variables passed between them; supports branching and human approval	Manual (@name), Schedule (including cron), or Event (connector data change)	Repeatable business processes, triage, report generation

Building a chat agent

Create from a natural-language prompt, or choose Proceed to builder for the visual flow editor.
Each node has Name, Description, Instructions, Model (Flash for low latency, Pro for complex reasoning), Data & tools, Knowledge files and Personalization (starter prompts; up to 3 shown at random).
A Schedule tab runs the agent on a timetable; leaving without Create saves a Draft.
Prompt mode cannot attach Google Cloud sources (BigQuery, Cloud Storage, Cloud SQL) — switch to the builder (designer) mode.

Building a workflow

Triggers: Manual, Schedule, Event.
Steps: Gemini Agent node (instructions, knowledge, connected apps, model — Gemini 3.0 or later — and output as text or a JSON schema), Condition (branching, filtering, loops), and Human-in-the-loop (request info or request approval).
MCP servers and existing agents can be added as steps or tools.
Versions can be saved, compared and restored; execution logs show each run.
Workflow connectors include Gmail, Calendar, Chat, Drive, Confluence, Jira, Teams, Notion, OneDrive, Outlook, Salesforce, SharePoint, ServiceNow and Slack.

Connector actions & knowledge rules

Search For Data actions are enabled per action; Add Or Update Data (write) actions are a connector-level, all-or-nothing toggle and require human review.
Write actions need the matching search actions enabled, otherwise the agent fails with ENTITY_NOT_FOUND.
A full Drive or OneDrive tool takes precedence over restricted knowledge — to scope access, split into two Gemini Agent nodes.
Uploaded knowledge files are placed in context every turn, up to 800,000 tokens combined; for large libraries (more than ~100 pages) connect a data store instead.
Builders can only use the connectors, tools and permissions an admin has provisioned.

State-based design and prompt craft

A workflow is a state machine you can see: steps are states, Conditions are transition routes, Human-in-the-loop steps are approval gates, and variables carry state between steps.
Write node Instructions like a system prompt: role, goal, constraints, output format. Add few-shot examples for format-sensitive outputs and ask for step-by-step reasoning (chain of thought) on analytical nodes; prefer a JSON-schema output when the next step parses it.
For customer-facing state machines with pages, routes and event handlers, see CX Agent Studio and Dialogflow CX flows (sections 07–08).

Exam trap — Chat agent vs workflow

"Every Monday, pull new Jira bugs, summarize, and ask a lead to approve before posting to Chat" is a workflow (Schedule trigger, Gemini Agent step, Human-in-the-loop approval). An open-ended "ask me anything about our HR policies" helper is a chat agent.

5. Bringing Custom ADK, A2A & Dialogflow Agents

When no-code is not enough, developers build agents in code and register them so employees use them inside Gemini Enterprise.

Path	Hosting requirement	Status	Key setup
ADK agent	Must run on Agent Runtime	Available (verify launch stage per feature)	Register in console, API, or with a single Agents CLI command; needs Gemini Enterprise Admin role and Discovery Engine API
A2A agent	Any host exposing an A2A agent card (e.g., Cloud Run)	Preview	Paste the agent card JSON; A2A v0.3 streaming supported (v1.0+ via compatibility packages)
Agent Registry import	A2A agent already in Agent Registry	Available (verify launch stage)	Import a governed agent instead of re-registering by hand
Dialogflow agent	Dialogflow	Available (verify launch stage)	Surface an existing conversational agent
Marketplace agent	Partner-hosted A2A agent	Preview	Procure in Cloud Marketplace, admin integrates and sets visibility

ADK agent registration details

Connection is VPC-SC compliant; the Agent Runtime instance can be in a different project.
The agent receives the signed-in user's email.
Optional OAuth authorization resource so the agent can act on third-party systems as the user: create an OAuth client (Web application) with redirect URIs https://vertexaisearch.cloud.google.com/oauth-redirect and https://vertexaisearch.cloud.google.com/static/oauth/oauth.html, then supply clientId, clientSecret, authorizationUri and tokenUri in serverSideOauth2. The registration references the engine via adkAgentDefinition.provisionedReasoningEngine.

A2A agent registration details

On Cloud Run (*.run.app), grant roles/run.invoker to the Discovery Engine service agent; Gemini Enterprise then sends an OIDC token in X-Serverless-Authorization (not for custom domains, load balancers or gateways).
The end user's OAuth token travels in the Authorization header.
Agent card securitySchemes, API keys and custom headers are not used; if you front the agent with Apigee, validate the token there (VerifyJWT or a tokeninfo ServiceCallout).
Traffic to A2A agents registered this way does not go through Agent Gateway.
Each registration consumes the daily agent creation quota.

Exam trap — Console Model Armor does not cover custom agents

The Model Armor setting in the Gemini Enterprise console screens the assistant only. ADK, A2A and Marketplace agents must call Model Armor (or equivalent guardrails) inside the agent code.

6. Governance & Admin Controls

Control	Where	What it governs
End-user feature toggles	Gemini Enterprise admin console	"Enable Workflow Builder" and other features per app
Sharing settings	Admin console	Agent sharing, approval-free sharing, sharing with Groups
Agent states	Admin console	Private, Enabled, Suspended, Disabled per agent
Connector provisioning	Admin console	Which data sources and actions builders can use
Identity provider	Google Identity or Workforce Identity Federation	Who users are; ACL enforcement
Model Armor templates	Admin console + Model Armor	Prompt and response screening for the assistant
VPC Service Controls, CMEK, data residency	Google Cloud project	Exfiltration perimeter, key ownership, global/US/EU location
Agent identity, Agent Registry, Agent Gateway	Agent Platform	Per-agent identity (SPIFFE), catalog of governed agents, policy enforcement on agent traffic
IAM roles	Google Cloud IAM	Gemini Enterprise Admin for registration; least privilege for service agents

Model Armor for the assistant

Screens assistant prompts and responses; available in all editions at no extra cost, may add latency.
Recommended: two templates — a prompt template (prompt injection, jailbreak, sensitive data) and a response template (data leakage, harmful content, malicious URLs).
Uses INSPECT_AND_BLOCK; it blocks rather than de-identifies. A violation returns answer.state = SKIPPED with CUSTOMER_POLICY_VIOLATION.

Layered governance pattern

Data layer: ACL-aware connectors, full syncs for permission changes, data residency, CMEK.
Agent layer: admin-provisioned connectors only, human review for write actions, sharing approval, suspend or disable misbehaving agents.
Traffic layer: Model Armor (console for assistant, in-code for custom agents), Agent Gateway for agent traffic on the platform, OAuth on behalf of the user.
Network layer: VPC Service Controls around Gemini Enterprise, Agent Runtime and data sources.

Exam trap — "Suspend" vs "Disable"

Suspended agents stay visible in the gallery but cannot be used (good for a temporary freeze with transparency); Disabled agents are hidden entirely.

7. CX Agent Studio for Customer-Facing Agents

CX Agent Studio is the minimal-code builder in Gemini Enterprise for CX (console: ces.cloud.google.com). It is built on ADK and is the evolution of Dialogflow CX, adding asynchronous tool calls, low-latency bidirectional streaming voice, and versioning with rollback.

Agent application structure

An agent application is a tree: a root (steering) agent that routes to sub-agents.
Set the model globally or override it per sub-agent; design in English with automatic language detection for end users.
AI assistance: generate an agent from a description, Restructure instructions into XML tags (role, persona, primary_goal, constraints, taskflow, subtask, step, trigger, action, examples), Refine instructions, and hill-climb against test cases.

Instructions

Reference tools as {@TOOL: tool_name}, sub-agents as {@AGENT: agent_name}, and variables as {username}.
Global instructions are inherited by every agent — put brand tone and DOs/DON'Ts there.
Modular conditional components (if/elif/else by channel, modality or variable values) keep one agent valid for chat and voice.
Inline few-shot examples ([user], [model], tool_code, tool_outputs) teach format and tool use; use them sparingly — clear instructions first. The XML taskflow → step structure is the in-console equivalent of an explicit chain-of-thought procedure.

Tool type	Use it for
Data store / File search / Google Search	Grounded answers from enterprise content, uploaded files, or the web
OpenAPI / Integration Connector / MCP	Calling business APIs and enterprise systems
Salesforce, ServiceNow, Jira, Confluence, SharePoint	Prebuilt SaaS actions
Python code / Client function / Widget	Server-side logic, client-side actions, rich UI elements
Agent as a tool / A2A (preview)	Delegating to another agent while keeping the session
System tools (e.g., `end_session`) / Google Maps (preview)	Session control and handoff; location answers

Tool execution & callbacks

Tool names are snake_case. Synchronous tools should finish in under ~5 s; asynchronous tools (≈5–60 s) let the agent keep talking while the call completes.
Callbacks are Python hooks equivalent to ADK: before_agent / after_agent, before_model / after_model (returning an LlmResponse skips the model), before_tool / after_tool (returning a dict skips the tool). Use them for deterministic guardrails, canned responses, and redaction.
A2A tool delegation: the primary agent keeps the session; exchanges are text only; billing counts one session in the same project, otherwise two; roles include roles/ces.client, roles/run.invoker and roles/aiplatform.user, with Secret Manager for third-party credentials.

Evaluation test case	What it checks
Scenario	An AI-simulated user pursues a goal; tests open-ended robustness
Simulation	Ordered goals and milestones; tests multi-step conversations
Golden	An ideal path including tool calls; regression testing with semantic match (0–4)

Evaluation metrics

Tool correctness, user goal satisfaction, goal completion, hallucinations, semantic match (golden only), scenario expectations; personas vary the simulated user.
Task completion = user goal satisfied AND no hallucinations AND scenario expectations met.

8. Flows, State Handlers & Human Handoff

Dialogflow CX models conversations as explicit state machines. CX Agent Studio can call these flows when you need deterministic control.

Dialogflow CX concept	Meaning
Flow	A conversation topic (e.g., "Authenticate caller") made of pages
Page	A conversational state; can collect form parameters
State handler	Has requirements, an optional fulfillment (response, parameter preset, webhook) and an optional transition target
Route	Intent route or condition route that moves to another page or flow
Event handler	Reacts to events such as `sys.no-match-default`, `sys.no-input-default`, or a sub-flow ending with a request for a human (`flow-failed-human-escalation`, raised by the `END_FLOW_WITH_HUMAN_ESCALATION` target)
Handler scope	Flow-level, page-level, or form-parameter-level
Form parameters	Slots a page must fill before it completes

Page anatomy and form filling

One active page per active flow. A page bundles an entry fulfillment (messages or a webhook that run when the page becomes active), an optional form, and its routes and event handlers.
Form filling runs turn by turn: values already in session state pre-fill the form, the agent prompts only for missing parameters, and each parameter can carry its own reprompt handlers (sys.no-match-1, sys.no-input-1 and so on).
Leaving the page is usually a condition route on $page.params.status = "FINAL", true once every required parameter is filled.
Typed extraction: bind parameters to system entities (@sys.date, @sys.number) or custom entities so values are validated, not guessed.

Handler evaluation order

Scope filter: only handlers on the active flow, the active page, or the parameter being filled are considered.
Intent routes: page routes, then page route groups, then flow routes, then flow route groups, each in listed order.
Condition routes: page routes, then page route groups; flow routes and flow route groups only when the current page is the flow's start page.
Event handlers: parameter-level (reprompt) handlers, then page, then flow, when an event fires (no match, no input, webhook failure, flow outcome).

Stop rule: a called handler with a transition target ends evaluation; one without a target lets evaluation continue, so several fulfillments can queue messages in one turn.
Consumption: a matched intent or event is consumed by the first handler that uses it; a satisfied condition is not, so several condition routes can fire in the same turn.

Built-in event	Fires when	Design use
`sys.no-match-default`, `sys.no-match-1` to `-6`	Input matches no in-scope intent or does not satisfy the form parameter	Numbered handlers replace the default and run in order: rephrase, give an example, then escalate
`sys.no-input-default`, `sys.no-input-1` to `-6`	Empty text, no recognized speech, or a no-speech timeout	Voice reprompts and a graceful exit after repeated silence
`sys.invalid-parameter`	A webhook marks a form parameter `INVALID`	Server-side validation (for example an unknown account number)
`sys.long-utterance`	Input over 256 characters for non-generative intents or parameters	Ask for a shorter answer instead of treating it as no-match
`webhook.error` and variants (`webhook.error.timeout`, `webhook.error.bad-request`, `webhook.error.rejected`)	Timeout, error status, invalid response, or unavailable service	Fallback message or alternate path; fires only if the calling route has no transition target of its own
`flow-cancelled`, `flow-failed`, `flow-failed-human-escalation`	A sub-flow ended with cancellation, failure, or a request for a human	Handle the outcome on the calling page

Symbolic transition target	Effect
`START_PAGE`	Go to the start page of the active flow
`CURRENT_PAGE`	Re-enter the current page (useful to repeat a prompt)
`PREVIOUS_PAGE`	Return to the page that led here and restore its page state
`END_FLOW`	Pop the active flow and resume the calling page; handlers already evaluated there are skipped
`END_FLOW_WITH_CANCELLATION` / `END_FLOW_WITH_FAILURE` / `END_FLOW_WITH_HUMAN_ESCALATION`	Pop the flow and raise the matching `flow-*` event on the calling page
`END_SESSION`	Clear the session; the next input restarts at the start page of the Default Start Flow

Flow stack limit: 25

Each flow-to-flow transition pushes onto a stack capped at 25. Going deeper can cause flows to be popped from the stack, so END_FLOW returns somewhere unexpected; keep sub-flow chains shallow. With an empty stack, END_FLOW ends the session.

Sample flow: order capture

[Start page] ──intent: order.new──► [Order details page]  form: product, quantity
                                      │ sys.no-match-1 → rephrase prompt
                                      │ sys.no-match-2 → offer examples
                                      │ webhook.error  → "stock check unavailable" → [Fallback page]
                                      └─ condition: $page.params.status = "FINAL"
                                            ▼
                                     [Confirm page] ──intent: confirm.yes──► END_SESSION
                                            └─ intent: confirm.no ──► PREVIOUS_PAGE

Combining playbooks, generators and flows

Playbooks are the generative building block of Dialogflow CX agents: a goal, step instructions, examples (few-shot conversations) and parameters. Task playbooks are reusable subtasks that exchange input and output parameters; routine playbooks model sequential stages and can hand off to other routine playbooks or to flows.
References in playbook instructions: ${PLAYBOOK: name} routes to another playbook, ${TOOL: name} calls a tool, and ${FLOW: name} hands control to a deterministic flow.
Generators call an LLM from inside a fulfillment with a prompt template (placeholders such as $last-user-utterance or session parameters) for summarization, parameter extraction or rewriting, without a webhook.
Session parameters are the shared memory between the generative and deterministic halves: a routine playbook writes them and a flow reads them, or the reverse (task playbooks pass data through input and output parameters instead).
Playbook examples are sample conversations (user turns, tool calls with inputs and outputs, agent replies) that act as few-shot prompts. Give every playbook at least one and aim for four or more, covering happy paths plus edge cases such as a tool returning no data; example quality usually drives behavior more than instruction wording. For multilingual agents, write examples in each language.
Example Store (preview, Agent Platform) is the code-agent counterpart: a managed set of few-shot examples retrieved by similarity to the user query. An ADK agent linked to an instance pulls relevant examples into its requests automatically, and new examples take effect without redeploying, which makes it a way to correct observed misbehavior.

Pattern	Shape	Good fit
Generative front, deterministic back	A playbook handles open discovery, then `${FLOW: name}` runs payment or identity steps	Sales or support where the closing steps are regulated
Deterministic spine, generative pages	A flow drives the process; a generator or data store tool answers side questions on one page	Claims intake that also fields policy questions
Flow as subroutine	A CX Agent Studio root agent routes to a flow-based agent and gets output variables back	Reusing an existing Dialogflow CX authentication flow

Flow-based agents in CX Agent Studio

A flow-based agent hands the conversation to a Dialogflow CX flow until it ends (END_SESSION), using DetectIntent; input and output variables are mapped between the two.
The Customer Engagement Suite service agent needs the Dialogflow API Client role.
CX Agent Studio agents are not drop-in replacements for Dialogflow playbooks; use a CX Agent Studio agent as the steering and routing layer.
Use flows for deterministic data collection, validation and authentication. Do not use flows for canned responses (use a callback) or intent classification (let the LLM route). Treat flows as black boxes — session parameters behave like implicit globals.

Human handoff with end_session

Add the end_session system tool to the root agent and every sub-agent that may escalate.
Parameters (camelCase since August 1, 2026; old ALL_CAPS names remain supported): escalationMessage, telephonyTransferCall (phoneNumber, sipUri, useOriginatingTrunk), liveAgentHandoff (endSession, sipRefer, uuiHeaders, xHeaders).
With Agent Assist, keep liveAgentHandoff.endSession at its default False so the conversation transfers to the human agent with assist; set it to True only when not using Agent Assist. Agent Assist handoff works with the bidirectional API.
After a session ends, CX Agent Studio cannot reconnect to it.

JSON — end_session call — transfer to a billing agent with Agent Assist

{
  "escalationMessage": "Transferring your call to a billing agent",
  "telephonyTransferCall": { "phoneNumber": "+15552420836", "useOriginatingTrunk": true },
  "liveAgentHandoff": { "endSession": false }
}

Exam trap — Deterministic does not mean "all flows"

Use LLM agents for understanding and routing, flows or callbacks for steps that must never vary (identity verification, payment capture, legally required wording).

State-machine design mistakes

Mistake	What goes wrong	Fix
No no-match or no-input handlers	Users loop on the same prompt or the call goes silent	Add numbered `sys.no-match-` and `sys.no-input-` handlers at flow and parameter level, ending in escalation
Circular routes between flows and playbooks	Turns repeat until the user hangs up; deep chains overflow the 25-flow stack	Count retries in a session parameter and add a page-level condition route that exits after a limit; keep sub-flow nesting shallow
LLM-extracted values for strict fields	Missing or invented account numbers, dates and amounts	Use page forms with typed entities and webhook validation (`sys.invalid-parameter`)
Reference data pasted into instructions	Higher latency and token cost on every turn; stale facts	Move FAQs and policies to a data store tool and keep instructions about behavior
Webhook route that also sets a transition target	`webhook.error` never fires, so failures pass silently	Leave the target off routes whose webhook can fail, and handle the error event explicitly
Broad intents placed on flow-level routes	Flow intent routes stay in scope on every page, so a loosely trained intent can pull the user out of a half-filled form	Attach specialized intents to the pages or route groups where they apply; keep flow-level routes for true global exits such as "talk to a person"
No instruction for empty tool or data store results	The playbook fills the gap with invented answers	Instruct it to say it does not know or ask the user to rephrase when a tool returns nothing, and add an example showing that path
State-changing action with no confirmation	Orders, refunds or record updates run on a misheard or misread value	Add a confirmation page (read back the values, then a yes or no route) before the webhook; in Workflow Builder, put a Human-in-the-loop approval step before the write

9. Low-Code vs Pro-Code Decision Matrix

Criterion	Workflow Builder (Gemini Enterprise)	CX Agent Studio (Gemini Enterprise for CX)	Agent Studio (Agent Platform)	ADK on Agent Runtime
Audience	Employees	External customers	Developers prototyping	Developers and platform teams
Channels	Gemini Enterprise web app, @mentions	Web chat, apps, telephony / voice	Console playground, export to code	Any (API, Gemini Enterprise, CX, custom UI)
Coding	None	Minimal (optional Python callbacks and tools)	Low-code	Full code
Control flow	Chat agents or step-based workflows with conditions and approvals	Root agent + sub-agents, optional deterministic flows	Prompt and workflow design	Any pattern (sequential, parallel, loop, custom)
Grounding	Connectors, data stores, knowledge files	Data store, file search, Google Search tools	Google Search, Maps, RAG Engine, Agent Search	Agent Search, RAG Engine, MCP, custom tools
Evaluation	Execution logs, versions	Scenario, simulation and golden test cases	Side-by-side prompt comparison	Agent evaluation services and custom eval suites
Governance	Admin toggles, sharing approval, Model Armor	Versioning, rollback, callbacks, IAM	Project IAM	IAM, Agent Identity, Agent Gateway, in-code Model Armor

Decision rules

Employee productivity task with available connectors → Workflow Builder; escalate to ADK only when you need custom code, complex tools, or strict evals.
Customer-facing chat or voice with telephony, handoff and regression tests → CX Agent Studio.
Custom logic, multi-agent orchestration, or reuse across channels → ADK on Agent Runtime, then register in Gemini Enterprise (and/or call from CX Agent Studio via A2A or tools).
Partner or other-framework agent → expose it over A2A and register it.
Prototype prompts and system instructions → Agent Studio, then move to ADK for production.

10. Exam Traps & Architect Checklist

Exam trap — Name drift

Agent Designer = Workflow Builder; Agentspace = Gemini Enterprise; Vertex AI Search = Agent Search; Agent Engine = Agent Runtime. Treat old and new names as the same product.

Exam trap — Where Model Armor applies

Console Model Armor protects the Gemini Enterprise assistant only. Custom ADK/A2A agents need guardrails in code; CX Agent Studio uses callbacks and its own safety settings.

Exam trap — A2A registration bypasses Agent Gateway

If a scenario requires central gateway policy on every agent call, A2A agents registered directly in Gemini Enterprise do not satisfy it by default.

Exam trap — Write actions are all-or-nothing

Connector "Add Or Update Data" is a connector-level toggle with human review, and it needs the related search actions enabled.

Architect checklist

Edition supports the requirement (no Business edition for IAM, VPC-SC, CMEK, custom agents).
Data mode chosen deliberately: ingestion for quality, federation for no-copy; full syncs scheduled for deletions and ACL changes.
Identity provider configured (Google Identity or global Workforce Identity Federation pool) and ACLs verified.
Builder path chosen with the decision matrix; custom agents hosted on Agent Runtime (ADK) or exposing an agent card (A2A).
OAuth on behalf of the user configured for third-party actions; least-privilege roles for service agents.
Guardrails: Model Armor templates for the assistant, in-code guardrails for custom agents, callbacks and flows for deterministic CX steps.
Human-in-the-loop for write actions and approvals; end_session handoff wired on every CX agent that can escalate.
Evaluation: CX golden and scenario test cases, workflow execution logs and versions, agent evals for ADK.

11. Glossary, Sources & Practice Quiz

Gemini Enterprise

Google's employee-facing search, assistant and agent platform (formerly Agentspace).

Workflow Builder

No-code builder for chat agents and workflows in Gemini Enterprise (formerly Agent Designer).

Agent Gallery

Catalog of Google-made, organization, personal and Marketplace agents inside Gemini Enterprise.

Federated search

Live query to a third-party source without copying data.

Data ingestion

Copying and indexing source content and ACLs into a data store for higher quality.

Layout parser

Default document parser with content-aware chunking and image and table annotation.

Agent Runtime

Managed runtime for code agents (formerly Agent Engine; API resource ReasoningEngine).

A2A agent card

JSON description of an A2A agent's endpoint and skills used for registration.

Model Armor

Prompt and response screening service; console setting covers the assistant only.

CX Agent Studio

Minimal-code builder for customer-facing agents, built on ADK, evolution of Dialogflow CX.

Global instructions

CX Agent Studio instructions inherited by every agent in an application.

Golden test case

CX evaluation case describing the ideal path, including tool calls, for regression testing.

end_session

CX Agent Studio system tool for ending a session, transferring calls, and live-agent handoff.

Entry fulfillment

Messages or a webhook that run when a Dialogflow CX page becomes active.

Symbolic transition target

A reserved destination such as END_FLOW, PREVIOUS_PAGE or END_SESSION that moves the session without naming a specific page.

Flow stack

The stack of flows entered through flow-to-flow transitions, capped at 25, that END_FLOW pops to return to the caller.

Generator

An LLM call configured inside a Dialogflow CX fulfillment with a prompt template, used without a webhook.

Task playbook vs. Routine playbook

A task playbook is a reusable subtask with input and output parameters; a routine playbook is a sequential stage that can hand off to other routines or flows.

OCR parser

Gemini Enterprise parser for scanned or image-based PDFs; processes the first 500 pages and can merge embedded text with useNativeText.

Digital parser

Basic parser that extracts machine-readable text without detecting tables, lists or headings; fallback for file types the chosen parser does not support.

Layout-aware chunking

Chunking that keeps each chunk's text within one layout entity, with a 100 to 500 token size limit (default 500).

Ancestor headings

Optional setting (includeAncestorHeadings) that prepends the document title and headings to each chunk.

Playbook example

A sample conversation, including tool calls, used as a few-shot prompt for a Dialogflow CX playbook.

Example Store

Agent Platform service (preview) that stores few-shot examples and retrieves the relevant ones for an agent at request time.

Agent Retrieval

Agent Platform storage and vector search engine (formerly Vector Search 2.0) built on Collections of JSON Data Objects, with optional autogenerated embeddings.

gemini-embedding-2

GA multimodal embedding model that maps text, images, documents, audio and video into one 3,072-dimension space, with an 8,192-token input limit per call.

audio_timestamp

Generation config flag (audioTimestamp in REST) required for accurate timestamps on audio-only files.

Media data store

Agent Search structured data store with a media schema plus required user events, used for media search and recommendations; it does not analyze the media files themselves.

Sources

Gemini Enterprise docs: editions, agents overview, Workflow Builder (chat agents and workflows), Agent Gallery, Marketplace agents, connectors and data stores, parsing and chunking, identity provider, ADK and A2A agent registration, Model Armor, choosing a product, release notes — https://docs.cloud.google.com/gemini/enterprise/docs
CX Agent Studio docs: overview, agents, instructions, tools, A2A tool, callbacks, evaluation, flows — https://docs.cloud.google.com/gemini-enterprise-cx/cx-agent-studio
Agent Assist handoff from CX Agent Studio — https://docs.cloud.google.com/gemini-enterprise-cx/agent-assist/handoff-cxas
Dialogflow CX concepts (pages, state handlers) — https://docs.cloud.google.com/dialogflow/cx/docs/concept/handler
Dialogflow CX playbooks, generators and webhooks: playbooks, generators, webhooks
Gemini Enterprise Agent Platform overview — https://docs.cloud.google.com/gemini-enterprise-agent-platform/overview
Parsing and chunking: parse and chunk documents (Gemini Enterprise), Document AI layout parser
Dialogflow CX playbook examples and best practices; Example Store overview
Prepare data and data store types: Gemini Enterprise, Agent Search, create a data store; data source access control (acl_info)
Audio and video: audio understanding, video understanding, media documents, media user events
Agent Retrieval and embeddings: overview, autogenerated embeddings, Gemini Embedding 2, multimodal embedding limits

Related guides

Agent Development Kit (ADK) — code agents, callbacks, multi-agent patterns.
A2A Protocol — agent cards, tasks, and cross-framework federation.
Agent Platform — Agent Runtime, Agent Studio, Agent Search and the builder platform.
Agent Platform Security — Agent Identity, Agent Gateway, Model Armor, VPC-SC.
RAG and MCP — retrieval pipelines and tool protocols.

Audio Deep Dive & Study Downloads

Listen to the 60-minute Gemini Enterprise & Low-Code Agents audio deep dive, open the 21-slide architectural deck and sketchnote infographic in the Hub Viewer, or drill scenario questions on editions, grounding modes, Workflow Builder, custom agent registration, governance, and CX Agent Studio.

Gemini Enterprise & Low-Code Agents (Video Walkthrough)

Gemini Enterprise, Workflow Builder & CX Agent Studio (Podcast)

Open Slide Deck & Infographic in Hub Viewer Launch Gemini Enterprise Practice Quiz →

Self-Assessment Questions (Click to Reveal)

Q1. A 40-person startup on Business edition wants to register an ADK agent and put the project inside a VPC Service Controls perimeter. What must change?

Move to a Google Cloud–administered edition (Standard or Plus). Business edition has no Cloud console or IAM, no own full-code agents and no enterprise-grade security controls, so it cannot host registered ADK agents or VPC-SC.

Q2. When do you prefer federated search over data ingestion?

When data must not be copied or stored outside the source system and near-real-time access matters more than answer quality. Ingestion gives better quality but uses storage and sync time.

Q3. A team wants a weekly report that gathers Salesforce updates, drafts a summary, and waits for a manager's approval before emailing it. Which Workflow Builder artifact and steps fit?

A workflow with a Schedule trigger, a Gemini Agent step for the summary, a Human-in-the-loop approval step, and then the send step.

Q4. Why does the Gemini Enterprise console Model Armor setting not protect a registered ADK agent?

The console setting screens only the Gemini Enterprise assistant. ADK, A2A and Marketplace agents must invoke Model Armor (or other guardrails) inside their own code.

Q5. In CX Agent Studio, where do you put brand tone rules that every sub-agent must follow?

In global instructions, which every agent in the application inherits.

Q6. A CX Agent Studio agent escalates to a human agent who uses Agent Assist. How should liveAgentHandoff.endSession be set?

Leave it at the default False so the conversation transfers to the human agent with Agent Assist; set True only when not using Agent Assist.