Core concepts of AI agents - Startup technical guide: AI agents - en

[Music] The world of AI agents is exploding, but

for people actually trying to build them, it can feel well, a bit like a

maze. So, our mission today is to try and map out Google Cloud's approach

here. How do you actually go from an idea to a productionready agent? What

makes them smart, reliable, and able to tackle complex stuff? Okay, fascinating.

Let's dive in then. So, where do you even start if you want to build these

things on Google Cloud? You mentioned paths,

>> right? Think of it like three main pathways. You can build your own agents,

you can use Google cloud agents, or you can bring in partner agents.

>> Each one offers a different balance, you know, between control and speed. Depends

what you need. >> Let's start with build your own. Sounds

like the deep end. Maximum customization.

>> That's the idea. If you need agents tailored for very specific, maybe unique

tasks, this is your route. And even within this, you've got choices. a code

first way for total control or an application first way that's faster

especially if you're not a coder >> code first that brings us to the agent

development kit the ADK >> okay so the ADK it's designed to be

flexible modular open and importantly LLM agnostic it's really built for

developers for technical teams who need fine grain control it fits right into

standard software development practices it's optimized for Google cloud sure but

you can bring your own LLM your deployment strategy

>> right so that's the deep control code first route. But what if you need to

deploy like an entire AI workforce across the company and maybe the people

doing it aren't developers? >> Ah yeah that's a totally different beast

and that's where Google agent space comes in. It's not code first like ADK.

It's a platform designed to orchestrate a whole fleet of AI agents and crucially

it empowers non-technical folks with a noode designer. Plus, there's a library

of pre-built agents for common complex tasks like doing deep market research.

And that noode agent designer is key. It's basically a prompt-driven way to

build agents. Your marketing team could build an agent to pull insights from CRM

and social media without writing code. >> Okay, that covers building your own.

What about pathway two? Use Google Cloud agents leveraging Google's own pre-built

powerhouses. >> Look, what kind of agents are we talking

about? >> Think Gemini Code Assist. That's the AI

pair programmer, right? Plugs into your IDE, helps with code completion,

debugging, even refactoring across multiple files,

>> boosts developer productivity. >> Exactly. Or there's Gemini Cloud Assist.

That's like having an AI expert for your Google Cloud setup, helping design

infrastructure, troubleshoot problems, optimize costs, all contextaware,

>> useful. And I think there's one for Collab, too.

>> Yeah, Gemini and Collab Enterprise turns your notebooks into collaborative AI

workspaces. Okay. So, build or use Google's. What's the third option?

>> The third path is to bring in partner agents. You can grab third-party or even

open-source agents from places like Google Cloud Marketplace or the agent

garden and just integrate them into your existing stack.

>> Maximum flexibility there. Mixing and matching.

>> Exactly. Choose the best tool for the job wherever it comes from.

>> All right. So, we've got the how to get one sorted. Build, use, or partner.

>> Now, let's get into the guts of an agent. If you pop the hood, what are the

essential building blocks? >> Okay, first absolutely central is the

model. That's the agent's brain. It's the large language model like Gemini

that understands the request and figures out what to say or do.

>> And choosing the right model matters, I assume

>> big time. It's a trade-off. You might use something like Gemini 2.5 Flash if

you need speed and low cost for high volume tasks. But for really complex

multi-step reasoning, you might need the power of Gemini 2.5 Pro.

>> Right? Capability versus speed versus cost. Fine tuning adapts a model's style

or persona, maybe teaches it specific jargon for your company. It adjusts how

it responds based on its training. >> But grounding is about connecting the

model to external verifiable facts. It's about ensuring the answers aren't just

plausible sounding, but are actually based on real-time accurate information

outside the models original training data. It prevents those uh

hallucinations. >> Got it. So fine-tuning is personality.

Grounding is truthfulness essentially. Very important. How does an agent do

things? >> That's where tools come in. Tools are

specific capabilities you give the agent. They're like function calls that

let it interact with the outside world. Call an API, query a database, access a

