Fornire strumenti a un agente

An agent is only as capable as the tools it can reach. On its own, an AI just predicts text. Give it tools, and it can search the web, read your files, run code, or call an API.

Think of tools as the agent's hands. The brain decides; the hands act. This lesson shows what those hands are and how you grant them.

A "tool" is any action the agent can take in the real world. Common ones:

• Web search / fetch — look something up online
• File read/write — open and edit your project
• Run command — start a server, run tests
• Call an API — hit a weather, payment, or data service

In Claude Code these come built in; in custom agents, you wire them up yourself.

Without tools, an agent can only guess from what it already learned. It might say "the latest version is 3.2" when it's actually 5.0.

With a web search tool, it can go check. With a file tool, it sees your actual code instead of imagining it. Tools replace guessing with knowing — that's the whole point.

When an agent uses a tool, it doesn't run the tool itself — it requests it. The agent says "call getWeather for Paris," your system runs that function, and hands the answer back to the agent.

Here's that handoff as plain JavaScript so you can see the shape of a tool:

For an agent to use a tool, you describe it in plain words: its name, what it does, and what inputs it needs. The AI reads that and decides when to call it.

You rarely write this by hand for beginner tools — Claude Code and v0 handle it — but knowing the shape helps you understand what the agent is choosing between.

As a vibe coder, you'll lean on a handful of built-in tools your agent already has:

• Read file — so it understands your project
• Edit file — so it can build features
• Run command — so it can test and start things
• Web search — so it stays current

You mostly just allow these when asked. Knowing what each does helps you approve wisely.

You don't have to name the tool — describe the outcome and the agent picks the right one. But you can nudge it when helpful.

Notice how this prompt hints at which tools to use without micromanaging:

You may hear about MCP (Model Context Protocol). It's a standard way to plug extra tools into an agent — like connecting it to your database, your design files, or a service like GitHub.

You don't need to build MCP servers as a beginner. Just know: it's the "USB port" that lets agents safely reach new tools beyond the built-in ones.

One of the most useful tools is a web API — a service your app calls for data (weather, currency, maps). An agent can both write the code that calls it and use it while building.

Here's a real fetch the agent might generate to call an API and use the result:

Every tool you give an agent is a power and a risk. A delete-file tool can clean up — or wipe your work. A shell tool can install packages — or run something harmful.

Good rule: grant the fewest tools needed for the task. Start narrow, add more only when the job clearly needs it. You'll go deeper on this in the safety lesson.

Putting it together: you decide which tools the agent can reach, describe what each does, and approve their use. The agent then chooses the right tool at the right moment to reach your goal.

An agent without tools is just a chatbot. An agent with the right tools is a builder. Equip it thoughtfully and it becomes genuinely useful.

You learned how agents reach the real world:

• Tools are actions: web search, file read/write, run command, call an API.
• The agent requests a tool; your system runs it and returns the result.
• Each tool is described by name, purpose, inputs.
• MCP is the standard plug for adding extra tools.
• Grant the fewest tools needed — power equals risk.

Next: chaining tools and steps into a multi-step automation.