Imagine this.

You wake up one morning and discover you are the smartest person on Earth. You can solve any math problem, write any story, explain any idea in twelve languages. There is just one catch. You are locked in a small white room. No phone. No computer. No pen. No paper. No window. No door handle on your side.

Someone slides a question under the door: “What’s the weather in Tokyo right now?”

You are the smartest person in the world. And you have no idea. You can think about Tokyo. You can recite facts about its climate from things you read years ago. But you cannot check. You cannot do. You are pure brain, with nothing to push against.

That is what a large language model is, all by itself. A genius in a locked room.

Now imagine someone slides a phone under the door. Suddenly you can look things up. Then a laptop. Now you can send emails. Then a set of keys. Now you can leave the room and walk into the world.

Each new object made you more powerful — not because you got smarter, but because you got connected. The smart part was already there. The tools turned thinking into doing.

That is what this chapter is about. Tools are what turn an AI from a brain in a jar into something that can actually help you.

Back to Ava

Remember Ava’s morning from Chapter 1? Her phone moved her alarm because the school schedule changed. Think about everything that little action required.

The agent had to read the family calendar. It had to check the school’s website for the schedule update. It had to change the alarm app. Three separate systems. Three different places where information lived.

The agent’s brain — the language model — couldn’t do any of that on its own. A language model, by itself, only does one thing: it reads text and writes text back. That’s it. It cannot click a button. It cannot open an app. It cannot peek inside a database. It cannot send an email.

So how did Ava’s alarm move?

The agent had tools.

What Is a Tool, Really?

A tool is anything outside the AI’s brain that the AI can use to interact with the world.

That sounds fancy, but the examples are simple. A tool can be:

• A web search (so the agent can look things up)
• A calendar app (so the agent can see your schedule)
• An email account (so the agent can send a message)
• A database (so the agent can pull up customer info)
• A file folder on your computer (so the agent can read or write documents)
• A calculator (so the agent can do math precisely, instead of guessing)
• A code runner (so the agent can write a program and actually run it)
• Even another AI agent (so it can ask a teammate for help)

Tools are external capabilities. The agent’s brain decides what to do. The tools let it actually do the thing.

Think of it like cooking. A great chef in an empty kitchen can imagine a fantastic meal, but she can’t make it. Give her a knife and she can chop. Give her a stove and she can cook. Give her a phone and she can order ingredients. Every tool unlocks a new kind of action.

Senses and Hands

Here’s another way to picture it. An agent without tools is like a person with no senses and no hands. Pure thought, floating in the dark.

Tools give the agent senses:

• Eyes — a database tool lets the agent “see” the customer records
• Ears — an API tool lets the agent “hear” what another service is telling it
• A nose for trouble — a monitoring tool lets the agent sniff out errors

Tools also give the agent hands:

• Hands that type — to send an email or post a message
• Hands that click — to book a flight or buy a ticket
• Hands that build — to write code, edit a document, update a file

When you put eyes, ears, and hands together with a smart brain, you get something that can actually act. That’s the recipe for an agent.

The Adapter Problem

Now here’s where things got messy, very fast.

When developers first started giving AI agents tools, every company built its own way of plugging tools in. Anthropic had its way. OpenAI had its way. Google had its way. Every tool — Gmail, Slack, Dropbox, GitHub — had to be wired up separately for each AI.

Imagine if every electronic device in your house used a different kind of charger. Your phone had a square plug. Your tablet had a triangle. Your headphones needed a star-shaped one. Your laptop needed a pentagon. You’d have a drawer full of adapters and you’d lose your mind.

That was the AI world in early 2024. Every connection had to be hand-built. Developers were reinventing the same plug, over and over, in slightly different shapes.

Someone needed to invent the USB port for AI.

MCP: The USB Port for AI

On November 25, 2024, Anthropic — the company that makes Claude — announced something called the Model Context Protocol, or MCP for short (Anthropic, 2024).

MCP is, in plain English, a shared rulebook for how AI agents plug into tools. It’s an open standard, which means anyone can use it, anyone can build with it, and nobody has to pay a fee or ask permission.

Here’s why having one standard matters so much. Imagine you build a Gmail tool. Without a standard, you’d have to build a different version for Claude, a different version for ChatGPT, a different version for Gemini, and a different version for every new AI that comes along. That’s a lot of wasted work.

With MCP, you build the Gmail tool once. Any AI that speaks MCP can use it. Same plug, same port, every time.

The idea caught on shockingly fast. By March 2025, OpenAI — Anthropic’s biggest rival — announced its products would support MCP too (Pento, 2025). Google followed a month later, saying Gemini would speak MCP as well (Pento, 2025). By late 2025, MCP was on Claude, ChatGPT, Gemini, Microsoft Copilot, Cursor, Windsurf, and Visual Studio Code. Anthropic reported more than 10,000 active public MCP servers by the time the protocol was donated to the Linux Foundation (Anthropic, 2025). One public directory, mcp.so, listed more than 17,000 by early 2026.

