Let Me Ask You Something

In the last post, we saw that AI agents work in a loop:

Think → Decide → Use Tool → Get Result → Repeat

That made sense.

But once I understood that loop…

one question immediately started bothering me:

If the AI can use tools… who decides what happens next?

Because the AI doesn't just magically know the order.

Something has to be in charge.

Let's Make It Concrete

Imagine you ask an AI agent:

"Research the top AI startups and give me a summary."

Now think about everything that needs to happen:

Step 1 → search the web
Step 2 → collect the results
Step 3 → summarize them
Step 4 → format the output
Step 5 → return the final answer

Each step depends on the previous one.

• If step 2 fails → step 3 shouldn't run

• If step 1 returns nothing → the agent should retry or stop

Something has to manage all of this.

That something is:

👉 orchestration

The Simplest Way To Think About It

Forget the technical word for a second.

Think of it like this:

AI model       = worker
Tools          = hands
Orchestration  = manager

The manager doesn't do the actual work.

It decides:

• what runs next

• in what order

• what to do if something fails

• when the job is finished

🚨 The Part That Surprises Most People

Here's the thing almost no one explains clearly:

Orchestration is not intelligence.

It's coordination.

That's a BIG difference.

The AI model does the thinking.

Orchestration just makes sure the right things run at the right time.

Why This Matters

Because some orchestration layers are:

• rule-based

• deterministic

• fully structured

They don't use an AI model at all.

They just follow a fixed flow:

Step 1 → Step 2 → Step 3 → Done

That's still orchestration.

🤯 What Really Changed My Perspective

Not everything inside an AI agent system is actually "AI."

Some parts are just:

• rules

• workflows

• structured logic

• control systems

Meaning:

The thing coordinating everything might not even be an AI model.

It can just be a system that says:

"Run this. Then this. Then stop."

No reasoning. No chat. No intelligence.

Just coordination.

And honestly — that realization changes how you see agents completely.

🔧 What Does Orchestration Actually Look Like?

In practice, it's often just this:

results = search_web()
summary = summarize(results)
send_email(summary)

That code is deciding sequence, dependencies, and flow.

No AI. No magic.

That logic = orchestration.

Or think of it visually — three agents connected:

[Search Agent]
      ↓
[Summarizer Agent]
      ↓
[Email Agent]

Something has to connect them, pass data between them, and decide what happens if one fails.

That connecting layer = orchestration.

Frameworks like Google ADK just give you a cleaner way to define that same flow — without writing all the retry, branching, and stop logic yourself every time.

The Mental Model Shift

Most people imagine AI agents like this:

One giant AI brain
→ does everything
→ controls everything

But the real picture looks more like this:

Worker  → does tasks (AI + tools)
Manager → decides what happens next (orchestration)
System  → executes everything

Different roles.

Different responsibilities.

The more you learn about agents… the less they feel like one super-intelligence and the more they feel like systems working together.

🔍 What Orchestration Actually Does

Let's make it very concrete.

Orchestration handles:

Sequencing

Run step 1 → then step 2 → then step 3

Branching

If search works → summarize If not → retry

Retrying

Tool failed → try again

Stopping

Task complete → return result

Parallelism

Run multiple steps at the same time

That last one is important.

Because it means:

systems can become faster without making the AI smarter.

🧩 Why Frameworks Like Google ADK Exist

Once you understand orchestration…

frameworks start making sense.

Because managing:

• multiple tools

• multiple steps

• retries

• failures

…quickly becomes messy.

Frameworks help you:

build and manage orchestration without chaos.

🗺️ The Full Picture So Far

Now everything we've learned connects:

You (user)
↓
Orchestration  ← decides flow
↓
AI model       ← thinks
↓
Tools          ← act
↓
Execution      ← runs tools
↓
Results
↓
Orchestration  ← continue? retry? stop?

Notice something important:

Orchestration is not just one step.

It wraps the entire system.

💡 One Line Worth Remembering

Orchestration is the layer that decides what happens next.

⏭️ What Comes Next

So far we've covered:

• ✅ What AI agents are

• ✅ How tools work

• ✅ How decisions are made

• ✅ What orchestration does

But now a bigger question appears:

If orchestration can coordinate steps… can it also coordinate multiple AI agents?

Continue Reading

← Previous: How AI Agents Actually Work (What’s Really Going On Behind the Scenes)

Part of the AI Agents series · TechAngles AI Hub.

Let Me Start With Something You've Probably Already Seen

You type something like:

"fix this bug"

And then… you stop.

You don't keep typing.

You just watch.

It reads your code. Changes something. Runs it. Fails. Tries again.

And after a few seconds… it works.

Most people just think:

"nice… it fixed it."

