Free Generative AI Leader (GCP-GAIL) Study Resources
Google Cloud Generative AI Leader — the business-leader certification for generative AI. 4 units, 20 topics, 67 learning objectives, grounded in Google's official documentation.
This map is built from Google's Generative AI Leader exam guide (retrieved 2026-10-06) and from this hive's own contents. Google publishes no exam code, no guide version and no passing score for this certification; "GCP-GAIL" is this hive's internal label, not Google's.
The exam, as Google publishes it
Format: 50-60 multiple choice questions
Time: 90 minutes
Validity: 3 years
Languages: English, Japanese, Spanish, Portuguese
Passing score: not published by Google
Sections and weights
Google attaches an approximate percentage to each section and to nothing below it. The counts are this hive's.
Section
Title
Weight (Google, approx.)
Topics
Objectives
Bank questions
Flashcards
Seats per mock
Unit 1
Fundamentals of gen AI
~30%
7
23
138
115
18
Unit 2
Google Cloud’s gen AI offerings
~35%
6
18
161
90
21
Unit 3
Techniques to improve gen AI model output
~20%
4
15
92
75
12
Unit 4
Business strategies for a successful gen AI solution
~15%
3
11
69
55
9
How this hive is organised
A lecture deck for every topic — 20 decks, one per topic of this hive's curriculum (each mapped to the exam guide's considerations), each teaching every objective under it. Every factual claim on a slide is pinned to an exact excerpt from an official Google Cloud page.
460 practice questions, each citing the Google Cloud documentation page its answer comes from, with the supporting quote recorded.
7 blueprint-weighted mock exams of 60 questions, dealt in proportion to the section weights (18/21/12/9 seats per section). No question appears in more than one mock.
335 flashcards, one collection per objective, each card traceable to Google's documentation.
A study guide per topic (below): the topic's lecture in reading form.
Names in the exam guide that Google has since changed
The exam guide still uses these names, so expect them on the exam. Google's current documentation uses the second column, and the decks teach both.
The exam guide says
Google's documentation now
Taught in
Cloud Functions
Cloud Run functions
Unit 2 Topic 6
Customer Engagement Suite
Gemini Enterprise for Customer Experience
Unit 2 Topic 4
Conversational Agents
built in CX Agent Studio
Unit 2 Topic 4
Conversational Insights
CX Insights
Unit 2 Topic 4
Agent Platform Feature Store
the feature-monitoring page still says Vertex AI Feature Store
Unit 3 Topic 2
Gems
Google Workspace Help says skills replace Gems in 2027
Unit 2 Topic 3
Imagen
still documented; its endpoints are listed as deprecated in favour of Gemini image models
Under each topic, Google's own considerations are quoted from Google's Generative AI Leader exam guide, retrieved 2026-10-06; the numbered objectives beneath them are this hive's learning objectives, written over those considerations. Each topic closes with its own summary of what the exam actually tests, taken from its lecture.
Topic 2 — Understand AI concepts and learning approaches
GAIL-U1.T2 · 4 objectives · lecture deck of 13 slides
The exam guide's considerations, quoted. Defining core gen AI concepts (e.g., artificial intelligence, natural language processing, machine learning, generative AI, foundation models, multimodal foundation models, diffusion models, prompt tuning, prompt engineering, large language models). Describing the machine learning approaches (e.g., supervised, unsupervised, reinforcement).
Distinguish artificial intelligence, machine learning, natural language processing and generative AI.
Distinguish foundation, large language, multimodal and diffusion models.
Distinguish prompt engineering from learned prompt tuning and model tuning.
Choose supervised, unsupervised or reinforcement learning for a stated learning problem.
What this topic actually tests.Which question does the label answer? field, method, material or output. What does the description prove? scale, language, modalities or method — not fit. What changed? the prompt, a learned prefix, or the parameters. What signal? labels, patterns or rewards.
Topic 3 — Follow the machine learning lifecycle
GAIL-U1.T3 · 2 objectives · lecture deck of 10 slides
The exam guide's considerations, quoted. Identifying the stages of the machine learning lifecycle; data ingestion, data preparation, model training, model deployment, and model management; and the Google Cloud tools for each stage.
Sequence ingestion, preparation, training, deployment and ongoing management.
Match lifecycle needs to relevant Google Cloud tools without confusing Model Garden and Model Registry.
What this topic actually tests.Order: ingest, prepare, train and evaluate, deploy, manage — and loop back on drift. Proof: each stage proves only its own step. Tools: Pub/Sub and Dataflow move and shape data; AutoML or custom training learn; Model Garden finds models; Model Registry manages yours; Model Monitoring watches.
Topic 1 — Choose a foundation model for a business use case
GAIL-U1.T1 · 3 objectives · lecture deck of 11 slides
The exam guide's considerations, quoted. Identifying how to choose the appropriate foundation model for a business use case (e.g., modality, context window, security, availability and reliability, cost, performance, fine-tuning, and customization).
Screen model candidates against required inputs, context and deployment constraints.
Choose workload-specific evaluation evidence before selecting a model.
Compare eligible candidates using measured quality, latency and workload cost.
What this topic actually tests.Can it do the job at all? modality, context, features, data controls, availability. Does it do our job well? evidence from our own prompts, scored broadly and read by people. Is it the cheapest that clears the bar? priced on our workload, with quality and latency as thresholds.
Topic 4 — Match generative AI to business work
GAIL-U1.T4 · 2 objectives · lecture deck of 10 slides
The exam guide's considerations, quoted. Identifying business use cases where gen AI can create, summarize, discover, and automate (e.g., text generation, image generation, code generation, video generation, data analysis, and personalized user experience). Describing how various data types are used in gen AI and the business implications.
Match create, summarize, discover and automate use cases to business outcomes and review needs.
Choose input and output data types for text, image, code, video, analysis and personalized experiences.
What this topic actually tests.Outcome: a measurable goal, decided before the technology. Job: create, summarize, discover or automate, with a review step. Data: the input and output types of each task, and whether a traditional prediction should feed a generative step.
Topic 5 — Judge whether data is fit for the task
GAIL-U1.T5 · 3 objectives · lecture deck of 10 slides
The exam guide's considerations, quoted. Explaining the characteristics and importance of data quality and data accessibility in AI (e.g., completeness, consistency, relevance, availability, cost, format). Identifying the differences between structured and unstructured data, and identifying real-world examples of each type. Identifying the differences between labeled and unlabeled data.
Evaluate completeness, consistency, relevance, availability, cost and format before using data.
Distinguish structured and unstructured data using business examples.
Distinguish labeled and unlabeled examples and their learning uses.
What this topic actually tests.Is it fit for this purpose? complete, consistent, recent, reachable, valid, affordable to label. Where does its meaning live? in columns, or inside files. Does it carry the answer? labeled to learn from, unlabeled to predict on.
Topic 6 — Locate decisions in the generative AI landscape
GAIL-U1.T6 · 5 objectives · lecture deck of 14 slides
The exam guide's considerations, quoted. Infrastructure Models Platforms Agents Applications
Explain the infrastructure layer and its compute, storage and networking responsibilities.
Distinguish reusable models from the applications that use them.
Explain how platforms support development, evaluation, deployment and operations.
Explain how agents combine model decisions with tools and bounded workflows.
Identify the user-facing application layer and its business workflow.
What this topic actually tests.Infrastructure runs everything. Models are reused across applications. Platforms build, deploy and govern. Agents act through tools within permissions. Applications change a workflow for real people.
Topic 7 — Choose among Google model families
GAIL-U1.T7 · 4 objectives · lecture deck of 12 slides
The exam guide's considerations, quoted. Gemini Gemma Imagen Veo
Recognize Gemini use cases and verify model-specific input and output capabilities.
Recognize Gemma open-weight use cases and the resulting deployment and license responsibilities.
Recognize Imagen image-generation and supported editing use cases.
Recognize Veo video-generation use cases and verify version-specific capabilities.
What this topic actually tests.Gemini for most text, code and multimodal work. Gemma when you must run or tune the model yourself — and run it. Imagen for its specialized image strengths, with Gemini as Google's starting point. Veo for video, within each version's documented limits.
Study Guide3,321 words
Unit 1.1 study guide — Choose a foundation model for a business use case
Study guide for Generative AI Leader, Unit 1 · Topic 1. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Identifying how to choose the appropriate foundation model for a business use case (e.g., modality, context window, security, availability and reliability, cost, performance, fine-tuning, and customization).
This hive's learning objectives for the topic:
Screen model candidates against required inputs, context and deployment constraints.
Choose workload-specific evaluation evidence before selecting a model.
Compare eligible candidates using measured quality, latency and workload cost.
Choosing a foundation model
Screen what must fit, measure what must work, compare what is left
Screen — modality, context, features, data controls and availability rule a candidate in or out. Evaluate — evidence from your own workload, not a leaderboard. Compare — the most affordable model that still meets your quality and latency bar.
This topic is one decision a generative AI leader is asked to make again and again: which foundation model should this business use case run on? Google's guidance starts from three properties — when you choose a model, consider the model's modality, size and cost — and ends with a rule worth memorising: choose the most affordable model that still meets your response quality and latency requirements. Between those two sentences sits a method, and this deck teaches it in three steps. First, screen. Some requirements are pass or fail: a model that cannot take the inputs your users send, or that your data policy cannot accept, is out however impressive it is. Second, evaluate. For the candidates that survive, gather evidence from your own workload, because a public leaderboard does not measure your task. Third, compare. Among the models that meet the quality and latency bar, the cheapest one for your actual workload wins. Keep those three verbs in order and most exam scenarios about model choice become easy to read.
Screen candidates before you score them
A model that cannot take your inputs is out, however good it is
Modality: the data categories a model is trained for, like text, images and video
Context window: how much a model can take in at one time
Features: not every model supports tuning or distillation
Data controls: what the service keeps, and what you must configure
Availability: endpoints and regions that keep the model reachable
Worked example (synthetic). An insurer wants claim photos in and a written damage summary out. A text-only model fails the first gate before anyone looks at its benchmark scores; it is not a weaker candidate, it is not a candidate.
The first objective is screening, and the point of screening is that some requirements are not trade-offs at all. Start with modality. Google defines the modality of a model as the high-level data categories it is trained for, like text, images and video, and adds that your use case and the model's modality are closely associated. If photos must go in, a model that cannot accept images is excluded. Needing several modalities is possible too, but Google warns that cost and latency might be higher. Next, the context window, which Google compares to short-term memory: how much the model can take in at one time. Historically, large language models, or LLMs, were significantly limited by the amount of text that could be passed in at once, so a task that needs a long contract in a single request screens on this. Then features. Google says not all models support features like tuning and distillation, and if those capabilities matter to you, you should check what each model supports. Then data controls. Google states that it won't use your data to train or fine-tune any AI or machine learning model without your prior permission or instruction — but retention is a configuration question, not a slogan, which the next slide shows. Finally availability: for global availability and resilience, Google recommends deploying models to endpoints in multiple regions or using the global endpoint. A candidate passes only when every gate the business actually requires is green.
Screening is a sequence of gates
Each gate removes candidates; only survivors are worth evaluating
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A left-to-right flowchart. A business requirement passes through four yes-or-no gates in turn: does the model take and return the modalities needed, does it fit the context the task needs, does it support required features such as tuning, and do its data controls and availability meet policy. A no at any gate leads to Out. Four yeses lead to Eligible: evaluate on your workload.
Worked example (synthetic). A legal team needs a whole contract in one request and tuning on its clause library. Two of five candidates fail the context gate and one fails the features gate, so only two go on to evaluation.
Drawn as a flow, screening is a series of gates, and the order matters less than the rule that any single no removes a candidate. The first gate is modality — your use case and the model's modality are closely associated, so the model must take in and return the kinds of data the use case involves. The second is context: the context window works like short-term memory, and a task that must hold a long document at once needs a model whose window fits it. The third is features: not all models support features like tuning and distillation, so if the plan depends on tuning, check what each model supports before you invest in evaluating it. The fourth gathers the policy checks — data controls and availability. Only the candidates that pass every gate are eligible, and that is where the next objective begins. Notice what is absent from the gates: no quality score and no price. Those are comparisons, and comparing a model that fails a hard requirement wastes the evaluation budget.
Data controls are configured, not assumed
Training use is restricted; retention depends on what you turn on
Question to ask
What Google documents
Will our data train Google's models?
Not without your prior permission or instruction
Can we reach zero data retention?
Only by taking specific actions; may not be possible with some Advanced AI features
Does grounding on Google Search keep logs?
Yes — no way to disable that storage
Will the model stay reachable?
Use endpoints in multiple regions or the global endpoint
Worked example (synthetic). A bank requires zero data retention for a customer chatbot. The team plans Grounding with Google Search, then learns that service stores logs with no off switch, so it plans a different grounding approach before going further.
Security and availability appear in the guide's list as considerations, and the trap is to treat them as properties of a model rather than of how a service is configured. Google states the training restriction plainly: it won't use your data to train or fine-tune any AI or machine learning model without your prior permission or instruction. Retention is different. Google's zero data retention page lists specific actions customers must take to reach zero data retention, and warns that it may not be possible when using some Advanced AI features. Some features retain data by design — for Grounding with Google Search, Google says there is no way to disable the storage of that information. So a requirement like zero data retention screens not only the model but the features you plan to use with it. Availability is a deployment choice as well: Google's reliability guidance says that for global availability and resilience you deploy models to endpoints across multiple regions or use the global endpoint. In an exam scenario, the candidate that silently assumes a data or availability guarantee is usually the wrong answer.
Gather evidence from your own workload
A public benchmark is not evidence about your task
Evaluate on your specific tasks and criteria, not leaderboards
Every method needs an evaluation dataset of prompts and ideal responses
Include diverse examples that match the task you are evaluating
Use a wide range of metrics in combination with human evaluation
Once live, sample production logs to see real-world use
Worked example (synthetic). A support team shortlists two models that both lead public charts. On 200 of its own past tickets, one answers refund questions far more accurately — the only result that predicts how the bot will do for these customers.
The second objective is about evidence. Once a candidate has passed the screen, the question becomes how well it does the actual job, and Google is direct about where that answer comes from: its evaluation service lets you see how a model performs on your specific tasks and against your unique criteria, providing insights which cannot be derived from public leaderboards and general benchmarks. Model evaluation, in Google's words, helps you assess how your prompts and customizations affect a model's performance. Every evaluation method needs the same raw material — an evaluation dataset, made of prompt and ground-truth pairs that you create, where ground truth means the ideal response. Build it with a diverse set of examples that align with the task you are evaluating, or the results will not mean much. Then measure broadly. Automated metrics are quick and scalable, but each method has weaknesses, and Google's remedy is to use a wide range of metrics in combination with human evaluations. Finally, evidence does not stop at launch: Google suggests sampling directly from production logs to evaluate real-world usage. The exam favours the answer that tests on representative business data over the one that trusts a general benchmark.
Four ways to score the responses
Pick the method from what you know about a good answer
Method
What it does
Reach for it when
Adaptive rubrics
Pass or fail tests generated for each prompt
Google's recommended default
Static rubrics
One fixed set of criteria for every prompt
The same criteria apply everywhere
Computation-based metrics
Deterministic scores such as ROUGE or BLEU
You have a ground truth answer
Custom functions
Your own scoring logic in Python
Requirements nothing else covers
Worked example (synthetic). A team scoring product-description rewrites has no single correct text, so a computation-based metric against one reference would mislead; rubrics that test each rewrite for the required facts fit better.
Google's evaluation service supports four common methods, and the choice follows from what you know about a good answer. Adaptive rubrics, which Google marks as recommended, generate a unique set of pass or fail rubrics for each individual prompt in your dataset — rubrics work like unit tests in software. Static rubrics apply a fixed set of scoring criteria across all prompts, which suits a workload where the same standard applies to every request. Computation-based metrics use deterministic algorithms when a ground truth is available, so they fit tasks with one right answer. And custom functions let you define your own evaluation logic in Python for specialized requirements. None of these is a leaderboard: each one scores responses to your prompts. The same tooling helps later too — Google lists model migrations as a use, comparing model versions to understand behavioural differences before you switch.
The evaluation workflow, end to end
Same dataset, same metrics, every candidate
Loading Diagram...
Figure 2 — Mermaid diagram
Figure: A left-to-right flowchart of five steps: an evaluation dataset of prompts and ideal responses, define metrics, generate responses from each candidate model, run the evaluation, and interpret the scores and individual responses. An arrow loops from interpret back to generate, labelled adjust prompts, then re-run.
Worked example (synthetic). Two eligible models answer the same 150 billing questions; both are scored by the same rubric, and reviewers read the twenty lowest-scoring answers from each before anyone looks at an average.
The workflow Google describes makes the comparison fair by holding everything constant except the model. You start from the evaluation dataset. You define evaluation metrics — choosing the metrics you want to use to measure model performance. You generate model responses, selecting one or more models to answer the same dataset. You run the evaluation job, which assesses each model's responses against the selected metrics. And you interpret the results, reviewing the aggregated scores and also the individual responses. That last instruction matters: an average can hide the handful of failures a business cannot accept, so read the worst answers as well as the summary. The loop back to generation is where prompt changes are tested, which is also why Google recommends starting with prompting to find the optimal prompt before reaching for heavier customization.
Compare only the candidates that passed
The most affordable model that still clears quality and latency wins
Larger models can answer better, at higher latency and cost
Metering differs: input and output tokens for some, node hours for others
Cost comes from your workload's volumes, not a rate card alone
Tuning can lower latency and cost by shortening prompts
Worked example (synthetic). Two models both clear a 90% acceptance bar and a two-second limit. The smaller one costs a third as much for the forecast volume, so it is chosen — even though the larger one scores higher.
The third objective is the comparison itself, and Google's rule sets its shape: choose the most affordable model that still meets your response quality and latency requirements. Notice that quality and latency are thresholds in that sentence, not scores to maximise. Size is the usual tension. In general, Google says, a larger model can learn more complex patterns, which can result in higher quality responses — but larger models in the same family can have higher latency and costs, so you may need to experiment and evaluate to find which size works best. Cost needs care because models can be metered and charged differently: some are charged by the number of input and output tokens, others by the node hours used while the model is deployed. So the honest comparison multiplies each candidate's prices by your own workload — how many requests, how long the prompts, how long the answers. Customization changes the arithmetic too: Google lists lower inference latency and cost, due to shorter prompts, among the benefits of tuning. And at deployment, if lower cost is a priority, you might be able to tolerate higher latency with lower-cost machines.
Thresholds first, then price
A higher score does not win if a cheaper model also clears the bar
Candidate
Accepted / 100
p95 latency
Monthly cost
Verdict
Alder
93
1.6 s
$1,200
Chosen — clears both bars, cheapest
Birch
97
1.9 s
$3,400
Clears both bars, costs more
Cedar
95
2.6 s
$900
Out — misses the 2 s latency limit
Dogwood
84
0.9 s
$500
Out — misses the 90 accepted bar
Worked example (synthetic). Invented figures for a retail assistant that must reach at least 90 accepted answers per 100 and a 95th-percentile latency of 2 seconds or less.
All the numbers on this slide are invented, so the reasoning is the point. The business set two bars before any model was tested: at least ninety accepted answers out of a hundred reviewed, and a ninety-fifth percentile response time of two seconds or less. Dogwood is the cheapest and fastest, but it misses the quality bar, so it is out. Cedar has a strong score and a low price, but it misses the latency limit, so it is out too. Two candidates remain. Birch has the highest score of all, and Alder costs about a third as much. Google's rule decides it — choose the most affordable model that still meets your response quality and latency requirements — so Alder is chosen. The extra four points Birch scores are real, but the business did not ask for them, and paying for them is a choice to justify separately. If the bars were wrong, change the bars; do not let the leaderboard instinct change them silently.
Price the workload, not the rate card
A cheaper input rate can still cost more for an output-heavy job
Figure. Two cards with invented prices. Model E charges 1 dollar per million input tokens and 8 per million output tokens; Model F charges 3 and 4. For 20 million input and 10 million output tokens each totals 100 dollars. A band beneath shows that doubling output to 20 million tokens makes E cost 180 dollars and F 140.
Worked example (synthetic). Invented rates only. A summariser that writes long reports is output-heavy; a classifier that reads long documents and returns one label is input-heavy. The same two rate cards rank differently for each.
Here is why cost has to be computed from the workload. Google notes that some models are charged based on the number of input and output tokens, and the input and output rates can differ. The two invented rate cards on this slide come to exactly one hundred dollars each for a job with twenty million input tokens and ten million output tokens. Now double the output — the same reports, but twice as long. Model E, with its cheap input and expensive output, rises to one hundred and eighty dollars; Model F only to one hundred and forty. Neither card is cheaper in general; each is cheaper for some shape of workload. And a model billed by node hours while it is deployed, which Google also describes, cannot be compared on tokens at all — you estimate how long it must run to serve your traffic. When you plan deployment, Google advises considering your anticipated traffic, latency requirements and budget together, which is exactly this comparison.
What this topic actually tests
Three questions, in this order
Can it do the job at all? modality, context, features, data controls, availability. Does it do our job well? evidence from our own prompts, scored broadly and read by people. Is it the cheapest that clears the bar? priced on our workload, with quality and latency as thresholds.
Close on three questions, asked in order. First, can it do the job at all? That is screening: the modality must match the use case, the context window must hold the task, required features such as tuning must be supported, and data controls and availability must meet policy — any no removes the candidate. Second, does it do our job well? That is evidence: an evaluation dataset of your own prompts and ideal responses, a wide range of metrics combined with human evaluation, never a public leaderboard standing in for your task. Third, is it the most affordable model that still clears the quality and latency bar? That is the comparison, priced on your workload's real volumes, because models are metered differently. The next topic in this unit turns to Google's own model families, which is where these three questions get concrete names.
Study guide for Generative AI Leader, Unit 1 · Topic 2. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Defining core gen AI concepts (e.g., artificial intelligence, natural language processing, machine learning, generative AI, foundation models, multimodal foundation models, diffusion models, prompt tuning, prompt engineering, large language models). Describing the machine learning approaches (e.g., supervised, unsupervised, reinforcement).
This hive's learning objectives for the topic:
Distinguish artificial intelligence, machine learning, natural language processing and generative AI.
Distinguish foundation, large language, multimodal and diffusion models.
Distinguish prompt engineering from learned prompt tuning and model tuning.
Choose supervised, unsupervised or reinforcement learning for a stated learning problem.
AI concepts and learning approaches
Name the field, the model, the adaptation and the learning signal
What kind of system? artificial intelligence, machine learning, natural language processing, generative AI. What kind of model? foundation, large language, multimodal, diffusion. How is it adapted? prompt engineering, prompt tuning, fine-tuning. How did it learn? supervised, unsupervised, reinforcement.
This topic is the vocabulary every later topic in the hive assumes, and the guide tests it as distinctions rather than definitions. Four questions organise it. First, what kind of system is this? Artificial intelligence, or AI, is the broad field; machine learning, or ML, is the method of training a model from data; natural language processing works on human language; and generative AI creates new content. Second, what kind of model is it? Foundation, large language, multimodal and diffusion models are descriptions of a model's scale, material and method, and one model can carry several of them. Third, how is its behaviour adapted? By writing better prompts, by learning a soft prompt, or by training the model further. Fourth, how did it learn in the first place? From labeled examples, from patterns in unlabeled data, or from rewards. Each question has its own slide and a figure, and the last slide pulls the four together.
Four labels that answer four different questions
Field, method, material and output are not rivals
AI: a non-human program or model that solves sophisticated tasks
ML: a sub-field of AI that trains a model from input data
NLP: processing what people say or type
Generative AI: does not just analyze data, it creates new content
Worked example (synthetic). A returns desk classifies each customer email into a queue and drafts a reply. Classifying the email is natural language processing done with machine learning; drafting the reply is generative AI. One system, three correct labels.
The first objective asks you to tell apart four terms that are often used as if they competed. Google's glossary defines artificial intelligence, or AI, as a non-human program or model that can solve sophisticated tasks, and adds that, formally, machine learning is a sub-field of artificial intelligence. Machine learning, or ML, is defined by its method: a program or system that trains a model from input data. Natural language processing, or NLP, is defined by its material — Google's glossary calls it the field of teaching computers to process what a user said or typed — and Google's NLP page notes that it uses machine learning to reveal the structure and meaning of text. Generative AI is defined by its output: Google describes it as a type of artificial intelligence that doesn't just analyze data; it creates new content. Because these answer different questions — what field, what method, what material, what output — one system can carry several labels at once. The exam rewards reading which question a scenario is actually asking.
Nested, not parallel
Machine learning sits inside AI; NLP and generative AI describe what it works on
Figure. Nested boxes. The outer box is artificial intelligence, a program or model that solves sophisticated tasks. Inside it is machine learning, which trains a model from input data. Inside machine learning sit two dashed boxes side by side: natural language processing, which works on what people say or type and uses machine learning, and generative AI, which creates new content from learned patterns.
Worked example (synthetic). A chatbot that writes answers to typed questions is all four at once: AI, built with machine learning, doing natural language processing, generating new text.
Drawn as boxes, the terms nest rather than compete. The outer box is artificial intelligence, or AI. Inside it is machine learning, or ML — Google's glossary says that formally, machine learning is a sub-field of artificial intelligence. The two dashed boxes inside describe what a machine-learned system works on and what it produces. Natural language processing, which Google's AI page says enables computers to understand, interpret and generate human language, uses machine learning to reveal the structure and meaning of text. Generative AI, in Google's words, learns the patterns and structures within vast amounts of data — text, images, code and more — and then uses that knowledge to produce entirely new, original content based on prompts. The dashed boxes overlap in practice: a model that reads a question and writes an answer is doing language processing and generation in one step. So when a question offers two labels that both apply, look for the one the stem's verb points at — understand, or create.
Generative AI against traditional AI
Classify and predict, or create and summarize
Approach
What it excels at
Typical output
Traditional AI
Learning from existing data to classify or predict
A category, a number, a forecast
Generative AI
Create summaries, uncover hidden correlations, generate new content
Text, images or videos in the style of its training data
Worked example (synthetic). Routing a support email to the billing queue needs a category — traditional AI. Drafting the reply needs new text — generative AI. A single product can use both.
Google draws the line between the two kinds of artificial intelligence, or AI, by what they produce. Traditional AI models, its guidance says, excel at learning from existing data to classify information or predict future outcomes based on historical patterns — the output is a category, a value or a forecast. Generative AI models expand these capabilities to create summaries, uncover complex hidden correlations, or generate new content — like text, images or videos — that reflect the style and patterns within the training data. That gives you a fast test for an exam scenario: if the business needs a label or a number, a traditional model may be the better fit; if it needs a draft, a summary or an image, it needs generation. And the two are not exclusive — the worked example routes an email with one and answers it with the other.
Four ways to describe a model
Scale, language, modalities and method are separate descriptions
Foundation model: very large, pre-trained on an enormous and diverse set
Large language model: a language model with a very high number of parameters
Multimodal model: inputs, outputs or both span more than one modality
Diffusion model: learns to reverse added noise to generate outputs
Worked example (synthetic). A team reads that a model is a large multimodal foundation model. That tells them it is broadly pre-trained and handles more than one kind of data — not which input and output pairs it supports for their task.
The second objective covers four model descriptions, and the trap is to treat them as four kinds of model when they are four kinds of statement. A foundation model, in Google's glossary, is a very large pre-trained model trained on an enormous and diverse training set, and one thing it can do is serve as a base model for additional fine-tuning or other customization. A large language model, or LLM, is at a minimum a language model having a very high number of parameters; Google's LLM page adds that it is trained on a massive amount of data and can be used to generate and translate text and perform other natural language processing tasks. A multimodal model is a model whose inputs, outputs, or both include more than one modality — images, videos and text, for example. A diffusion model is described by its method: it works by adding noise to data and then learning how to reverse the process iteratively to generate new, realistic outputs. One model can match several of these descriptions at once, which is why a description never replaces checking what the model actually accepts and returns.
How a diffusion model learns
Add noise, learn to remove it, then generate from noise
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A left-to-right flowchart: training data has noise added step by step to become noisy data; the model learns to reverse that process; applying the learned reverse process iteratively produces a new, realistic output.
Worked example (synthetic). A conceptual sequence only — it describes the mechanism, not any named Google image or video model.
The diffusion description is the one in the guide that names a method, so it helps to see the method. Google's definition, which appears in the glossary of its WeatherNext weather models, says a diffusion model works by adding noise to data and then learning how to reverse the process iteratively to generate new, realistic outputs. Read the flow left to right. During training, noise is added to real data step by step; the model learns how to undo that corruption. To generate, the learned reverse process is applied over and over until something new and realistic emerges. Treat this as a picture of the idea, not a claim about any particular product: the definition sits on a weather glossary, and this deck does not assert which Google image or video models use the technique.
What each description tells you, and what it does not
A label is a starting point; the task decides
Description
Tells you
Still check
Foundation model
Broadly pre-trained; a base for customization
Whether it suits your task
Large language model
Language-focused; very many parameters
Which languages and tasks
Multimodal model
More than one modality in, out or both
The exact input and output pairs
Diffusion model
Generates by reversing added noise
What it produces for your use
Worked example (synthetic). A support team needs photos in and written advice out. 'Multimodal' is promising, but only the model's own documentation can confirm photo-in, text-out.
Each description narrows the field without settling the choice. Foundation tells you a model is broadly pre-trained and can serve as a base for additional fine-tuning or other customization — not that it fits your task. Large language model tells you the material is language and the parameter count is very high — not which languages it handles well. Multimodal is the one most often over-read: the glossary's definition is that inputs, outputs or both include more than one modality, so a multimodal model may take images in and give only text out. Google's multimodal page gives an example of the direction mattering — Gemini can receive a photo of a plate of cookies and generate a written recipe, and vice versa — but a different model may support only one direction. Diffusion tells you how a model generates. In every row, the last column is the work: check the input and output pairs your use case actually needs.
Three ways to change what a model does
Edit the prompt, learn a prefix, or retrain the parameters
Prompt engineering: craft prompts that elicit the desired responses
Prompt tuning: learn a soft-prompt prefix while freezing the model
Fine-tuning: a second, task-specific training pass on a pre-trained model
Google recommends starting with prompting, then tuning only if required
Worked example (synthetic). A team rewrites its instructions and adds two examples to the prompt — prompt engineering. Nothing about the model has been trained, so nothing about it has changed.
The third objective is three ways of adapting a model, and the distinction is what actually changes. Prompt engineering, in Google's glossary, is the art of creating prompts that elicit the desired responses from a large language model; Google's longer page calls it the art and science of designing and optimizing prompts. The model itself is untouched — only the text sent to it changes. Prompt tuning is a parameter-efficient tuning mechanism that learns a prefix the system prepends to the actual prompt. That prefix is learned, not written: the glossary says the system learns the soft prompt by freezing all other model parameters and fine-tuning on a specific task. Fine-tuning is a second, task-specific training pass performed on a pre-trained model to refine its parameters for a specific use case. The order Google recommends follows the cost: start with prompting to find the optimal prompt, then move on to fine-tuning, if required, to further boost performance or fix recurrent errors.
What changes, and what stays fixed
Only one of the three leaves the model exactly as it was
Method
What changes
What stays fixed
Prompt engineering
The prompt you write
Every model parameter
Prompt tuning
A learned soft prompt prepended to the input
All other model parameters (frozen)
Parameter-efficient tuning
A relatively small subset of parameters
The rest of the parameters
Full fine-tuning
All parameters of the model
Nothing
Worked example (synthetic). A legal team's clause classifier keeps making the same mistake after weeks of prompt edits. Moving to tuning changes something the prompt never could: the learned values themselves.
The table sorts the methods by what they change. Prompt engineering changes only the text you send, so every model parameter stays exactly as it was. Prompt tuning changes a learned soft prompt that is prepended to the input, while the system freezes all other model parameters. Fine-tuning comes in two strengths on Google's tuning page: parameter-efficient tuning updates a relatively small subset of the model's parameters during the tuning process, and full fine-tuning updates all parameters of the model, which suits highly complex tasks with the potential of higher quality — at higher cost. Notice that prompt tuning appears in Google's glossary as a parameter-efficient mechanism, so it sits at the light end of the tuning family. The exam's usual distinction is the first row against the rest: writing a better prompt is not training, and a team that has only edited its prompt has not tuned anything.
Prompting first, tuning if required
Escalate only when the evidence says the prompt is not enough
Loading Diagram...
Figure 2 — Mermaid diagram
Figure: A left-to-right flowchart. Design and refine the prompt, then ask whether it meets the bar on your evaluation. If yes, ship the prompt. If no, tune the model with parameter-efficient or full fine-tuning, then evaluate again.
Worked example (synthetic). A support bot's tone is fixed by adding a role and two examples to the prompt, so no tuning is needed; a second bot still mislabels product codes after prompt changes, so it moves to tuning.
Google's tuning guidance gives an order of operations, and the flowchart draws it. We recommend starting with prompting to find the optimal prompt, the page says; then move on to fine-tuning, if required, to further boost performance or fix recurrent errors. The decision in the middle is an evaluation, not a feeling: if the prompted model meets the bar on your own examples, the cheaper option has already succeeded. If it does not, tuning is the next step, and the lighter, parameter-efficient form updates only a relatively small subset of the model's parameters. Whatever was changed, it goes back through the same evaluation. In scenarios, the wrong answers usually jump straight to retraining before anyone has tried a better prompt, or claim a prompt edit has tuned the model.
Three learning signals
Labels, patterns or rewards — read what the data provides
Supervised: features with their corresponding labels
Unsupervised: patterns in a typically unlabeled dataset
Reinforcement: an agent maximizes return through interaction
The available data and feedback decide the approach
Worked example (synthetic). A bank has two years of transactions each marked fraud or not fraud. Those marks are labels, so predicting fraud on new transactions is a supervised problem.
The fourth objective asks you to choose a learning approach for a stated problem, and the reliable way is to ask what signal the data provides. Supervised machine learning, in Google's glossary, is training a model from features and their corresponding labels — Google's comparison page puts it simply: supervised learning requires labeled datasets. Unsupervised machine learning is training a model to find patterns in a dataset, typically an unlabeled one; it is more helpful for discovering new patterns and relationships in raw, unlabeled data. Reinforcement learning, or RL, is a family of algorithms that learn an optimal policy whose goal is to maximize return when interacting with an environment. Google's RL page describes an agent that, rather than relying on explicit programming or labeled datasets, learns by trial and error, receiving rewards or penalties for its actions. So: known answers mean supervised, no answers and a search for structure mean unsupervised, and actions with feedback mean reinforcement.
Signal, then typical tasks
Match the problem to what the training data looks like
Approach
Learning signal
Typical tasks Google lists
Supervised
Labeled examples
Classification and regression: spam detection, sentiment, pricing changes
Learning a policy by interacting with an environment
Worked example (synthetic). A retailer wants customer groups nobody has defined yet — unsupervised clustering. A warehouse robot learning which picking routes finish fastest from trial runs — reinforcement learning.
Google's pages attach typical tasks to each approach, which turns the definitions into a lookup. Supervised machine learning is suited for classification and regression tasks — Google lists weather forecasting, pricing changes, sentiment analysis and spam detection — because each needs examples with known answers. Unsupervised learning is more commonly used for exploratory data analysis and clustering tasks, such as anomaly detection, big data visualization or customer segmentation, where the groups are what you want to discover. Reinforcement learning, or RL, fits problems where an agent acts, receives rewards or penalties, and improves its policy through interaction with an environment. When a scenario is ambiguous, go back to the signal column: if nobody has labeled the data, a supervised model has nothing to learn from, however well the task sounds like classification.
What this topic actually tests
Four distinctions, in Google's words
Which question does the label answer? field, method, material or output. What does the description prove? scale, language, modalities or method — not fit. What changed? the prompt, a learned prefix, or the parameters. What signal? labels, patterns or rewards.
Close on the four distinctions. First, the labels artificial intelligence, machine learning, natural language processing and generative AI answer different questions — field, method, material, output — so several can be true of one system, and generative AI is the one that creates new content. Second, model descriptions narrow the field without settling fit: a foundation model is a broadly pre-trained base, a large language model is a language model with very many parameters, a multimodal model has more than one modality in its inputs, outputs or both, and a diffusion model generates by learning to reverse added noise. Third, adapting a model means changing the prompt, learning a soft prompt with the model frozen, or retraining parameters — and Google says to start with prompting. Fourth, supervised learning needs labels, unsupervised learning finds patterns in unlabeled data, and reinforcement learning learns from rewards. The next topic follows a model through its lifecycle, using this vocabulary at every stage.
Study guide for Generative AI Leader, Unit 1 · Topic 3. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Identifying the stages of the machine learning lifecycle; data ingestion, data preparation, model training, model deployment, and model management; and the Google Cloud tools for each stage.
This hive's learning objectives for the topic:
Sequence ingestion, preparation, training, deployment and ongoing management.
Match lifecycle needs to relevant Google Cloud tools without confusing Model Garden and Model Registry.
The machine learning lifecycle
Five stages, each with its own question and its own Google Cloud tools
Ingest — bring the data in. Prepare — make it fit to learn from. Train — learn a model, then evaluate it. Deploy — serve a chosen version. Manage — monitor, version and retrain. The stages loop: what monitoring finds sends work back to the data.
This topic follows a model from raw data to production and back again. Google calls the discipline machine learning operations, or MLOps, and defines it as the process of managing the machine learning, or ML, life cycle, from development to deployment and monitoring. The guide names five stages — data ingestion, data preparation, model training, model deployment and model management — and asks for the Google Cloud tools that serve each one. The first objective is the order of the stages and what each one is for; the second is matching a need to the right tool, with one pair the guide singles out because candidates mix them up: Model Garden, where you find models, and Model Registry, where you manage your own. Keep one idea in view throughout: the lifecycle is a loop, not a line, because what you learn from monitoring a deployed model sends work back to the start.
Five stages, in order
Each stage answers a question the next one depends on
Ingest: load and distribute the data the model will learn from
Prepare: clean, transform and format the raw data for training
Train and evaluate: learn a model, then check it on the task
Deploy: serve a chosen version to the applications that call it
Manage: monitor for drift, version models, retrain when needed
Worked example (synthetic). A parcel firm streams scanner events, removes duplicates and mislabeled scans, trains a delay model, deploys the approved version, then watches for drift when a new depot opens.
The first objective is sequence. Ingestion comes first because nothing can be learned from data the system has not received; Google's Pub/Sub, for example, is used for streaming analytics and data integration pipelines to load and distribute data. Preparation follows, and Google defines it as cleaning, transforming and formatting the raw data to make it suitable for model training — the step that decides whether training learns the task or the noise. Training learns a model from the prepared data, and evaluation checks it; Google's own machine learning operations, or MLOps, workflow lists model training, then model evaluation and iteration, as consecutive steps. Deployment makes a chosen model available: for online inference, Google says you must first deploy the model resource to an endpoint. Management is everything after: monitoring for drift, keeping versions organised, and deciding when to retrain. Each stage produces something the next one needs, which is why skipping one — training on unprepared data, deploying an unevaluated model — shows up later as a failure somewhere else.
The lifecycle is a loop
Monitoring sends work back to the data, not just to the model
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A left-to-right flowchart of five stages: ingest the data, prepare the data, train and evaluate, deploy a chosen version, and monitor and manage. An arrow labelled drift or decay detected loops from monitor and manage back to ingest the data.
Worked example (synthetic). A demand model trained before a store opened weekend hours starts under-forecasting Saturdays. Monitoring flags the drift, and the fix starts with new data, not a new model.
Drawn as a flow, the five stages close into a loop. The arrow back from management is what Google's monitoring guidance is about: as with conventional monitoring in machine learning operations, or MLOps, you must deploy an alerting process to notify application owners when drift, skew or performance decay is detected. Drift has a precise meaning here. Google's Model Monitoring page explains that the factors that predicted an outcome when the model was trained may stop being relevant as behaviour changes, and that this deviation in the data is known as drift. When drift is detected, the right response usually begins at the left of the diagram — new or newly prepared data, then retraining and re-evaluation — rather than at the model alone. That is why the guide treats management as a stage of the lifecycle and not as an afterthought to deployment.
Each stage proves something different
A clean dataset is not a good model; a good score is not a deployment
Stage
What it establishes
What it does not prove
Prepare
Data is suitable for training
That a model will perform well
Train and evaluate
A model meets the task on test data
That a version is serving users
Deploy
A version is reachable at an endpoint
That it stays accurate as data changes
Manage
Drift and decay are detected and acted on
Nothing on its own — it triggers the loop
Worked example (synthetic). A handover note says 'model trained, 94% accuracy'. It proves the training stage, but not which version is deployed, where, or who watches it — so the handover is incomplete.
A useful way to hold the sequence is to ask what each stage proves and what it leaves open. Preparation makes data suitable for model training, but a clean dataset says nothing yet about how well a model will do. Training and evaluation show that a model meets the task on the evaluation data — Google's workflow has model evaluation and iteration as its own step — but a score is not a service. Deployment makes a version reachable: Google says that before sending a request for an online inference you must first deploy the model resource to an endpoint. And management is where you find out whether that version stays good, because Model Monitoring can track and alert you when deviations exceed a specified threshold. Exam scenarios often hand you evidence from one stage and ask about another — the trap answer treats a training score as proof of production readiness.
The same loop, for a generative AI application
Discovery replaces training from scratch; monitoring still closes the loop
Phase
What happens
Discovery
Identify which foundation model suits the use case
Development and experimentation
Prompt engineering, then tuning if needed
Deployment
Manage prompt templates, chains, data stores and adapters
Continuous monitoring
Improve performance and maintain safety in production
Worked example (synthetic). A team building a support assistant spends its 'training' stage choosing and prompting a foundation model, then deploys prompts and a retrieval store alongside it.
For a generative AI application the stages keep their order but change their content, and Google's architecture guide lists the phases. Discovery: developers and engineers identify which foundation model is most suitable for their use case. Development and experimentation: developers use prompt engineering to create and refine input prompts, with tuning methods available when needed. Deployment: developers must manage many artifacts, including prompt templates, chain definitions, retrieval data stores and fine-tuned model adapters. And continuous monitoring in production, where administrators improve performance and maintain safety standards. Map it onto the five stages and it fits: discovery and prompting take the place of training from scratch, the deployed thing is more than one model file, and monitoring still sends work back to the start.
Google Cloud tools for each stage
Match the need to the tool, not the tool to a guess
Ingest and prepare: Pub/Sub, Dataflow, BigQuery, Cloud Storage
Find a model to start from: Model Garden
Train your own: AutoML code-free, or custom training code
Manage versions and deploy: Model Registry and endpoints
Watch and automate: Model Monitoring and Agent Platform Pipelines
Worked example (synthetic). A retailer streams till events with Pub/Sub, cleans them in Dataflow into BigQuery, trains with AutoML, registers each version in Model Registry, and alerts on drift with Model Monitoring.
The second objective attaches Google Cloud tools to the stages. For ingestion and preparation, Pub/Sub loads and distributes streaming data; Dataflow provides unified stream and batch data processing at scale, reading from sources, transforming the data and writing it to a destination; BigQuery supports continuous data ingestion and analysis; and Cloud Storage stores data as objects in containers called buckets. For a starting model, Model Garden is an AI and machine learning, or ML, model library that helps you discover, test, customize and deploy models from Google and its partners. To train your own, AutoML lets you build a code-free ML model from the training data you provide, and if AutoML doesn't address your needs, you can run your own training code on managed infrastructure. Model Registry is a central repository where you manage the lifecycle of your models, and from it you can assign a version to an endpoint. Finally, Model Monitoring tracks and alerts on drift, and Agent Platform Pipelines lets you automate, monitor and govern ML systems by orchestrating the workflow.
Ingestion and preparation, as a pipeline
Data streams in, is transformed, lands, and only then trains a model
Figure. A Google Cloud project. Apps and devices send events to Pub/Sub, which streams them to Dataflow. Dataflow transforms the data and writes it to a group labelled prepared data, holding BigQuery and Cloud Storage. Both feed Agent Platform training. A callout reads: ingest, prepare and land the data before any model is trained.
Worked example (synthetic). A fleet company's vehicles send telemetry events; Dataflow drops malformed readings and writes clean rows to BigQuery and raw files to Cloud Storage before a maintenance model is trained.
Here are the first stages as a pipeline. On the left, apps and devices produce events. Pub/Sub receives them — Google says it is used for streaming analytics and data integration pipelines to load and distribute data. Dataflow is the preparation step in the middle: it creates data pipelines that read from one or more sources, transform the data, and write the data to a destination, for batch and streaming alike. The prepared data lands in two places shown in the group: BigQuery, whose streaming supports continuous data ingestion and analysis, and Cloud Storage, which stores data as objects in buckets. Only then does Agent Platform training learn from it. The callout is the point of the picture — ingestion and preparation happen before training, and a model trained straight from raw events learns their duplicates and errors along with their patterns.
Model Garden against Model Registry
One is where you find models; the other is where you manage yours
Question
Model Garden
Model Registry
What is it?
A model library from Google and partners
A central repository for your models
When do you use it?
Before you have a model: discover and test
After you have models: organize and track versions
Leads to
Customizing or deploying a chosen model
Assigning a version to an endpoint
Worked example (synthetic). Team A has no model yet and wants to compare candidates — Model Garden. Team B has twelve trained versions and must know which one serves production — Model Registry.
The guide names one pair explicitly, because the two names sound alike and do different jobs. Model Garden is an AI and machine learning, or ML, model library that helps you discover, test, customize and deploy models and assets from Google and Google partners — it is where you look before you have chosen a model. Model Registry is a central repository where you can manage the lifecycle of your ML models: from it you have an overview of your models so you can better organize, track and train new versions, and when you have a version you would like to deploy, you can assign it to an endpoint directly from the registry. So the deciding question in a scenario is whether the team is looking for a model or keeping track of its own. A team asking which version is in production needs the registry; a team asking which model to start from needs the garden.
From a trained model to a watched service
Train, register, deploy, monitor — and automate the chain
Need
Tool
In Google's words
Train without writing code
AutoML
A code-free model from your data
Train with your own code
Custom training
Your code on managed infrastructure
Serve online requests
Endpoint
Deploy the model before sending requests
Catch changing data
Model Monitoring
Alerts when deviations exceed a threshold
Repeat the whole chain
Agent Platform Pipelines
Orchestrate ML workflows
Worked example (synthetic). A credit team with tabular data and no ML engineers starts with AutoML; a research team with its own model architecture uses custom training. Both deploy to an endpoint and monitor for drift.
The model side of the lifecycle has its own set of tools, each answering a different need. To train without code, AutoML lets you build a code-free machine learning, or ML, model based on the training data you provide; if AutoML doesn't address your needs, you can provide your own training code and run it on Agent Platform's managed infrastructure. To serve online requests, Google is precise about order: online inferences are synchronous requests to a model deployed to an endpoint, so you must first deploy the model resource to an endpoint. To catch a changing world, Model Monitoring can track and alert you when deviations exceed a specified threshold. And to run the whole chain again without doing it by hand, Agent Platform Pipelines lets you automate, monitor and govern ML systems by using pipelines to orchestrate your ML workflows. In a scenario, read the need in the first column and the tool follows.
What this topic actually tests
Order the stages, then match the need to the tool
Order: ingest, prepare, train and evaluate, deploy, manage — and loop back on drift. Proof: each stage proves only its own step. Tools: Pub/Sub and Dataflow move and shape data; AutoML or custom training learn; Model Garden finds models; Model Registry manages yours; Model Monitoring watches.
Close on what the exam asks. First, order: ingestion, preparation, training with evaluation, deployment, and management, with monitoring that sends work back to the data when drift is detected. Second, proof: a prepared dataset, a training score and a deployed endpoint each establish one stage, and evidence from one is not evidence for the next. Third, tools: Pub/Sub loads and distributes data, Dataflow transforms it, BigQuery and Cloud Storage hold it; AutoML trains without code and custom training runs your own; Model Garden is where you discover models, Model Registry is where you manage the lifecycle of your own versions; an endpoint serves them; and Model Monitoring alerts when deviations exceed a threshold. The next topic, choosing a foundation model, zooms into the discovery step this lifecycle starts from.
Study guide for Generative AI Leader, Unit 1 · Topic 4. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Identifying business use cases where gen AI can create, summarize, discover, and automate (e.g., text generation, image generation, code generation, video generation, data analysis, and personalized user experience). Describing how various data types are used in gen AI and the business implications.
This hive's learning objectives for the topic:
Match create, summarize, discover and automate use cases to business outcomes and review needs.
Choose input and output data types for text, image, code, video, analysis and personalized experiences.
Matching generative AI to business work
Start from the outcome, name the job, then specify what goes in and out
The job — create, summarize, discover or automate, each tied to a measurable outcome and a review step. The data — which types go in and which come out: text, image, code, video, analysis, personalization.
This topic turns the vocabulary of the unit into business decisions. Google's guidance starts in one place: to create successful generative or traditional artificial intelligence, or AI, solutions, begin by clearly identifying the specific measurable business goals or needs that you want to address. The first objective builds on that. The guide groups the work generative AI does into four jobs — create, summarize, discover and automate — and each job has to connect to an outcome the business can measure and to the review a person still needs to do. The second objective is the data: for every task, which types of information go in and which come out, because that is what decides whether a candidate model can do the job at all. Two questions, asked in that order, and the deck closes by combining them.
Four jobs, each tied to an outcome
Name the job, the business outcome, and who checks the output
Create: generate and recommend content
Summarize: condense documents, feedback and reports for decisions
Discover: conversational search and insights across documents and data
Automate: scale workflows for repetitive tasks
Decide whether humans stay in the loop at critical steps
Worked example (synthetic). A membership office drafts renewal letters (create), condenses board minutes (summarize), lets staff ask questions of its policy library (discover) and pre-fills routine forms (automate) — and measures staff hours saved for each.
The guide groups generative artificial intelligence, or AI, work into four jobs, and Google's own list of what these solutions excel at maps onto them. Create: Google's list opens with creating and recommending content, and adds generating code. Summarize: summarizing text content, including documents, articles, customer feedback and reports, to help with more informed data-driven decisions. Discover: powering conversational search and chatbots, and using associative reasoning to find insights and relationships within documents and data. Automate: scaling and automating workflow for repetitive tasks. A job alone is not a use case, though. Google asks you to decide whether the business expectation requires generative AI, another type of AI, or no AI at all, and to clarify how the business plans to measure success. And automation carries a review question: if you automate workflows with generative AI, Google says, assess whether humans should be included in the loop for critical decision stages.
Job, example, outcome, review
Every row needs a measure and a check, not just a capability
Job
Google's example
Outcome to measure
Review step
Create
Content and recommendations
Time to first draft
Editor approves before sending
Summarize
Documents, feedback, reports
Decision time saved
Spot-check against the source
Discover
Conversational search over knowledge bases
Answers found without escalation
Cite the source passage
Automate
Repetitive workflow steps
Tickets resolved without a person
Human in the loop at critical steps
Worked example (synthetic). The outcome and review columns are house examples; the job and Google's example columns come from Google's task list.
The table puts each job beside an example from Google's list, an outcome a business could measure, and a review step. Create covers creating and recommending content; a sensible measure is time to a usable first draft, and an editor still approves what goes out. Summarize covers documents, articles, customer feedback and reports, which Google ties to more informed data-driven decisions; the review is a spot-check against the source. Discover covers enabling conversational search through large knowledge bases with natural language queries; the measure might be questions answered without escalation. Automate covers repetitive workflow; Google's own example measures include the percentage of tickets resolved without human intervention — and Google pairs automation with deciding where human review is still needed. The last two columns are house examples, not Google's numbers; the point they make is Google's — every use case needs a way to measure success.
Work backward from the outcome
Goal and measures first; the type of AI is a decision, not a default
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A left-to-right flowchart: start from a measurable business goal and success criteria; decide whether it needs generative AI, other AI or no AI; identify end users and how they will interact; identify process and workflow changes; then measure against the criteria.
Worked example (synthetic). A support team's goal is to cut time-to-resolution by a fifth. Only after naming that measure does it decide a generative chatbot fits, then plans the ticket workflow around it.
Google's use-case guidance reads as a sequence, and the flowchart follows it. Begin by clearly identifying the specific measurable business goals or needs, and clarify how the business plans to measure success — Google names return on investment, or ROI, as one of the key measures of AI project success. Then decide whether the business expectation requires generative artificial intelligence, other types of AI, or whether it doesn't require AI at all; that question sits second, after the goal, so the technology never chooses itself. Next, identify the end users and how they might interact with the application. Then identify the changes the business has to make to existing processes or workflows. Only then is there something to measure against. In an exam scenario, the weak answer starts from a model's capabilities; the strong one starts from the outcome.
What a measurable outcome looks like
Google's support-chatbot example measures outcomes, not output volume
Goal
A measure Google lists
Efficiency
Share of tickets resolved without human intervention
Customer experience
CSAT score increase in surveys tied to the chatbot
Overall value
Return on investment
Worked example (synthetic). A team proposes 'number of replies generated per day' as its success metric. It counts output, not outcome; resolution rate and satisfaction say whether the replies helped.
Google's worked example is a customer support chatbot, and its success criteria show what a measurable outcome looks like. For efficiency, one measure is the percentage of tickets resolved without human intervention. For the customer experience, an increase in customer satisfaction, or CSAT, scores in surveys tied to chatbot usage. And above both, return on investment, or ROI, which Google calls one of the key measures of artificial intelligence, or AI, project success. Notice what is missing from the list: a count of generated replies, words or images. Volume of output is easy to measure and says nothing about whether the business goal moved. An exam option that proposes measuring how much a model produced, rather than what changed for customers or staff, is usually the distractor.
Specify what goes in and what comes out
A task is a direction: input types to output types
Text to image, text to video: creative multimedia from prompts
Video to text: automatic captions and subtitles
Text, images, video and audio to text: multi-source summaries
Natural language to code: functions, commands and scripts
Behavior and preferences to recommendations: personalization
Worked example (synthetic). A museum wants photos of new exhibits turned into short written captions. The requirement is image in, text out — a text-to-image model is the wrong direction, however good its pictures are.
The second objective is data types, and Google ties them directly to model choice: typically, your use case and the model's modality are closely associated — if your use case involves text-to-image generation, you need a model trained on text and image data. So write each task as a direction. Google's examples cover every type the guide lists. Creating new images from text prompt descriptions, and generating short videos or animations from text prompts or scripts. Automatic captioning or subtitling of videos — video in, text out. Creating summaries of information from multiple sources that can include text, images, and video or audio components. Creating code, functions, command-line commands and scripts from natural language prompts. And analysis feeding personalization: analyzing user behavior, preferences, reviews and past interactions to provide personalized content recommendations. Google adds that generative artificial intelligence, or AI, covers use cases that require processing and inputting information from multiple modalities like text, images, videos or audio.
Task, input, output
Write the direction before you shortlist a model
Task (Google's example)
In
Out
Images from text prompt descriptions
Text
Image
Short videos from prompts or scripts
Text
Video
Captioning or subtitling videos
Video
Text
Code and scripts from natural language
Text
Code
Summaries of mixed sources
Text, image, video, audio
Text
Worked example (synthetic). Two requests that sound alike — 'make a product video' and 'describe this product video' — are opposite directions: text to video, and video to text.
The table writes Google's examples as directions, because the direction is what screens a model. Creating new images from text prompt descriptions is text in, image out. Generating short videos or animations from text prompts or scripts is text in, video out. Automatic captioning or subtitling of videos runs the other way, video in, text out. Creating code, functions and scripts from natural language prompts is text in, code out. And creating summaries of information from multiple sources that can include text, images, and video or audio components has several types going in and text coming out. The worked example shows why this matters: two requests can share every noun and still need opposite capabilities. Once each task has its direction, the screening question from the model-choice topic — does this candidate accept these inputs and produce these outputs — has a precise answer.
Analysis and personalization, chained
A prediction becomes part of a prompt
Loading Diagram...
Figure 2 — Mermaid diagram
Figure: Two left-to-right chains. In the first, historical structured customer data feeds a traditional AI model that predicts churn probability; that prediction is included in a prompt to a generative chatbot that lets staff explore it in plain language. In the second, behavior and preferences feed personalized recommendations.
Worked example (synthetic). A sales team asks a chatbot 'which of my accounts are most at risk this month, and why?' — the risk scores come from a predictive model, the plain-language answer from a generative one.
Analysis and personalization are the two data jobs in the guide that are not simply generation, and Google shows how they combine with it. Traditional predictive artificial intelligence is particularly effective with structured data, and Google's example has it analyze historical data to forecast customer churn probability. Then the chain: you can use output from a traditional AI model as part of the prompt for a generative AI model, and Google describes integrating that churn analysis with a generative AI-powered chatbot, which lets a sales team explore the predictions in natural language conversations. Personalization works similarly: analyzing user behavior, preferences, reviews and past interactions to provide personalized content recommendations, which can be combined with real-time factors like location. The business implication is that the data types differ at each step — structured records in, a number out, then that number as text in a prompt.
Structured prediction or multimodal generation
The data and the output decide between them — or combine them
Figure. Two cards. Traditional predictive AI is particularly effective with structured data and outputs a category, forecast or probability. Generative AI takes inputs from multiple modalities — text, images, video, audio — and outputs new text, images, video or code. A band beneath says the two can be combined: a traditional model's output can become part of a generative model's prompt.
Worked example (synthetic). A bank wants next month's cash demand per branch (structured data, a number — traditional AI) and a plain-language briefing for each branch manager (text out — generative AI).
Put the two halves of the topic together and the data types point to the kind of artificial intelligence, or AI, a task needs. On the left, traditional predictive AI, which Google says is particularly effective with structured data, and whose outputs are categories, forecasts and probabilities. On the right, generative AI, which covers use cases that require processing and inputting information from multiple modalities like text, images, videos or audio, and produces new content. The band underneath is the part exam scenarios like to test: they are not rivals, because you can use output from a traditional AI model as part of the prompt for a generative AI model. The worked example needs both — a forecast from structured data, and a briefing in plain language built from it.
What this topic actually tests
Outcome first, job second, data direction third
Outcome: a measurable goal, decided before the technology. Job: create, summarize, discover or automate, with a review step. Data: the input and output types of each task, and whether a traditional prediction should feed a generative step.
Close on the order of questions. First, the outcome: Google's guidance begins with specific measurable business goals, and decides whether the need requires generative artificial intelligence, or AI, other AI, or no AI only after that. Second, the job: create, summarize, discover or automate, each tied to a measure of success and to a decision about whether humans stay in the loop at critical steps. Third, the data: write every task as input types to output types — text to image, video to text, mixed sources to a summary, natural language to code, behavior and preferences to recommendations — because that direction is what a candidate model must support. And remember the combination: a traditional model's prediction can become part of a generative model's prompt. The next topic stays with data and asks what makes it fit for the task.
Study guide for Generative AI Leader, Unit 1 · Topic 5. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Explaining the characteristics and importance of data quality and data accessibility in AI (e.g., completeness, consistency, relevance, availability, cost, format). Identifying the differences between structured and unstructured data, and identifying real-world examples of each type. Identifying the differences between labeled and unlabeled data.
This hive's learning objectives for the topic:
Evaluate completeness, consistency, relevance, availability, cost and format before using data.
Distinguish structured and unstructured data using business examples.
Distinguish labeled and unlabeled examples and their learning uses.
Judging whether data is fit for the task
Before a model learns from data, decide whether the data deserves it
Is it good enough? completeness, consistency, relevance, availability, cost and format. What kind is it? structured rows or unstructured text, images, audio and video. Does it carry answers? labeled examples teach; unlabeled examples are what the model later predicts on.
Every generative AI project rests on data, and this topic is about judging that data before anyone builds on it. Google's machine learning course puts the stakes in one line: regardless of the format, your ML model — your machine learning model — is only as good as the data it trains on. The guide asks three things of a generative AI leader here. First, is the data good enough? It names completeness, consistency, relevance, availability, cost and format, and we will map each onto what Google documents. Second, what kind of data is it — structured, like the rows of a spreadsheet, or unstructured, like text, images, audio and video? Third, does the data carry answers? Labeled examples contain the answer a model should learn; unlabeled examples do not. Each question changes what a project can realistically do, and how much it costs.
Six checks before data reaches a model
Quality is fitness for a purpose, not a property of data in general
Completeness: does it hold everything the purpose requires?
Consistency: do the same facts agree across tables and systems?
Relevance: is it recent, and does it match what production will see?
Availability: can the people building the model actually access it?
Cost and format: what do labels cost, and does it meet format standards?
Worked example (synthetic). A retailer wants a returns assistant trained on three years of support tickets. Half the tickets lack the product code, and the ticket system and the order system disagree on refund amounts — two failed checks before any model is chosen.
The first objective is to evaluate data before using it, and Google's course defines quality pragmatically: a high-quality dataset helps your model accomplish its goal. That makes quality a question about purpose. Completeness, in Google's data catalog, assesses whether the data contains all of the information that's required for its intended purpose. Consistency refers to having the same values across multiple instances such as tables and columns — Google's example is a product whose revenue differs between a sales database and a usage database. The guide's word relevance maps onto two things Google documents: freshness, which helps you determine whether the data is recent enough to be useful, and Google's tuning advice that training data should reflect the prompt distribution, format and context the model will encounter in production. Availability is access: Google describes modern data governance as ensuring that data scientists and data engineers can access high-quality data to build accurate models and agents. Format is validity — whether data conforms to standards for format and acceptable ranges. And cost shows up most sharply in labels: Google notes you typically pay human raters, so human-generated data can be expensive. A data source that fails a check the use case depends on is not a weaker option; it is a blocked one until it is fixed.
The guide's words, mapped to what Google documents
Each check is a question you can answer before training starts
Guide's word
Question to ask
Google's term
Completeness
Does it hold all that the purpose needs?
Completeness
Consistency
Do two systems agree on the same fact?
Consistency
Relevance
Is it recent, and like production?
Freshness; match production
Availability
Can the builders reach it?
Governed access
Format
Does it meet the standards set?
Validity
Cost
What will labels cost?
Paid human raters
Worked example (synthetic). A bank's model must read loan applications from two systems. One stores dates as day-month-year, the other as month-day-year — a validity and consistency problem to fix before training, not after.
Here the six words the guide lists are set beside the terms Google actually uses, because an exam item may use either vocabulary. Completeness and consistency are Google's own dimension names: does the data hold everything the purpose needs, and do two systems agree on the same fact? Relevance is the guide's word; Google's nearest dimension is freshness — whether the data is recent enough to be useful — together with the tuning advice that training data should match what the model will see in production. Availability is a governance question: can the people building the model reach high-quality data at all? Format corresponds to validity, which evaluates whether data conforms to standards for format, acceptable ranges or other criteria. And cost is most visible in labelling, because human raters are paid. Google's own list of data-quality dimensions — accuracy, completeness, consistency, timeliness, validity and uniqueness — overlaps the guide's six without matching it word for word, which is why reading the question carefully matters more than memorising one list.
What to do with incomplete examples
Never train on them as they are: delete them or fill the gaps
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A flowchart. An example with a missing value leads to a question: do enough complete examples remain? Yes leads to deleting the incomplete example; no leads to imputing a well-reasoned guess for the gap. Both paths lead to training on complete examples. A dotted arrow shows automation flagging unreliable data before the question.
Worked example (synthetic). A clinic has 20,000 complete patient-intake forms and 300 missing an age field. With so many complete forms, deleting the 300 costs little; with only 400 forms in total, imputing would be the better fix.
Completeness has a concrete rule in Google's course: don't train a model on incomplete examples. There are two ways to fix them. You can delete the incomplete examples, which is sensible when enough complete examples remain to train a useful model. Or you can impute missing values — in Google's words, convert the incomplete example to a complete example by providing well-reasoned guesses for the missing values — which is the fallback when deleting would leave too little data. Before either, find the problems at scale: Google recommends using automation to flag unreliable data, since reliability is the degree to which you can trust your data. For a generative AI leader the lesson is about planning. Data repair is real work with a real schedule, and Google's application guidance is blunt about skipping it: if you give the model suboptimal data, like inaccurate or incomplete data, you can't expect optimal performance.
Structured and unstructured data
Rows and columns, or text, images, audio and video
Structured: data in spreadsheets or relational databases
Unstructured: text, images, audio and video files
Semi-structured: formats like sensor data without a fixed schema
Combining both gives more useful insight than either alone
Worked example (synthetic). An airline holds structured booking records and unstructured complaint emails. A model that reads both can link a complaint to the flight and fare it concerns, which neither source does alone.
The second objective is telling structured data from unstructured data, with real examples. Google's description is a contrast: more traditional structured data, such as data in spreadsheets or relational databases, is now supplemented by unstructured text, images, audio and video files, or semi-structured formats like sensor data that can't be organized in a fixed data schema. So structured data has a fixed shape — named columns, typed values — while unstructured data is content whose meaning lives inside the file. Generative AI changes the business value of the second kind, because models can read documents, look at images and listen to audio. And the two are most useful together: Google says combining structured data sources with unstructured ones provides more useful insights for consumer understanding and personalization. On Google Cloud, unstructured files do not have to stay out of analysis either — BigQuery object tables exist primarily to make unstructured data accessible for analysis.
Business examples of each kind
Ask where the meaning lives: in a column, or inside the file
Kind
Business examples
Where the meaning lives
Structured
Orders table, payroll spreadsheet
Named columns, fixed schema
Unstructured
Contracts, call recordings, product photos
Inside the file's content
Semi-structured
Sensor readings
Fields without a fixed schema
Worked example (synthetic). An insurer asks which of its data a model could use to spot damage in claims. The claims table says what was claimed; the photos show what happened — the photos are the unstructured source the use case needs.
Business examples make the distinction stick. An orders table or a payroll spreadsheet is structured: its meaning sits in named columns with a fixed schema, which is exactly what Google means by data in spreadsheets or relational databases. Contracts, call-centre recordings and product photos are unstructured: the meaning is inside the content, in the text, the audio or the image. Sensor readings are Google's example of semi-structured data — formats that can't be organized in a fixed data schema. The useful question for an exam scenario is where the meaning lives. If the answer is a column, the data is structured; if you have to read, look or listen to get it, the data is unstructured.
One customer, two kinds of data
Each kind answers a question the other cannot
Figure. Two cards. The structured card shows an order record with two items, refunded, and notes that columns tell you what happened. The unstructured card shows a customer's complaint about a crushed box and a missing lid, and notes that text tells you why. A band beneath reads: together they reveal refunds caused by packaging damage, an insight neither source gives alone.
Worked example (synthetic). A synthetic order record and complaint. Counting refunds needs only the table; explaining them needs the text.
This invented example shows why Google recommends combining the two kinds. The structured record says what happened: an order of two items, refunded. The unstructured complaint says why: the box arrived crushed. A report built on the table alone counts refunds; a report built on the emails alone tells stories without totals. Put together, they show how many refunds packaging damage caused — the kind of more useful insight Google says comes from combining structured data sources with unstructured ones. For a business leader, the practical point is that unstructured data is often where the reasons are, and that generative AI is what makes those reasons readable at scale.
Labeled and unlabeled examples
A label is the answer; an unlabeled example has none
Labeled example: features plus a label, the value to predict
Unlabeled example: features, but no label
A trained model predicts labels for new, unlabeled data
Semi-supervised learning uses data where only some is labeled
Labels can be costly: human raters are paid
Worked example (synthetic). A bank has 50,000 past transactions marked fraud or not fraud — labeled data. Tomorrow's transactions arrive unmarked, and the trained model's job is to supply that missing label.
The third objective separates labeled from unlabeled data and connects each to how it is used. Google's machine learning course defines the parts: features are the values that a supervised model uses to predict the label, and the label is the answer — the value the model should predict. Examples that contain both features and a label are called labeled examples. In contrast, unlabeled examples contain features, but no label. The two have different jobs. Labeled examples are what a supervised model learns from. Unlabeled data is what a trained model works on: once trained and evaluated, models can be used for inference, making predictions on new, unlabeled data in real-world applications. Between the two sits a mixed approach Google describes, semi-supervised learning, in which only some data is labeled. Labels also carry a cost, because you typically pay human raters, so human-generated data can be expensive — which is why the quality of labels matters more than their number: Google's tuning guidance says high-quality, well-labeled data is better than quantity.
Where labeled and unlabeled data go
Labels teach the model; unlabeled data is what it then predicts on
Loading Diagram...
Figure 2 — Mermaid diagram
Figure: A flowchart. Labeled examples, made of features and a label, feed training and evaluation, which produces a trained model. New unlabeled data, features only, goes into the trained model, which outputs a predicted label.
Worked example (synthetic). A support team labels 5,000 past emails by department, trains a router, then lets the router label each new email as it arrives.
The flow puts each kind of data in its place. Labeled examples — features plus the answer — go into training and evaluation, and a trained model comes out. New data then arrives without labels, because in real use nobody knows the answer yet; the model's job is to predict it. That is Google's description of inference: once trained and evaluated, models make predictions on new, unlabeled data. So a scenario that asks what data is needed to build a classifier is asking about labeled examples, and one that asks what the model processes after launch is describing unlabeled data. Good training data has two more properties Google names: good datasets are both large and highly diverse.
What this topic actually tests
Three questions to ask of any dataset
Is it fit for this purpose? complete, consistent, recent, reachable, valid, affordable to label. Where does its meaning live? in columns, or inside files. Does it carry the answer? labeled to learn from, unlabeled to predict on.
Close on three questions to ask of any dataset a project proposes. First, is it fit for this purpose? Check completeness, consistency, relevance — recent and like production — availability, format and the cost of labelling, and remember that incomplete examples are fixed by deleting or imputing, never trained on as they are. Second, where does its meaning live? In columns, which makes it structured, or inside files of text, images, audio and video, which makes it unstructured — and combining the two usually tells you more. Third, does it carry the answer? Labeled examples teach a model; unlabeled data is what the trained model predicts on. A machine learning model is only as good as the data it trains on, so these questions come before any choice of model.
Study guide for Generative AI Leader, Unit 1 · Topic 6. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Infrastructure Models Platforms Agents Applications
This hive's learning objectives for the topic:
Explain the infrastructure layer and its compute, storage and networking responsibilities.
Distinguish reusable models from the applications that use them.
Explain how platforms support development, evaluation, deployment and operations.
Explain how agents combine model decisions with tools and bounded workflows.
Identify the user-facing application layer and its business workflow.
Locating decisions in the generative AI landscape
Five layers: infrastructure, models, platforms, agents, applications
Infrastructure — the compute, storage and networking everything runs on. Models — reusable engines such as Gemini. Platforms — where teams build, deploy and govern. Agents — models given goals and tools. Applications — what people actually use at work.
A generative AI leader is constantly asked to decide things — which model, which tool, who may approve what — and the guide asks you to place each decision on one of five layers. From the bottom: infrastructure, the compute, storage and networking that everything runs on; models, the reusable engines such as Gemini; platforms, where teams build, deploy and govern solutions; agents, which give a model goals and tools; and applications, the products employees and customers actually use. The layers matter because a decision made on one layer depends on the ones beneath it. An application cannot be more reliable than the platform it runs on, and an agent can only do what its tools and permissions allow. Google's own phrase for the relationship between the middle two is that foundation models form the core upon which numerous generative AI applications are built.
Infrastructure: what everything runs on
Accelerators, networking and storage — usually chosen for you
Accelerators: NVIDIA GPUs and Google Cloud TPUs
TPUs: Google-designed chips for large matrix operations
Networking and storage move and hold the data
AI Hypercomputer: Google Cloud's unified AI infrastructure portfolio
Worked example (synthetic). A bank calls a hosted model through an API and never sees a chip. A research lab training its own model must choose accelerators and storage — the same layer, decided by very different people.
The first layer is infrastructure, and its job is compute, storage and networking. Google describes AI Hypercomputer as an integrated supercomputing system optimized for artificial intelligence and machine learning workloads, and as the unified portfolio for Google Cloud's AI infrastructure — performance-optimized hardware, open software and flexible consumption models. Its hardware layer provides accelerators, both NVIDIA GPUs — graphics processing units — and Google Cloud TPUs, along with networking and storage resources. TPUs, or Tensor Processing Units, are Google's custom-developed chips used to accelerate machine learning workloads; they train models efficiently with hardware designed for the large matrix operations machine learning relies on. For most businesses this layer is a decision made for them: a team calling a hosted model never chooses a chip. It becomes a leader's decision when the organization trains or serves its own models and must weigh hardware, scale and how capacity is bought.
The five layers in order
Infrastructure is the base everything else depends on
Figure. A band titled generative AI landscape holds five boxes in order: 1 Infrastructure, with TPUs, GPUs, storage and networking; 2 Models, such as Gemini, Gemma and Veo; 3 Platforms, to build, deploy, govern and optimize; 4 Agents, models plus tools and memory; 5 Applications, what employees and customers use. A note reads that a business decision usually lands on one layer and depends on the layers below it.
Worked example (synthetic). A team wants its customer-service app to answer faster. The fix might be in the application, a different model, or more serving capacity — locating the decision tells you whose job it is.
Here are the five layers the guide names, in its order. Infrastructure sits first because everything else runs on it. Models come next — reusable engines such as Gemini, Gemma and Veo. Platforms are where those models are turned into solutions: Google describes Gemini Enterprise Agent Platform as a unified platform to build, deploy, govern and optimize AI agents and model-based solutions. Agents add goals, tools and memory to a model. And applications are what people actually use. The note on the figure is the skill this topic tests: a business decision usually lands on one layer and depends on the layers beneath it. Asking which layer a decision belongs to also tells you who usually makes it — a procurement and engineering team for infrastructure, a builder for platforms and agents, a business owner for applications.
Models and the applications built on them
One model can serve many applications; an app serves one purpose
A foundation model is the core many applications are built on
A simple prompt can steer one model to many different tasks
Model Garden offers Google's, third-party and open-source models
The application adds the workflow, data and users
Worked example (synthetic). One company runs a contract summariser and a sales-email drafter on the same model. Changing the model affects both apps; changing the drafter's screens affects only the drafter.
The second objective is the line between a model and an application. A foundation model is a reusable engine, and Google's description is that foundation models form the core upon which numerous generative AI applications are built. Their flexibility comes from what Google calls emergent abilities: with a simple text prompt, a foundation model can learn to perform a variety of tasks — translating languages, answering questions, writing code — without explicit training for each one. Google Cloud's Model Garden gives access to Google's frontier models such as Gemini, plus third-party and open-source models. An application is different in kind. It wraps a model in a particular workflow, connects it to particular data and puts it in front of particular users. That is why a model decision ripples into every application built on it, while an application decision stays local to that application.
Model or application?
Ask whether the thing is reused across purposes, or built for one
Question
Model
Application
What is it for?
Many tasks, steered by prompts
One business purpose
Who uses it?
Builders, through a platform
Employees or customers
What does it add?
General capability
Workflow, data and interface
Who feels a change?
Every app built on it
That app's users
Worked example (synthetic). Upgrading the model under five internal tools needs testing in all five. Redesigning one tool's screen needs testing in one.
Four questions separate the two. What is it for? A model serves many tasks, steered by prompts; an application serves one business purpose. Who uses it? Builders reach models through a platform such as Model Garden, while employees or customers use applications. What does it add? A model brings general capability; the application brings the workflow, the data connections and the interface. And who feels a change? Because foundation models form the core of numerous applications, changing a model is felt by every application built on it, while changing one application is felt by that application's users. In an exam scenario, a decision that affects several products at once is usually a model or platform decision; one that affects a single workflow is usually an application decision.
Platforms: where solutions are built and run
Build, scale, govern and optimize, in one place
Agent Platform: build, deploy, govern and optimize agents and solutions
Covers the lifecycle from 200+ foundation models to running agents
Low-code: Agent Studio designs agents without code
Code: Agent Development Kit builds complex agents
Integrated security and governance for enterprise needs
Worked example (synthetic). A retailer's data team builds a product-question agent in Agent Studio, connects its catalogue through RAG Engine, and governs who can deploy it — three platform decisions before any shopper sees it.
The third layer is the platform, where models become solutions. Google describes Gemini Enterprise Agent Platform as a unified platform to build, deploy, govern and optimize enterprise-grade AI agents and model-based solutions. As an evolution of Vertex AI, it supports the complete AI lifecycle, from accessing over two hundred foundation models to deploying and managing agents. It meets builders at different skill levels: Agent Studio lets you design agents and interact with models without code, while the Agent Development Kit is a modular, model-agnostic framework for building and deploying complex agents. It connects models to company knowledge too — RAG Engine securely connects private enterprise data to large language models to improve answer accuracy and reduce hallucinations. And it answers enterprise requirements with integrated security and governance. A platform decision is therefore a decision about how solutions are built, evaluated and controlled, not about any single application.
The platform's four pillars
Each pillar is a set of decisions a team makes on the platform
Pillar
Decisions it holds
Example capability
Build
Design, prototype and develop agents
Agent Studio, Model Garden
Scale
Deploy and manage agents in production
Agent Runtime
Govern
Secure, catalog and govern agents
Agent Identity permissions
Optimize
Assess, monitor and refine quality
Agent evaluation
Worked example (synthetic). A team debating who may deploy a new agent is in Govern; a team debating Agent Studio against code is in Build.
Google organizes Agent Platform around four pillars: build, scale, govern and optimize. Reading them as four sets of decisions makes the platform layer concrete. Build is where you design, prototype and develop agents — Agent Studio for low-code design, Model Garden for the choice of model. Scale is deploying and managing them, with Agent Runtime as the scalable runtime environment. Govern is securing, cataloguing and governing agents with enterprise-grade controls and policies — Agent Identity, for example, lets you grant granular permissions to agents. Optimize is assessing, monitoring and refining agents to keep quality and reliability high. When an exam scenario describes a team arguing about permissions, deployment or evaluation, the argument is happening on the platform layer, whatever application it is for.
Agents: a model with goals and tools
Agents reason, plan and act — within the tools and permissions given
Agents use AI to pursue goals and complete tasks for users
They reason, plan and remember, with some autonomy
Tools are how an agent acts on its environment
Large language models are the foundation they reason with
Permissions and supervision bound what they may do
Worked example (synthetic). An expense agent reads a receipt, checks the travel policy and files the claim. It can file claims because it was given that tool — and not approve payments, because it was not.
The fourth layer is agents. Google defines AI agents as software systems that use AI to pursue goals and complete tasks on behalf of users. They show reasoning, planning and memory, and have a level of autonomy to make decisions, learn and adapt. Two ingredients make that possible. Large language models, or LLMs, serve as the foundation, giving agents the ability to understand, reason and act. And tools are the functions or external resources an agent uses to interact with its environment — looking something up, filing a form, calling a system. That second ingredient is also the boundary. An agent can only do what its tools let it do, and on Agent Platform, Agent Identity lets you grant granular permissions to agents. Google's framing keeps people involved as well: agents can reason and take action on users' behalf with their supervision. A leader's agent decision is therefore mostly about scope — which goals, which tools, which permissions, and where a human checks the work.
How an agent works through a task
Reason, act with a tool, observe, repeat — inside its permissions
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A flowchart. A goal from a user leads to reasoning and planning with the model, then acting through a permitted tool, then observing the result. If the task is not done, the flow loops back to reasoning; when it is done, the agent reports back for review.
Worked example (synthetic). Asked to rebook a cancelled flight, an agent searches flights, holds a seat, checks the fare rule, and returns the option to the traveller to confirm.
This loop is the shape of most agent work. A user gives a goal. The agent reasons and plans with its model — Google names reasoning and planning among an agent's defining traits. It acts through a tool, the function or external resource that lets it touch the world. It observes the result, and if the task is not done it reasons again. When it is done, it reports back, because agents act on users' behalf with their supervision. Two things in the figure are business decisions rather than technical ones: which tools the agent is permitted to use, and where the loop stops for a person to review. Those two choices decide how much autonomy an agent really has.
Agents, assistants and bots
The difference is how much they decide on their own
System
Autonomy
Typical behaviour
AI agent
Most
Pursues a goal; plans and acts
AI assistant
Less
Needs user input and direction
Bot
Least
Follows pre-programmed rules
Worked example (synthetic). A website menu that answers fixed questions is a bot. A chat helper that drafts a reply when asked is an assistant. A system that resolves a refund end to end is an agent.
Google separates three things that are often all called agents. AI agents pursue goals and complete tasks with a level of autonomy. AI assistants, Google says, are less autonomous, requiring user input and direction. Bots are the least autonomous, typically following pre-programmed rules. The scale matters when you place a decision. Moving from a bot to an assistant changes how the model is used; moving from an assistant to an agent changes what the system is allowed to do without asking — which is why that step brings governance questions such as tool permissions and review points with it.
Applications: where people meet AI
The layer users see, built around a business workflow
Gemini Enterprise: intranet search, AI assistant and agentic platform
Permissions-aware search across enterprise information
Gemini in Workspace: help in the flow of work in Gmail, Docs and Meet
An application is judged by the workflow it improves
Worked example (synthetic). A sales team uses Gemini in Gmail to draft follow-ups and Gemini Enterprise to search past deals. Neither team member chooses a model or a chip; they choose how their work changes.
The fifth layer is applications — the products people actually use, organized around a business workflow. Google describes Gemini Enterprise as an intranet search, AI assistant and agentic platform that empowers knowledge workers with generative AI and agentic workflows by drawing on data sources from across the organization. It gives employees a single, multimodal search interface with permissions-aware access to enterprise information, so people find only what they are allowed to see. Google Workspace with Gemini puts help directly in the flow of work: help me write in Gmail and Docs to compose emails and documents, and take notes for me in Meet so people can focus on the conversation. Application decisions are a business owner's decisions — which workflow to change, for which people, and how to measure whether it got better — and they rest on every layer underneath.
Two Google applications, two workflows
Each one is defined by the work it changes, not the model under it
Application
Who uses it
What it changes
Gemini Enterprise
Knowledge workers
Search, assistance and agents across company data
Workspace with Gemini
People in Gmail, Docs, Meet
Help in the flow of work: drafting, notes
Worked example (synthetic). A legal team needs to find past clauses across many systems — a Gemini Enterprise workflow. The same team wants first drafts inside Docs — a Workspace with Gemini workflow.
Two of Google's applications show how this layer is defined by work rather than technology. Gemini Enterprise is an intranet search, AI assistant and agentic platform for knowledge workers, drawing on data sources from across the organization, with permissions-aware access so people see only what they may. Google Workspace with Gemini puts AI help directly in the flow of work — help me write in Gmail and Docs, take notes for me in Meet. Both may run on the same family of models; what separates them is the workflow each changes and the people who use it. That is the question an application decision answers.
Which layer does this decision belong to?
Name the layer, and you have named who decides
Figure. A two-column table of decisions and layers. Train on TPUs or GPUs: infrastructure. Which model powers our tools: models. Who may deploy agents: platforms. May it issue refunds alone: agents. Which team's workflow changes: applications.
Worked example (synthetic). Five questions from one project, each placed on a different layer of the guide's landscape.
Here the skill is applied to five questions from a single project. Whether to train on TPUs or GPUs — Tensor Processing Units or graphics processing units — is an infrastructure decision. Which model powers the company's tools is a model decision, felt by every application built on that model. Who may deploy agents is a platform decision — governance, in Agent Platform's terms. Whether an agent may issue refunds on its own is an agent decision about tools and permissions. And which team's workflow changes is an application decision. Naming the layer also names who usually decides, which is what the exam means by locating a decision in the landscape.
What this topic actually tests
Place the decision, then ask what it depends on
Infrastructure runs everything. Models are reused across applications. Platforms build, deploy and govern. Agents act through tools within permissions. Applications change a workflow for real people.
Close by placing decisions. Infrastructure — accelerators such as Tensor Processing Units, TPUs, and graphics processing units, GPUs, with networking and storage — runs everything. Models are reusable engines; foundation models are the core numerous applications are built on, so a model change ripples outward. Platforms such as Agent Platform are where teams build, deploy, govern and optimize. Agents give a model goals and tools, and act only within the permissions they are granted. Applications such as Gemini Enterprise and Gemini in Workspace change a workflow for real people. When a scenario describes a decision, name its layer first, then ask what it depends on underneath. The next topic opens the model layer and looks at Google's model families one by one.
Study guide for Generative AI Leader, Unit 1 · Topic 7. This is the topic's lecture in reading form — every slide's teaching, figures and worked examples, in order — followed by the official Google Cloud pages its claims rest on.
What the exam guide asks, quoted. Gemini Gemma Imagen Veo
This hive's learning objectives for the topic:
Recognize Gemini use cases and verify model-specific input and output capabilities.
Recognize Gemma open-weight use cases and the resulting deployment and license responsibilities.
Recognize Imagen image-generation and supported editing use cases.
Recognize Veo video-generation use cases and verify version-specific capabilities.
Choosing among Google's model families
Gemini, Gemma, Imagen and Veo — and why you read the model page
Gemini — multimodal models for most tasks. Gemma — lightweight open models you can run and tune yourself. Imagen — specialized image generation, now with Gemini as Google's starting point. Veo — video from text and images. Capabilities differ by version: check the model's own page.
The guide names four of Google's model families and asks for their use cases and strengths. Gemini is the general family, built from the ground up for multimodality, so it can reason across text, images, video, audio and code. Gemma is a set of lightweight, generative artificial intelligence open models that you can run on your own hardware or hosted services and tune yourself. Imagen is Google's specialized image generation model — though, as we will see, Google now recommends Gemini as the starting point for generating images. And Veo generates video from text and images. One habit runs through the whole topic: capabilities differ by model and by version, so a leader confirms them on the model's own page instead of trusting a summary — including this deck, which names the version behind every number it gives.
Gemini: one family, different strengths
Pick the Gemini model by the job, then verify what that model accepts
Built for multimodality: text, images, video, audio and code
3.8 Flash: long-horizon coding and autonomous agents
3.5 Flash: near-Pro intelligence at Flash-tier cost and speed
3.1 Flash-Lite: most cost-efficient, for high-volume, low-latency traffic
Gemini image models: conversational editing and multi-image fusion
Worked example (synthetic). A support team routes a million short questions a day and needs low cost per request. Flash-Lite's documented strength fits; a coding agent that works for hours fits 3.8 Flash's.
Gemini is a family, not one model. Google's documentation says Gemini models are built from the ground up for multimodality and can reason seamlessly across text, images, video, audio and code. Within the family, each model page states a strength. Gemini 3.8 Flash is described as Google's most intelligent workhorse model yet, built for long-horizon coding and autonomous agents. Gemini 3.5 Flash delivers near-Pro intelligence at Flash-tier cost and speed. Gemini 3.1 Flash-Lite is the most cost-efficient model, optimized for low-latency use cases with high-volume, cost-sensitive traffic. And the Gemini image models add conversational editing, multi-image fusion and character consistency for creative work. These descriptions are current as of this deck's retrieval date and will change — which is why the second half of this objective is verification: before relying on a capability, check the features that each model supports, on that model's own page.
What a model page tells you
Modalities, limits and capabilities are listed per model and version
Figure. A model page card for Gemini 3.5 Flash, retrieved 6 October 2026, with three panels: token limits showing a context window of 1,048,576 tokens and a maximum output of 65,536 tokens; modalities, meaning which inputs it accepts and which outputs it returns; and capabilities such as tuning, grounding and function calling, each marked supported or not.
Worked example (synthetic). A team plans to send 2,000-page document sets in one request. The model page's context window answers whether that fits before any test is run.
Here is what verification looks like in practice. Each Gemini model has its own page listing its modalities, its token limits and its capabilities. Gemini 3.5 Flash's page, for example, lists a context window of one million, forty-eight thousand, five hundred and seventy-six tokens and a maximum output of sixty-five thousand, five hundred and thirty-six tokens. Those numbers belong to that model and that version; another Gemini model can list different ones, and Google revises them over time. So the leader's habit is simple: when a use case depends on an input type, a request size or a capability such as tuning, confirm it on the model's own page — Google's guidance is to check the features that are supported by each model.
Gemma: open models you run and tune
Open weights give control — and hand you the work of running them
Lightweight generative AI open models, based on Gemini models
Run in your apps, on your hardware, mobile devices or hosted services
Open weight: tune with the framework of your choice
Smaller sizes need fewer resources and deploy more flexibly
Pretrained versions need tuning before real use
Worked example (synthetic). A device maker needs a model that runs on a phone with no network connection. A small Gemma variant fits that requirement in a way a hosted model cannot.
Gemma is Google's open model family. Google describes Gemma as a set of lightweight, generative artificial intelligence open models, available to run in your applications and on your hardware, mobile devices or hosted services. Because the models are open weight, you can tune any of them using the framework of your choice. Size is a deployment decision too: lower parameter sizes mean lower resource requirements and more deployment flexibility, and Gemma 4, for example, is listed as supporting text and image input on all variants and audio on its smallest variants. Open weights come with responsibilities. Pretrained versions are not ready for users as they are — Google does not recommend using them without performing some tuning. And whoever runs the model takes on its operation. Google's guidance is to use Agent Platform if you want end-to-end operations tooling and a serverless experience, and to self-manage on Google Kubernetes Engine when you have in-house expertise and need granular control.
Who runs an open model, and what that costs
Managed serving trades control for less operational work
Serving choice
Who operates it
What you gain
Managed API (MaaS)
Google provisions, scales and maintains
Focus on the application
Self-deployed
Your team, in your project and network
Control of the data path; lower cost at scale
On GKE
Your team, with in-house operations skills
Granular control of the workload
Worked example (synthetic). A bank whose regulator forbids multi-tenant services self-deploys Gemma in its own network and staffs the operations work that comes with it.
The deployment responsibility the guide mentions becomes concrete in Google's serving options for open models. With a managed API — model as a service — Google handles all provisioning, scaling and maintenance, which suits teams focused on the application rather than operations. Self-deploying lets you run the model within your own Google Cloud project and network, with complete control over the data path; it requires a greater upfront engineering investment but can lower total cost of ownership at scale. Running on Google Kubernetes Engine suits organizations with existing Kubernetes investments and in-house operations expertise that need granular control. The pattern to remember: the more control you take over an open model, the more of its running becomes your team's job.
Imagen: specialized image generation
Know its use cases — and that Google now points to Gemini first
Generate novel images from a text prompt
Edit or expand an image using a mask you define; upscale images
Strong for photorealism, branding, logos and typography
Google recommends Gemini as the starting point for images
Imagen endpoints are listed as deprecated, migrating to Gemini
Worked example (synthetic). A marketing team needs a product logo with exact lettering. That is a documented Imagen strength — but a new project starts on Gemini's image model, because that is where Google directs new image work.
Imagen is the image family the guide names, and Google's documentation still describes its use cases: generate novel images using only a text prompt, edit or expand an uploaded or generated image using a mask area you define, and upscale existing images. Google lists its strengths as image quality, photorealism and specific styles; infusing branding or generating logos and product designs; and advanced spelling or typography — with low latency, optimized for near-real-time performance. But the same documentation now steers new work elsewhere. It recommends Gemini as a starting point for generating images, and its table of deprecated image generation endpoints lists the Imagen endpoints — imagen-4.0-generate-001 among them — with gemini-2.5-flash-image as the replacement, recommending updates before June 30, 2026. These pages also carry the notice that Vertex AI's services are now part of Gemini Enterprise Agent Platform. So know Imagen's use cases for the exam, and know that Gemini's image models are where Google points new image projects.
Gemini image models against Imagen 4
Google's own comparison: flexibility against specialized quality
Aspect
Gemini image
Imagen 4
Google's stance
Starting point for images
Specialized; Ultra for best quality
Editing
Multi-turn conversational editing
Mask-based editing, upscaling
Strengths
Multi-image fusion, consistency
Photorealism, logos, typography
Latency
Higher
Near-real-time
Worked example (synthetic). A design team iterates on a poster through several rounds of spoken changes — Gemini's conversational editing fits. A catalogue needs a thousand photorealistic product shots quickly — the Imagen strengths fit.
Google's documentation compares the two image options directly. Gemini's image models are Google's recommended starting point for generating images; they are uniquely capable of multi-turn conversational editing, and support multi-image fusion and character consistency, at higher latency. Imagen is Google's specialized image generation model: it edits with masks and upscales, it is strongest where image quality, photorealism, branding, logos or typography are the priority, and it is optimized for near-real-time performance — Google advises choosing Imagen 4 Ultra when you need the best image quality. Hold the earlier caveat alongside the table: Google calls Imagen 4 its latest line of image generation models, yet lists its endpoints as deprecated with a Gemini image model as the replacement. In a scenario, prefer the answer that starts from Gemini and reaches for Imagen only for its specialized strengths.
Two facts about Imagen to hold together
Its use cases are documented; its endpoints are being retired
Figure. Two cards. The first, what Imagen does, lists text-to-image generation, mask-based editing and expansion, upscaling, and strengths in photorealism, logos and typography. The second, where Google points now, lists Gemini as the starting point for images, the imagen-4.0-generate-001 endpoint migrating to gemini-2.5-flash-image, and updating endpoints before June 30, 2026.
Worked example (synthetic). An exam item asks what Imagen is used for: answer with its use cases. A project plan asks which image model to build on: start with Gemini, as Google recommends.
Two facts about Imagen are both true, and a good answer keeps them apart. On the left, what Imagen does: it generates novel images from text prompts, edits or expands images using a mask you define, upscales images, and is strongest at photorealism, branding and logos, and typography. On the right, where Google points today: Google recommends Gemini as a starting point for generating images, and its table of deprecated endpoints maps imagen-4.0-generate-001 to gemini-2.5-flash-image, with a recommendation to update endpoints before June 30, 2026. So a question about Imagen's use cases is answered from the left card, and a question about what to build a new image workflow on is answered from the right.
Veo: video from text and images
Know the use case, then check what this Veo version supports
Veo generates videos from text prompts and images
Veo 3.1 is Google's latest line of video generation models
Veo 3.1 Fast adds low latency to high quality
Version facts: 4, 6 or 8 second clips; 9:16 or 16:9
Gemini Omni Flash can also generate and edit video
Worked example (synthetic). A retailer wants short vertical product clips for phones. Veo 3.1's documented 9:16 aspect ratio and 8-second limit decide whether one clip or several stitched clips are needed.
Veo is Google's video family. Google's model list describes Veo 3.1 Generate as generating videos from text prompts and images with high quality, and Veo 3.1 Fast as doing the same with high quality and low latency. Veo 3.1 is described as Google's latest line of video generation models. On Agent Platform you can generate video with either Gemini Omni Flash or Veo, in Media Studio or through their APIs, and Gemini Omni Flash is listed as able to generate video from text or reference assets, or edit existing videos. Version-specific facts matter here more than anywhere. Veo 3.1's page lists video lengths of 4, 6 or 8 seconds — with reference-image-to-video supporting only 8 — aspect ratios of 9:16 and 16:9, output resolutions up to 4K, and English as the prompt language. A use case that needs a two-minute landscape film is not answered by any single Veo 3.1 clip, which is exactly the kind of check a leader makes on the model page first.
Veo 3.1, as its page documents it
Requirements to check before promising a video use case
Requirement
Veo 3.1 documents
Check before
Clip length
4, 6 or 8 seconds
Promising longer scenes
Aspect ratio
9:16 or 16:9
Square or other formats
Output resolution
720p, 1080p, 4K (Generate)
Print or cinema output
Prompt language
English
Non-English prompts
Worked example (synthetic). A travel brand plans 30-second landscape adverts. Veo 3.1's 8-second maximum means planning several clips per advert from the start.
This table turns the version facts into checks. Clip length: Veo 3.1 lists 4, 6 or 8 seconds, so longer scenes need planning. Aspect ratio: 9:16 for vertical and 16:9 for landscape, so any other format needs another plan. Output resolution: the Generate model lists 720p, 1080p and 4K. Prompt language: English. All of these come from Veo 3.1's own page on the retrieval date, and Google states that Veo and Gemini Omni Flash are designed with its AI Principles in mind — which still leaves testing and responsible deployment to you. The figures will change with the next version; the habit of checking them should not.
Which family fits the job?
Start from what must be produced, then where it must run
Loading Diagram...
Figure 1 — Mermaid diagram
Figure: A flowchart. A business job first asks: must it run on your own hardware or device? Yes leads to Gemma. No leads to a second question: what must it produce? Video leads to Veo; images lead to a Gemini image model, with Imagen for its specialized strengths; text, code or analysis leads to Gemini.
Worked example (synthetic). Three requests in one week: an offline field-inspection app (Gemma), a social video campaign (Veo), and a contract-analysis tool (Gemini).
Put the four families together as a first-pass choice. Start with where the model must run. If it must run on your own hardware or a device, the open Gemma models are the family designed for that — Google says Gemma runs on your hardware, mobile devices or hosted services. Otherwise, ask what must be produced. Video points to Veo. Images point to a Gemini image model first, because Google recommends Gemini as the starting point, with Imagen for its specialized strengths such as typography. Text, code and analysis point to Gemini, built for multimodality across all of them. This is a first pass, not a final answer: the earlier topic's method still applies — screen, evaluate on your own workload, then compare.
What this topic actually tests
Match the family to the job, then check the version
Gemini for most text, code and multimodal work. Gemma when you must run or tune the model yourself — and run it. Imagen for its specialized image strengths, with Gemini as Google's starting point. Veo for video, within each version's documented limits.
Close with the four families and one habit. Gemini is the general, multimodal family; pick the model within it by the job. Gemma is for when you must run or tune the model yourself — open weights give control, and hand you the work of running the model. Imagen has documented strengths in photorealism, logos and typography, but Google now recommends Gemini as the starting point for images and lists Imagen endpoints as deprecated. Veo produces video from text and images, within limits that each version documents. And the habit: every capability belongs to a model and a version, so confirm it on that model's page before a business plan depends on it. Model Garden is where Google's proprietary and select open models are discovered, tested and deployed, and it is the natural place to start that check.
Under each topic, Google's own considerations are quoted from Google's Generative AI Leader exam guide, retrieved 2026-10-06; the numbered objectives beneath them are this hive's learning objectives, written over those considerations. Each topic closes with its own summary of what the exam actually tests, taken from its lecture.
Topic 1 — Assess Google Cloud platform value
GAIL-U2.T1 · 4 objectives · lecture deck of 12 slides
The exam guide's considerations, quoted. Describing how Google's AI-first approach and commitment to future innovation translate into cutting-edge gen AI solutions. Describing how Google Cloud has an enterprise-ready AI platform (e.g., responsible, secure, private, reliable, scalable). Recognizing the advantages of Google's comprehensive AI ecosystem (e.g., integration of gen AI across Google products and services). Describing the benefits of Google Cloud's open approach.
Interpret Google AI-first positioning without treating marketing claims as independent comparisons.
Evaluate responsible, secure, private, reliable and scalable operation as configuration-dependent requirements.
Explain potential integration benefits across the Google AI ecosystem.
Explain the benefits and responsibilities of model and tooling choice in an open ecosystem.
What this topic actually tests.AI-first? whose claim is it, and what would test it. Enterprise-ready? which controls must we configure. Ecosystem? which of our tools does it reach. Open? which choices does it hand us, and who will evaluate them.
Topic 2 — Connect infrastructure and data controls to delivery
GAIL-U2.T2 · 3 objectives · lecture deck of 11 slides
The exam guide's considerations, quoted. Identifying the essential components of Google Cloud’s AI-optimized infrastructure and its benefits (e.g., hypercomputer, Google’s custom-designed TPUs, GPUs, data centers, cloud computing). Explaining how Google Cloud's AI platform provides users with control over their data (e.g., security, privacy, governance, open and leading first party models, pre-built and customizable solutions, agents). Describing how Google Cloud's AI platform democratizes AI development (e.g., low-code and no-code tools, pre-trained models, APIs).
Explain AI Hypercomputer, TPU, GPU, data-center and cloud roles at a business level.
Identify data-control choices across models, governance, prebuilt solutions and agents.
Choose low-code, no-code, pretrained-model or API paths for an organization capability.
What this topic actually tests.Which layer fits? an integrated system; TPUs for specific workloads, GPUs and CPUs for others. Which control applies? ask per layer — models, governance, prebuilt solutions, agents. Which path? a pre-trained API first, then no-code, low-code, code.
Topic 3 — Choose an AI tool for workplace tasks
GAIL-U2.T3 · 3 objectives · lecture deck of 11 slides
The exam guide's considerations, quoted. Recognizing the functionality, use cases, and business value of the Gemini app and Gemini Advanced (e.g., Gems). Recognizing the functionality, use cases, and business value of Gemini Enterprise (e.g., Gemini Notebook API, multimodal search, and custom agent capabilities). Recognizing the functionality, use cases, and business value of Gemini for Google Workspace.
Match Gemini app and Gems use cases to current account and subscription scope, retaining the guide term Gemini Advanced.
Recognize Gemini Enterprise search, notebook and custom-agent use cases with edition and preview boundaries.
Match Gemini for Google Workspace assistance to work within Workspace applications.
What this topic actually tests.Gemini app — a general assistant; the work account brings enterprise protections; Gems customise it, skills replace them. Gemini Enterprise — search, assistant and agents across company systems, within edition and preview limits. Gemini in Workspace — help inside the app where the work is.
Topic 4 — Improve customer discovery and service
GAIL-U2.T4 · 2 objectives · lecture deck of 10 slides
The exam guide's considerations, quoted. Recognizing the functionality, use cases, and business benefits of Google Cloud’s external search offerings (e.g., Agent Search on Gemini Enterprise Agent Platform , Google Search). Recognizing the functionality, use cases, and business value of Google’s Customer Engagement Suite (e.g., Conversational Agents, Agent Assist, Conversational Insights, Google Cloud Contact Center as a Service).
Distinguish enterprise search, public Google Search and grounding use cases.
Choose conversational agents, agent assistance, conversation insights or contact-center services for a service need.
What this topic actually tests.Where does the answer live? your own sites and data → Agent Search; the public, current web → Grounding with Google Search; your documents inside a model's answer → grounding on your data. Who is being helped, and when? customers on their own → CX Agent Studio; a person mid-conversation → Agent Assist; managers afterwards → CX Insights; the whole queue → CCAI Platform.
Topic 5 — Choose building blocks for a custom AI solution
GAIL-U2.T5 · 3 objectives · lecture deck of 12 slides
The exam guide's considerations, quoted. Recognizing the functionality, use cases, and business value of Agent Platform (e.g., Model Garden, Agent Search, Agent Platform AutoML). Recognizing the functionality, use cases, and business value of Google Cloud’s RAG offerings (e.g., prebuilt RAG with Agent Search, RAG APIs). Recognizing the functionality, use cases, and business value of using Agent Platform to build custom agents.
Match Model Garden, Agent Search and AutoML to their distinct developer tasks.
Choose prebuilt search-based RAG or RAG APIs according to retrieval needs.
Recognize when a custom agent is appropriate and identify its tools and operating controls.
What this topic actually tests.Model? Model Garden to find and deploy; AutoML to train with minimal effort. Your data? Agent Search's prebuilt RAG unless you must control the parts — then RAG APIs or RAG Engine. Action? a custom agent with ADK on Agent Runtime, under identity, gateway and registry controls.
Topic 6 — Give agents the right tools
GAIL-U2.T6 · 3 objectives · lecture deck of 12 slides
The exam guide's considerations, quoted. Identifying how agents use tools to interact with the external environment and achieve tasks (e.g., extensions, functions, data stores, and plugins). Identifying relevant Google Cloud services and pre-built AI APIs for agent tooling (e.g., Cloud Storage, databases, Cloud Functions, Cloud Run, Agent Platform, Speech-to-Text API, Text-to-Speech API, Translation API, Document Translation API, Document AI API, Cloud Vision API, Cloud Video Intelligence API, Natural Language API, Google Cloud API Library). Determining when to use Agent Studio and Google AI Studio.
Explain how functions, extensions, data stores and plugins connect agents to external tasks.
Match Google storage, database, execution and prebuilt AI services to tool inputs and outputs.
Distinguish Agent Studio and Google AI Studio by intended workflow and service context.
What this topic actually tests.Who runs it? a function is run by your application; an extension by the platform — and extensions are retiring. What goes in and out? audio, text, documents, images and video each name their API; code runs on Cloud Run; data lands in Cloud Storage or a database. Where do you build? Google AI Studio to try Gemini fast; Agent Studio for production on Google Cloud.
Generative AI Leader (GCP-GAIL) Practice Questions
Try 15 sample questions from a bank of 460. Answers and detailed explanations included.
Q1easy
In Google's description of AI agents, what are tools?
A.
The specific chips that the agent runs on.
B.
The people who supervise the agent's work.
C.
Resources an agent uses to act on its environment.
D.
The fixed, pre-programmed rules that a bot follows.
Show answer & explanation
Correct Answer: C
The specific chips that the agent runs on.: Incorrect. Chips such as TPUs are infrastructure; tools are what an agent uses to act.
The people who supervise the agent's work.: Incorrect. Google says agents act on users' behalf with their supervision; users are not tools.
Resources an agent uses to act on its environment.: Correct. Google defines tools as functions or external resources that an agent can utilize to interact with its environment and enhance its capabilities.
The fixed, pre-programmed rules that a bot follows.: Incorrect. Following pre-programmed rules is what makes a bot the least autonomous system.
Answer: C
Q2medium
A logistics firm needs the printed text on photographed shipping labels turned into machine-readable text. Which pre-trained capability fits?
A.
The Vision API's text recognition
B.
Building a custom vision model from scratch in code
C.
Cloud Translation's Basic API on the label images
D.
Workspace Studio automations running inside Gmail
Show answer & explanation
Correct Answer: A
The Vision API's text recognition — correct. Google lists Vision API text detection: "Optical character recognition (OCR) for an image; text recognition and conversion to machine-coded text."
Building a custom vision model from scratch in code — incorrect. A pre-trained API already provides text recognition, so building from scratch wastes effort.
Cloud Translation's Basic API on the label images — incorrect. Translation converts text between languages; it does not read text from images.
Workspace Studio automations running inside Gmail — incorrect. Workspace Studio automates work; text recognition from images is the Vision API's job.
A hotel needs written descriptions based on room photographs. Which information direction must a candidate support?
A.
Text input and image output
B.
Image input and text output
C.
Audio input and video output
D.
Text input only with a longer context limit
Show answer & explanation
Correct Answer: B
Text input and image output — Incorrect: This reverses the required input/output direction.
Image input and text output — Correct: The photograph enters the system; the written description leaves it.
Audio input and video output — Incorrect: Neither direction matches the stated task.
Text input only with a longer context limit — Incorrect: More text capacity does not establish photograph input.
Answer: B
Q4hard
A hotel chain plans to judge its summarization pilot by how many summaries the model produces. What does Google's use-case guidance point it to instead?
A.
Counting generated words, since output proves value
B.
Skipping measurement until after a full rollout
C.
Measuring against the business goals it identified
D.
Tracking only how quickly the model responds
Show answer & explanation
Correct Answer: C
Measuring against the business goals it identified is correct. Google says to begin from specific measurable business goals and to clarify how the business plans to measure their success — output volume is not a goal.
Counting generated words, since output proves value is wrong: output volume says nothing about the business goal; Google asks how success against the goal will be measured. Skipping measurement until after a full rollout is wrong: Google puts the measure of success at the start of the decision process, not after rollout. Tracking only how quickly the model responds is wrong: speed alone is not the business outcome; Google names measures such as return on investment.
A team splits "read a contract, list risks, draft a summary" into three prompts, each fed the previous one's result. What is this technique?
A.
Few-shot prompting.
B.
Prompt chaining.
C.
Role prompting.
D.
Aggregating parallel prompts.
Show answer & explanation
Correct Answer: B
Few-shot prompting.: Incorrect. Few-shot prompts add examples to one prompt; here the work is split across linked prompts.
Prompt chaining.: Correct. Google describes breaking complex tasks into subtasks, and in a sequential chain the output of one prompt becomes the input of the next.
Role prompting.: Incorrect. Role prompting sets who the model is acting as; it does not split a task into linked steps.
Aggregating parallel prompts.: Incorrect. Parallel prompts suit subtasks that need no particular order; these steps depend on each other.
Answer: B
Q6medium
A retailer’s input patterns change after a seasonal promotion, and errors increase. Which response best follows lifecycle management?
A.
Assume the newest model will fix the problem without evaluation.
B.
Reuse the old result as proof that the new inputs are handled.
C.
Investigate the change, reevaluate, and control any replacement.
D.
Rename the version and preserve its old acceptance status.
Show answer & explanation
Correct Answer: C
Assume the newest model will fix the problem without evaluation. — Incorrect: Recency does not establish that the diagnosed failure is fixed.
Reuse the old result as proof that the new inputs are handled. — Incorrect: The original evaluation may not represent the changed inputs.
Investigate the change, reevaluate, and control any replacement. — Correct: Observed changes call for evidence and managed iteration.
Rename the version and preserve its old acceptance status. — Incorrect: A name change supplies no new behavioral evidence.
Answer: C
Q7medium
An agent's tool fails because the pre-built API it calls was never switched on in the project. What does Google say is required?
A.
Move the agent from Cloud Run to Cloud SQL.
B.
Store the API key in a Cloud Storage bucket.
C.
Enable the API for the project, found via the API Library.
D.
Replace the function with an extension.
Show answer & explanation
Correct Answer: C
Move the agent from Cloud Run to Cloud SQL.: Incorrect. Cloud SQL is a database, not a place to run an agent, and moving does not enable an API.
Store the API key in a Cloud Storage bucket.: Incorrect. Cloud Storage holds objects; the documented requirement is enabling the API for the project.
Enable the API for the project, found via the API Library.: Correct. Google says an API not enabled by default must be enabled for your project, and to use the API Library to discover APIs.
Replace the function with an extension.: Incorrect. Extensions are deprecated and do not change whether an API is enabled.
Answer: C
Q8hard
A warehouse system improves its picking routes by trying them, timing each run and favouring what finished fastest. Which approach is this?
A.
Supervised learning, since each route is labeled fastest.
B.
Reinforcement learning, learning by trial and error from rewards.
C.
Unsupervised learning, since routes form clusters.
D.
Generative AI, since it creates new routes.
Show answer & explanation
Correct Answer: B
Supervised learning, since each route is labeled fastest.: Incorrect. No labeled examples exist beforehand; supervised learning requires labeled datasets.
Reinforcement learning, learning by trial and error from rewards.: Correct. Google describes reinforcement learning as an agent learning optimal behavior through interaction with its environment, by trial and error, receiving rewards or penalties for its actions.
Unsupervised learning, since routes form clusters.: Incorrect. Unsupervised learning finds patterns in unlabeled data; this system learns from feedback on its own actions.
Generative AI, since it creates new routes.: Incorrect. Generative AI creates new content such as text or images; learning from rewarded actions is reinforcement learning.
Answer: B
Q9easy
An employee writes the same style of weekly update every Friday. Which Gemini app feature does the exam guide name for this kind of repeatable work?
A.
A Gemini Enterprise connector to Jira.
B.
Speech translation in Google Meet.
C.
A Gem, a customized version of Gemini for repetitive tasks.
D.
A Frontline edition seat.
Show answer & explanation
Correct Answer: C
A Gemini Enterprise connector to Jira.: Incorrect. Connectors link Gemini Enterprise to third-party apps; they do not customise the Gemini app for a recurring task.
Speech translation in Google Meet.: Incorrect. Speech translation removes language barriers in calls; it does not customise a recurring writing task.
A Gem, a customized version of Gemini for repetitive tasks.: Correct. Google's Workspace Help defines a Gem as a customized version of Gemini that helps you tackle repetitive tasks or get deep expertise in new areas.
A Frontline edition seat.: Incorrect. Frontline is a Gemini Enterprise edition that limits users to provisioned agents; it is not a Gemini app customisation.
Answer: C
Q10medium
A travel site wants recommendations tailored to each visitor's past bookings, reviews and current location. Which data does Google say this uses?
A.
Only the text of the recommendations already written.
B.
Behavior, preferences, past interactions and real-time factors such as location.
C.
Only video of the destinations.
D.
Only source code from the booking system.
Show answer & explanation
Correct Answer: B
Only the text of the recommendations already written.: Incorrect. Personalization analyzes each user's behavior and preferences, not just existing text.
Behavior, preferences, past interactions and real-time factors such as location.: Correct. Google describes analyzing user behavior, preferences, reviews and past interactions for personalized recommendations, combined with real-time factors like location.
Only video of the destinations.: Incorrect. Video is not what drives personalization in Google's example; behavior and location are.
Only source code from the booking system.: Incorrect. Code generation is a different task; personalization draws on user behavior and context.
Answer: B
Q11easy
How does Google suggest finding the right number of examples for a few-shot prompt?
A.
Experiment with the number of examples
B.
Always use exactly ten examples
C.
Never use more than one example
D.
Use as many as the context window holds
Show answer & explanation
Correct Answer: A
Experiment with the number of examples — Google: "You can experiment with the number of examples to provide in the prompt for the most desired results."
Always use exactly ten examples — invents a fixed number Google does not give. Never use more than one example — ignores that, depending on the model, too few examples are ineffective. Use as many as the context window holds — risks overfitting from too many examples.
A retailer's model writes first drafts of product descriptions that staff can edit at any time. What review approach fits these low-stakes outputs?
A.
A manager approves every description first.
B.
No checks at all, because the model is accurate.
C.
Stop using the model for any customer text.
D.
Release, then monitor and collect user feedback.
Show answer & explanation
Correct Answer: D
A manager approves every description first.: Incorrect. Approval of every output is the treatment for outputs that can materially affect rights; this one cannot.
No checks at all, because the model is accurate.: Incorrect. Google still recommends safety testing and monitoring content, even where outputs are low stakes.
Stop using the model for any customer text.: Incorrect. The guidance is to match oversight to risk, not to abandon a low-risk use.
Release, then monitor and collect user feedback.: Correct. No one's rights are affected and errors are easy to correct, so Google's recommended practices — safety testing for the use case, soliciting user feedback and monitoring content — fit without approving every draft.
Answer: D
Q13medium
A telecom wants customers' problems solved in one conversation instead of several. Which measure from Google's chatbot example tracks this?
A.
Increase in the number of follow-up messages sent
B.
Decrease in the chatbot's response length
C.
Growth in the chatbot's training data
D.
Increase in the first-contact resolution rate
Show answer & explanation
Correct Answer: D
Increase in the first-contact resolution rate fits: Google lists "Increase in first-contact resolution rate (issues solved in a single interaction)."
Increase in the number of follow-up messages sent — would show the opposite of solving issues in one interaction.
Decrease in the chatbot's response length — is a style choice, not resolution in a single contact.
Growth in the chatbot's training data — is an input to the model, not an outcome measure.
A risk team's model depends on high-precision arithmetic. What does Google's TPU guidance suggest?
A.
TPUs suit it best, as they are Google's own chips.
B.
The choice of processor has no effect on such models.
C.
Only CPUs can ever run machine learning work.
D.
TPUs do not suit it; look at other processors.
Show answer & explanation
Correct Answer: D
TPUs suit it best, as they are Google's own chips.: Incorrect. Being custom-built does not make TPUs fit every workload; Google says they are optimized for specific workloads.
The choice of processor has no effect on such models.: Incorrect. Google gives explicit fit guidance for CPUs, GPUs and TPUs, so the choice matters.
Only CPUs can ever run machine learning work.: Incorrect. Google describes GPUs and TPUs accelerating machine learning workloads.
TPUs do not suit it; look at other processors.: Correct. Google lists workloads that require high-precision arithmetic among those Cloud TPUs are not suited to.
Answer: D
Q15medium
A gen AI assistant is live. Which practice does Google recommend for watching the quality of what it generates?
A.
Evaluate once before launch, then stop.
B.
Rely on latency alerts to catch bad answers.
C.
Use the model's own confidence as the quality metric.
D.
Continuously monitor output with the Gen AI evaluation service.
Show answer & explanation
Correct Answer: D
Evaluate once before launch, then stop.: Incorrect. Google recommends ongoing evaluation after deployment, because behaviour can change over time.
Rely on latency alerts to catch bad answers.: Incorrect. Latency is a service-health metric; it cannot detect an unsafe or ungrounded answer.
Use the model's own confidence as the quality metric.: Incorrect. Google points to evaluation metrics and human judgment, and warns automated metrics must align with what people think.
Continuously monitor output with the Gen AI evaluation service.: Correct. For generative AI, Google recommends using the Gen AI evaluation service to continuously monitor model output in production, with automatic metrics such as response quality, safety and grounding.
335 flashcards for spaced-repetition study. Showing 30 sample cards below.
GAIL — U1.T1.LO1 — Choose a foundation model for a business use case(5 cards shown)
Question
What does modality describe when screening a model?
Answer
The types of information the model accepts or produces, such as text, images or audio.
Question
Why should an evaluation include long inputs when the workload uses them?
Answer
Answer quality can vary with context; passing an input-size check does not measure task success.
Question
What does Google compare a model's context window to?
Answer
Short-term memory — how much the model can take in at one time.
Question
A plan depends on tuning. What must be checked about each candidate model before evaluating it?
Answer
Whether the model supports tuning at all — Google says not all models support features like tuning and distillation, so check each model's supported features when they matter.
Question
A zero-data-retention requirement meets a plan to use Grounding with Google Search. What is the conflict?
Answer
That grounding service stores logs, and there is no way to disable that storage — so the requirement screens out the feature, not just a model.
GAIL — U1.T1.LO2 — Choose a foundation model for a business use case(5 cards shown)
Question
What is a model-evaluation rubric used for?
Answer
It states the criteria used to judge responses on the intended task.
Question
Why include human judgments alongside automated model scores?
Answer
They help assess qualities and context that automated measurements may miss.
Question
What does every one of Google's evaluation methods require?
Answer
An evaluation dataset: prompt and ground-truth (ideal response) pairs that you create.
Question
Which evaluation method does Google mark as recommended, and what does it generate?
Answer
Adaptive rubrics — a unique set of pass or fail rubrics for each individual prompt in your dataset.
Question
When does a computation-based metric such as ROUGE or BLEU fit an evaluation?
Answer
When a ground truth is available — they are deterministic algorithms that score against a reference answer, so they suit tasks with one right answer.
GAIL — U1.T1.LO3 — Choose a foundation model for a business use case(5 cards shown)
Question
Which token directions need separate quantities in a token-priced estimate?
Answer
Input and output, each multiplied by its applicable rate.
Question
When does a cost comparison need refreshing?
Answer
When the workload volumes, model, configuration or applicable rates change.
Question
What is Google's rule for choosing among models that pass the screen?
Answer
Choose the most affordable model that still meets your response quality and latency requirements.
Question
Name the two ways Google says generative models can be metered and charged.
Answer
By the number of input and output tokens, or by the node hours used while the model is deployed.
Question
How can tuning lower a model's serving cost and latency, according to Google?
Answer
Through shorter prompts: the long instructions and few-shot examples move into the tuned model, so every request carries less.
GAIL — U1.T2.LO1 — Understand AI concepts and learning approaches(5 cards shown)
Question
How are machine learning and artificial intelligence related?
Answer
Machine learning is a subfield of artificial intelligence.
Question
What distinguishes a generative task from assigning an existing category?
Answer
The generative task creates content rather than only selecting a category.
Question
What does Google's glossary say natural language processing teaches computers to do?
Answer
To process what a user said or typed, using linguistic rules.
Question
What does natural language processing use to reveal the structure and meaning of text?
Answer
Machine learning — Google's NLP page says NLP uses machine learning to reveal the structure and meaning of text.
Question
Per Google, what does generative AI do with the patterns it learns from data?
Answer
It uses them to produce entirely new, original content based on prompts — after learning patterns from data such as text, images and code.
GAIL — U1.T2.LO2 — Understand AI concepts and learning approaches(5 cards shown)
Question
What makes a foundation model useful as a starting point?
Answer
It provides a broadly trained base that can be customized for tasks.
Question
What process does a diffusion model learn to reverse?
Answer
A process that adds noise to data.
Question
How does Google's glossary describe a large language model, at a minimum?
Answer
A language model having a very high number of parameters.
Question
What makes a model multimodal, in the glossary's definition?
Answer
Its inputs, outputs, or both include more than one modality — so the label alone does not say which input and output pairs it supports.
Question
Besides responding well to a wide range of requests, what can a foundation model serve as?
Answer
A base model for additional fine-tuning or other customization — it is very large and pre-trained on an enormous, diverse training set.
GAIL — U1.T2.LO3 — Understand AI concepts and learning approaches(5 cards shown)
Question
What changes when an author performs prompt engineering?
Answer
The instructions or context in the prompt sent to the model.
Question
What does model fine-tuning adapt beyond rewriting an instruction?
Answer
A further task-specific training pass refines the pretrained model parameters.
Question
What does prompt tuning learn, and what does it prepend it to?
Answer
A prefix (a soft prompt), which the system prepends to the actual prompt.
Question
How much of a model does parameter-efficient tuning update?
Answer
A relatively small subset of the model's parameters — unlike full fine-tuning, which updates all of them.
Question
In what order does Google recommend prompting and fine-tuning?
Answer
Start with prompting to find the optimal prompt; then fine-tune, if required, to boost performance or fix recurrent errors.
Flowchart, left to right. Business requirement connects to Takes and returns<br/>the modalities needed?. M -- no connects to Out. M -- yes connects to Fits the context<br/>the task needs?. C -- no connects to X. C -- yes connects to Supports required<br/>features, such as tuning?. F -- no connects to X. F -- yes connects to Data controls and<br/>availability meet policy?. D -- no connects to X. 1 more statements.
Loading Diagram...
Flowchart, left to right. Evaluation dataset<br/>prompts + ideal responses connects to Define metrics. M connects to Generate responses<br/>from each candidate. G connects to Run the evaluation. R connects to Interpret scores and<br/>individual responses. I connects to G (adjust prompts, then re-run).
Loading Diagram...
Flowchart, left to right. Training data connects to Noisy data (add noise step by step). N connects to Learned reverse process (learn to reverse). R connects to New, realistic output (apply iteratively).
Loading Diagram...
Flowchart, left to right. Design and refine<br/>the prompt connects to Meets the bar on<br/>your evaluation?. E -- yes connects to Ship the prompt. E -- no connects to Tune: parameter-efficient<br/>or full fine-tuning. T connects to E.
Loading Diagram...
Flowchart, left to right. Ingest<br/>the data connects to Prepare<br/>the data. P connects to Train and<br/>evaluate. T connects to Deploy a<br/>chosen version. D connects to Monitor and<br/>manage. M connects to Ingest<br/>the data"] --> P["Prepare<br/>the data (drift or decay detected).
Loading Diagram...
Flowchart, left to right. Measurable business goal<br/>and success criteria connects to Generative AI,<br/>other AI, or no AI?. A connects to End users and how<br/>they will interact. U connects to Process and<br/>workflow changes. P connects to Measure against<br/>the criteria.
Loading Diagram...
Flowchart, left to right. Historical customer data<br/>(structured) connects to Traditional AI:<br/>churn probability. T connects to Prompt includes<br/>the prediction. P connects to Generative chatbot:<br/>explore in plain language. Behavior and<br/>preferences connects to Personalized<br/>recommendations.
Loading Diagram...
Flowchart, left to right. Example with a<br/>missing value connects to Enough complete<br/>examples remain?. Q -- yes connects to Delete the<br/>incomplete example. Q -- no connects to Impute: a well-reasoned<br/>guess for the gap. D connects to Train on<br/>complete examples. I connects to T. Automation flags<br/>unreliable data connects to Example with a<br/>missing value"] --> Q{"Enough complete<br/>examples remain?.
Loading Diagram...
Flowchart, left to right. Labeled examples<br/>features + label connects to Train and<br/>evaluate. T connects to Trained model. New unlabeled data<br/>features only connects to M. M connects to Predicted label.
Loading Diagram...
Flowchart, left to right. Goal from<br/>a user connects to Reason and plan<br/>with the model. R connects to Act through<br/>a permitted tool. A connects to Observe<br/>the result. O connects to R (not done). O connects to Report back<br/>for review (done).
Loading Diagram...
Flowchart, left to right. Business job connects to Must it run on your<br/>own hardware or device?. O -- yes connects to Gemma. O -- no connects to What must<br/>it produce?. P -- video connects to Veo. P -- images connects to Gemini image model;<br/>Imagen for its strengths. P -- text, code, analysis connects to Gemini.