document, even trigger another agent. >> So without tools, the model can think,

but it can't act. >> Pretty much tools bridge the gap between

reasoning and action. >> Who's coordinating all this? The

executive function. >> That's agent orchestration. This is the

logic that guides the agent through a task, especially if it takes multiple

steps. It decides which tool to use when, in what order, and how to combine

the results to reach the final goal. >> How does that work in practice?

>> A really common pattern you'll see is react. Stands for reason plus action.

The agent thinks about the problem, reasons, decides on an action like

calling a tool, performs the action, sees the result, observes, and then

reasons again based on the new info. Can you give an example?

>> Sure. Imagine processing a customer refund. The agent might first reason

about the request, then act by calling a CRM tool to get the purchase date. It

observes the date, then reasons again based on your return policy, maybe

checks inventory with another tool action, and finally acts to process the

refund via a payment API. >> Right? That's stepby-step think then do

loop. I can see how that gives small teams a lot of leverage.

>> Absolutely. It automates complex sequences.

>> Okay, final piece. getting this agent out there reliably.

>> That's the runtime. This is about deployment. Moving from a prototype on

your laptop to something that runs reliably, securely, and at scale in

production. >> What are the options there?

>> Well, Vertex AI has something called the agent engine. It's specifically designed

for this, a fully managed service for deploying and scaling agents, especially

those built with things like the ADK. It handles autoscaling, security, all that.

>> Managed is nice. Otherwise, >> sure you could use Cloud Run for

serverless deployment or if you need really deep control over the

architecture, Google Kubernetes Engine, GKE, is always an option,

>> right? So, we've built this agent. It has a brain, tools, orchestration. It's

running. But back to that trust point. How do we really make sure it's giving

good grounded answers? >> Great question. This is where grounding

techniques become critical. The foundational step is usually retrieval

augmented generation. >> What is it simply? Simply put, before

the LLM generates an answer, it look up relevant information from an external

trusted knowledge source like your company's internal docs, product specs,

support articles. It often uses vector databases to do this search based on

meaning semantic search, not just keywords.

>> Ah, so it fetches relevant facts first, then writes the answer based on those

facts. >> Exactly. So if a customer asks about

shoes for white feet, the agent doesn't guess. It retrieves the actual product

info that matches that semantic meaning and bases its recommendation on that.

The info is current and verifiable. >> Much better than just relying on old

training data. Are there more advanced forms?

>> Definitely. You've got graph rag instead of just finding text snippets that seem

related. It uses a knowledge graph to understand actual relationships between

data points. Think uh for medical diagnosis knowing symptom A is caused by

condition B which is treated by medicine C. It's about structured understanding.

her connections. >> It's about making agents not just

knowledgeable but resourceful and trustworthy problem solvers like that

real-time inventory check example. Identify product trigger check inventory

function via a tool. Give immediate accurate stock level. That's agentic

action grounded in real data. >> Okay, let's try and summarize this for

you the listener, the founder, the developer. What are the key takeaways

here? >> Well, first know your paths. Build it

yourself with ADK or agent space. Use Google's pre-built agents like Gemini

Code or Cloud Assist or bring in partners. They can all work together

thanks to protocols like MCP and A2A. >> Right. Second, understand the core

parts, the model brain, the tools, the orchestration like Reacts, the

Executive, and the runtime deployment like agent engine.

>> Third, and maybe most critical for production. Grounding is key for trust.

mastering these concepts, thinking about grounding and tools from the start.

That's how you move from cool demos to genuinely intelligent, reliable,

productionready systems. It's not just good practice. It's really a competitive

advantage. >> Building something defensible.

Automating smartly makes sense. So, if people want to take the next step,

>> there's more content available. Check out the ondemand startup school sessions

and definitely look into the Google for startups cloud program. You could get up

to $350,000 USD in cloud credits, plus expert help.

>> Fantastic. We'll put links to all of that in the show notes. Definitely worth

exploring to kickstart your own agenting journey. Thanks for breaking that all

down. >> My pleasure. Lots of exciting potential

here. [Music]