Few brand-new tech standards have ever spread that fast. In one year, MCP went from a single company’s idea to the way nearly every major AI talks to nearly every major tool.

A2A: When Agents Call Agents

MCP solves one problem — how agents talk to tools. But there’s a second problem. What happens when one agent needs to talk to another agent?

Say you have a personal-assistant agent that handles your calendar. Your boss has a meeting-scheduler agent that books conference rooms. Your assistant needs to ask the scheduler, “Hey, is the big room free Tuesday at 2?”

If those two agents can’t talk to each other, you’re back to copying and pasting between apps.

On April 9, 2025, Google announced a protocol for exactly this: Agent2Agent, or A2A (Google Developers Blog, 2025). If MCP is the USB port between agents and tools, A2A is the telephone line between agents and other agents.

A2A lets agents introduce themselves (using something called an “Agent Card” that lists what each agent can do), hand off tasks, and report back when they’re done. Agents made by different companies, running on different servers, can now place phone calls to one another and get work done together.

Who’s in Charge Now?

Here’s a part that changed after these protocols first appeared.

For most of 2025, MCP was run by Anthropic, and A2A was run by Google. But both companies eventually decided these standards were too important to belong to any single business. So both protocols were handed over to a neutral, nonprofit caretaker.

Protocol	What it does	Created	Donated to a neutral home
MCP	Connects agents to tools	Anthropic, Nov 2024	Agentic AI Foundation (under the Linux Foundation), Dec 2025
A2A	Connects agents to other agents	Google, Apr 2025	Linux Foundation, Jun 2025

Both protocols now live under the Linux Foundation, the nonprofit behind Linux, the software that runs most of the internet’s servers. MCP specifically joined a new sub-project there called the Agentic AI Foundation, founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, Amazon, and others (Linux Foundation, 2025). That’s a remarkable list — rivals who normally compete on everything agreeing to share one rulebook.

For you, the user, this means something simple but important. The plugs and phone lines between AI agents and the rest of the world are now public infrastructure. Like roads. Or the electric grid. Nobody owns them. Everybody uses them.

A Quick Tour of the Toolbox

Let’s look at the kinds of tools a real agent might reach for during a single day.

Tool	What it does	Example
Web search	Looks things up online	“What’s the weather in Tokyo right now?”
Calendar	Reads and edits your schedule	Moving Ava’s alarm earlier
Email	Reads, drafts, and sends messages	Auto-replying to a customer question
Database	Pulls records from a company’s data	Finding all orders from a single customer
File system	Opens, edits, saves documents	Updating a report
Code execution	Writes and runs small programs	Doing precise math, generating a chart
Browser	Clicks through websites like a human	Booking a flight on a travel site
Another agent	Hands off part of a task	Asking the scheduling agent to find a room

Every one of those is something the language model, on its own, cannot do. Every one of those, plugged in through MCP or A2A, turns the agent from a thinker into a doer.

Why This Matters

Step back for a second. Think about what’s happening here.

A few years ago, AI was something you talked to. You typed a question. It typed an answer. End of conversation. Useful, but limited.

Now, AI can reach. It can open your calendar. It can read your email. It can search the web. It can run a piece of code. It can call another agent across the country and ask it for help. The smartness was already there. The tools changed what the smartness could do.

This is the difference between a brilliant kid locked in a room and a brilliant kid with a phone, a laptop, and a set of keys. Same brain. Wildly different impact on the world.

Key Takeaways

• Tools are external capabilities that let an AI agent interact with the world — web search, email, calendars, databases, files, code, even other agents
• Without tools, a language model is a brain in a locked room — it can think but it cannot act
• MCP (Model Context Protocol) is an open standard from Anthropic, announced November 2024, that works like a USB port between agents and tools — build a tool once, any AI can plug in
• A2A (Agent2Agent) is an open standard from Google, announced April 2025, that lets agents call other agents like a telephone line between teammates
• Both standards are now run by neutral nonprofits — A2A joined the Linux Foundation in June 2025; MCP joined the new Agentic AI Foundation (also under the Linux Foundation) in December 2025
• The adoption was historic — by early 2026, one public directory listed more than 17,000 MCP servers, and the biggest AI companies supported the standard

---

Tools let agents act. But there’s still something missing. Right now, every conversation with an agent starts from zero — it doesn’t remember what you said yesterday, what it did for you last week, or even what the two of you were just talking about five minutes ago. Imagine working with an assistant who forgets your name every time you walk into the room. To be truly useful, agents need memory. In the next chapter, we’ll find out how they get it — and why a good memory is much harder to build than it sounds.