But if you pause for a second, there's a strange question hiding there:

What is actually happening behind the scenes?

Because this doesn't feel like:

• a normal chatbot
• or a simple answer

It feels like something is doing work step by step.

The Mental Model Most People Have

At first, I assumed something like this:

One super smart AI
→ understands everything
→ decides everything
→ does everything

Basically:

one giant brain doing the entire job.

Sounds reasonable.

But That's Not What's Actually Happening

Once you start digging a little deeper, the picture changes.

A lot.

Because real AI agents don't look like one thing.

They look more like this:

Brain (AI)
↓
Decision layer
↓
Tools
↓
Execution system
↓
Results
↓
Repeat

Not one thing.

A chain of parts working together.

🔍 Let's Break This Down (Without Making It Complicated)

Forget fancy terms for a second.

Here's the simplest way to think about it:

🧠 1. The Brain (AI Model)

This is the part you already understand.

It reads your request and thinks:

"what should happen next?"

⚙️ 2. The Decision Layer

This part is subtle… but really important.

Instead of replying with normal text, the AI sometimes outputs something like:

{
  "tool": "search_web",
  "input": "AI startups 2026"
}

That's not a sentence.

That's an instruction.

This is the moment where:

thinking turns into action.

🤲 3. The Tools (The "Hands")

These are the actual things that can do work:

• search the web
• open a file
• run code
• call an API

AI = brain tools = hands

🚨 4. The Part Most People Miss

Here's the important twist:

The AI does NOT run the tools.

It only asks.

Something else runs them.

🔄 What Actually Happens

Let's say you ask:

"Find top AI startups"

Here's the real flow:

Step 1 → AI thinks
          "I should search the web"

Step 2 → AI sends a tool call
          { tool: "search_web" }

Step 3 → Your system runs it

Step 4 → Results come back

Step 5 → AI continues

That's it.

That's the "magic."

👁️ If You Step Back… Something Interesting Appears

At this point you can already see something:

This is not just "AI answering questions."

This is:

👉 a system passing work between different parts

And once you see that…

you can't unsee it.

🧩 And Then Something Bigger

The more I looked into this, the more the idea of:

"one AI doing everything"

started to fall apart.

Because in real systems, different parts can be:

• different models
• different tools
• different pieces of code
• even separate services

For example:

• One model talks to the user
• Another model decides which tool to use
• Your backend executes the action
• Another layer controls the flow

That's not one AI.

That's a system.

🎯 So What's Actually Running The Whole Thing?

Something has to decide:

• what happens next
• whether to call a tool
• whether to retry
• when to stop

That "something" is what people call:

👉 orchestration

Ignore the fancy word for now.

Think of it like this:

It's the part that keeps everything moving.

Like a coordinator behind the scenes.

A Simple Way To See It

If the AI can think and use tools, orchestration decides:

what step runs next
what order things happen in
what to do if something fails
when the job is finished

❓ And This Is Why Frameworks Exist

At this point, you might wonder:

"Why do we even need frameworks like Google's ADK?"

Because once you try to coordinate all these moving parts yourself…

you realize very quickly:

it gets messy. Fast.

Frameworks exist to handle the coordination so you don't have to rebuild it every time.

🗺️ The Cleanest Way To See The Whole System

If we simplify everything, it becomes:

You (user)
↓
AI (brain)
↓
Tool decision
↓
Tool call
↓
Execution system
↓
Result
↓
AI continues

That's the loop.

💡 The Big Shift

At the start, it feels like:

"AI is doing everything."

But now it becomes:

"AI is one part of a system doing the work together."

🎯 One Line Worth Remembering

An AI agent is not one thing. It's a system where different parts work together to get something done.

⏭️ What Comes Next

Once you see agents this way, a new question naturally comes up:

If all these parts exist… who is actually coordinating them?

👉 Next Post: What Is Orchestration in AI Agents? (The Hidden Layer That Controls Everything)

AI can use tools.

It can:

• search the web
• run code
• open files
• call APIs

Cool.

But something still feels… missing.

Because there's one question almost nobody properly explains:

How does the AI decide which tool to use?

The Hidden Step Most People Never See

When you type something like:

"What's the weather in London?"

the AI doesn't just magically "know" what to do.

Under the hood, something more structured is happening.

Instead of replying normally, the model generates a structured tool call — essentially an instruction that says:

"Use this tool with these inputs."

The exact format varies by model and framework, but the idea is always the same: instead of plain text, the model outputs a structured action for the system to execute.

And honestly, this is the moment AI agents started making more sense to me.

Because suddenly it stopped feeling like magic.

At First, I Assumed One Giant Model Did Everything

My original mental model was basically:

"Okay… GPT probably handles everything itself."

Reasoning. Planning. Tool selection. Responses. Memory. Everything.

And to be fair, a lot of modern systems actually do work like that.

Large models from companies like OpenAI, Anthropic, and Google Gemini can often decide which tools to call directly.

But then I discovered something interesting.

Some systems use smaller, specialized models just for tool calling.

And that's where FunctionGemma comes in.

Meet FunctionGemma

FunctionGemma is a specialized version of Google's Gemma model built specifically for function calling.

Not chatting. Not storytelling. Not writing essays.

Its main job is:

Take user intent → convert it into structured tool calls.

That's it.

And honestly, I think that idea is fascinating.

Because instead of trying to make one giant model do everything…

you can split the system into smaller, focused parts.

And Here's the Wild Part

FunctionGemma is tiny compared to modern large language models.

It's built on the Gemma 3 270M parameter model.

Which sounds ridiculously small in today's AI world.

But the important realization is this:

Tool calling is actually a much narrower problem than open-ended conversation.

The model doesn't need to:

• write novels
• explain philosophy
• debate politics

It mainly needs to:

• understand intent
• choose a function
• generate structured outputs correctly

That constrained problem makes smaller specialized models surprisingly effective — especially after fine-tuning.

And the size has another huge advantage: FunctionGemma is specifically designed to run on-device — on laptops, phones, or edge hardware — without needing a server. That's a big deal for privacy and offline use.

This Completely Changed How I See AI Agents

Before this, I imagined agents like:

"One super-intelligent AI doing everything."

But now I think of them more like systems made of layers:

Main model         → reasoning and conversation
Tool-calling layer → converts intent into actions
Tools / APIs       → actually perform the work
Orchestration      → manages the loop, retries, and flow

Almost like:

Brain → Decision Layer → Hands

And suddenly agents feel a lot less mystical. And a lot more understandable.

So What Actually Happens in an Agent?

At a very basic level, the loop is surprisingly simple.

User says:

"Search AI startups"

The system generates a structured tool call, something like:

tool: search_web
query: "AI startups"

Then:

1. The backend executes the tool
2. Gets the results
3. Sends them back to the model
4. The model continues

Think → Call tool → Get result → Continue

That's the core loop.

Real Agents Add More Layers

Of course, production agents usually become much more complex.

They may include:

• memory
• retries
• validation
• planning
• permissions
• context management
• error handling

But the important thing is: the core idea is still understandable.

And honestly, that realization made AI feel way more approachable to me.

One Important Thing Most People Miss

FunctionGemma is not really meant to be dropped in "as-is" as a universal agent model.

Google actually positions it as a foundation for fine-tuning.

Meaning:

• You define your own tools
• Train it on your own examples
• Improve its reliability for your specific use case

So instead of:

"one AI that knows everything"

you get:

"a small, specialized model trained for your specific workflows"

That's a very different philosophy. And the benchmark numbers back it up — the base model scores 58% on Mobile Actions tasks. After fine-tuning? 85%.

And Honestly… I Think This Is Where AI Is Heading

The more I learn about agents, the more it feels like modern AI systems are becoming modular.

Instead of one massive model doing everything, we're starting to see:

• routers
• planners
• memory systems
• verification models
• specialized tool-callers
• local edge models

Smaller parts working together.

And weirdly… that makes the whole field feel less intimidating.

What I'm Doing Next

So instead of only reading about agents…

I want to build one myself.

A small one. From scratch. Nothing insane.

Just:

• a few tools
• a simple loop
• tool-calling logic
• structured outputs
• backend execution

And I'll document the whole process here as I learn.

One Line Worth Remembering

AI agents are not just "one giant AI." They're systems made of smaller parts. And sometimes… the part deciding what action to take next can be surprisingly small.

An agent = AI that keeps trying

But that brings up a fair question.

How does it actually do anything?

How does it open a file? Search the web? Run code and check if it worked?

The answer is one word: tools.

Start With What You've Already Seen

When you type "fix this bug" in Cursor or Claude OR any code editor with AI, it doesn't just write back a reply.

It opens your file. Changes something. Runs it. Checks if it worked.

It's not just thinking. It's doing things.

That's tools in action — you just didn't know that's what it was called.

So What Is a Tool?

A tool is just something the AI can use to do a real action.

Not think about it. Not describe it. Actually do it.

Search the web → that's a tool. Open a file → that's a tool. Run some code → that's a tool.

A tool can be anything that helps the AI achieve its goal. it can even be a simple function that returns a value. it can also be a complex function that does multiple things. it can be a python script. also can can be a software application that does multiple things.

Each one lets the AI reach outside the conversation and do something in the real world.

What Does It Look Like Under the Hood?

If you're curious about the technical side, here's a quick look.

A tool isn’t the command itself — it’s a capability the AI is allowed to use (like a function or API).

When the AI wants to use a tool, it sends a tool call — a structured request that says: "Use this tool with these inputs."

For example:

• Tool → search_web
• Tool call →

{
  "tool": "search_web",
  "input": "top AI startups 2026"
}

The system runs that tool, and the result comes back:

["OpenAI", "Anthropic", "Perplexity"]

Now the AI has real information to work with — not something it made up.

Same idea when it fixes your bug:

• read_file("app.py") → looks at your code
• write_file("app.py", ...) → makes a change
• run_code("app.py") → tests if it works

That’s the whole “magic” behind tools like Cursor — it’s just AI using tools, one step at a time.

The Simple Way to Think About It

• AI = the brain — decides what needs to happen
• Tools = the hands — actually make it happen

Without tools, the AI can only talk. With tools, it can actually do things.

But Here’s the Part Most People Don’t Know

You might think the AI is the one running the tools.

It’s not.

The AI asks. Something else does the actual execution.

Here’s how it really works:

Step 1 — The AI decides what it needs “I need to search the web.”

Step 2 — It sends a tool call A structured request instead of normal text:

{
  "tool": "search_web",
  "input": "top AI startups 2026"
}

Step 3 — Your app runs the tool Cursor, Claude, or your backend executes it.

Step 4 — The result comes back

["OpenAI", "Anthropic", "Perplexity"]

Step 5 — The AI continues It uses the result, decides the next step, and keeps going.

Why Does It Work This Way?

Because it keeps you in control.

The AI can only use the tools you give it. If a tool doesn’t exist, it simply can’t use it.

That’s why well-built agents feel safe — they’re limited by design.

One Line to Remember

A tool is a capability the AI can use — and a tool call is how it asks to use it. Your system is the one that actually runs it.

Now Think About This

If you could give an AI agent any tools you wanted:

• What would you connect to it?
• What tasks could it fully take off your plate?

Next up: How AI Agents Actually Work (Simple Architecture)

Have you used Cursor? Claude? GitHub Copilot?

If yes — you've already used an AI agent. Nobody just never told you that.

Let me show you what I mean.

That Moment When You Just... Watched

You type something like:

"fix this bug"

And then you stop. You lean back. You watch.

It reads your code. Changes something. Tries to run it. It fails. It tries again.

Most people see this and just think — "cool, it's helping me."

But something bigger is going on there.

That's not just a chatbot giving you an answer. That's something doing the work.

That's an AI agent.

So What Is an AI Agent?

Here's the simplest way I can put it:

An AI agent is AI that doesn't stop after one answer. It keeps going.

That's really it.

The difference is just this loop:

Think → Do → Check → Try again

A normal chatbot stops after step one. It thinks, gives you an answer, and waits for you to do the rest.

An agent keeps going — it does something, checks if it worked, and tries again if it didn't.

Side by Side — Chatbot vs Agent

Chatbot:

• You ask → it answers → done.

Agent:

• You give it a job → it works → checks if it's done → keeps working → until it's finished (or gets stuck).

Without that loop, you're just talking to a very smart search engine. With it, you have something that can actually try to get things done.

A Real Example: "Fix the Login Error"

Say you ask an AI tool to fix a login bug in your app.

A chatbot gives you a list of things that might be wrong. Good info — but you're still the one who has to fix it.

An agent opens your code. Changes something. Runs it. Sees the error. Tries a different fix. Runs it again.

You asked once. It kept going on its own.

That's why Cursor feels different from just asking ChatGPT a question in a browser tab. One gives you answers. The other actually does the work.

The Thing Most People Get Wrong

When people hear "AI agent," they picture AI running free — doing whatever it wants with no one watching.

That's not how it works.

Good agents are kept within clear limits:

• They can only use certain tools

• They can only do certain things

• A person (or another system) keeps an eye on what they do

Giving an agent too much freedom doesn't make it better. It usually makes it worse. The best agents are kept focused — one job, clear rules, and they know when to stop.

Why This Actually Matters

Old software waited for you. Every single step needed you to tell it what to do next.

Now, software can try to finish a job on its own — even if it gets it wrong the first time.

That's a real change. Not hype. You've already seen it — every time you walked away from Cursor and came back to find the bug fixed.

Here's the question worth thinking about:

If AI can try, fail, and try again on its own — what tasks would you stop doing yourself?

The One Line to Remember

An AI agent is just AI that doesn't stop.

Continue Reading

→ Next: What Is a Tool in AI Agents?

Part of the AI Agents series · TechAngles AI Hub.