Week 7 Self-Paced Module: Evolution of Tool Use

Overview

This week's lecture showed you how tool use works today. This module answers a different question: why does it look the way it does? Tool use went from a research idea to a standard protocol in about three years — from hand-built, one-off integrations, through ReAct and Toolformer, to function calling and the Model Context Protocol (MCP). Understanding that arc helps you read new announcements critically and anticipate what comes next.

Why This Matters

Each step in this history fixed a specific weakness in the one before it, and knowing which weakness tells you what is still your job today. Understanding why function calling moved tool definitions out of training and into the request is exactly why your tool descriptions matter so much — the model was trained to read schemas in general, so your text is the only thing telling it what your tool is actually for. And because the standards are still changing (MCP's specification has already changed significantly since late 2024), this history also helps you judge whether a new announcement is a genuinely new idea or just a new packaging of an old one.

Format and Timing

• Framing video (~12 minutes, 15 slides, posted on E3) — link coming soon; check back before starting the module.
• Required reading — three items: Anthropic's tool-use documentation, MCP's architecture overview, and the ReAct/Toolformer paper abstracts (~38 minutes combined). Linked below.
• Multiple choice questions (單一選擇題) — four questions on E3, about 10 minutes.
• Total estimated time: ~60 minutes
• Complete by Sunday, October 25. Week 8 is a holiday, so use it if you need to.

What You'll Learn

• Before tool use: hand-built systems (2021–2022) — WebGPT (a GPT-3 model fine-tuned to use a web browser) and MRKL systems (routing requests to separate expert modules) proved that a language model plus outside tools beats a language model alone, but each integration was built by hand for one specific system and task.
• ReAct (2022) — interleaves reasoning traces and actions: reason about what to do, act, observe, reason again. It named the Reason → Act → Observe loop, reduced hallucination and error propagation compared to chain-of-thought alone, and made behaviour more auditable — though a reasoning trace is evidence you can debug with, not proof of what actually drove the decision.
• Toolformer (2023) — trained a model to decide which APIs to call, when, and with what arguments, in a self-supervised way from a handful of demonstrations. The decision to use a tool was learned rather than hard-coded, but the knowledge was baked into the weights: it couldn't chain tool calls, couldn't interact with a tool over multiple turns, and adding a new tool meant retraining.
• Function calling (2023): the pivot — tool definitions move out of training and into the API request. The model is trained once, in general, to read tool schemas and decide whether to call them; you define a tool with a name, description, and input schema, the model returns a structured tool call, and your code runs it and returns the result. This is why description quality is now your responsibility, not the model's training data's.
• The next problem: N × M integrations — with function calling, every application writes its own tool definitions and glue code for its own model. Reusing the same integration across multiple applications means writing it multiple times, or letting copies drift. This is an integration problem, which is exactly the kind of problem a standard solves.
• MCP (2024): a standard for tools and context — Anthropic's open protocol with a host (the AI app), one client per server, and servers that expose tools, resources and prompts over JSON-RPC. Write an integration once as a server, and any compatible host can use it — N × M becomes N + M. MCP changes reuse, not intelligence: schema quality, boundaries, and safety are still engineering responsibilities.
• MCP's governance and continued change (2025–2026) — Anthropic donated MCP to the Agentic AI Foundation (a Linux Foundation directed fund, co-founded with Block and OpenAI) in December 2025, by which point it had roughly 10,000 active servers and support across major AI products. The specification keeps evolving — some earlier features have already been deprecated or replaced — and security has become a first-class topic (confused-deputy attacks, token passthrough, local server compromise). Anything you build on MCP should pin versions and expect to update.
• The pattern across all of it — each step moved something out of one-off code or model weights and into a shared interface. What never moved: designing the interface well, evaluating the trajectory, and deciding what the system is allowed to do. Those remain engineering responsibilities no standard takes off your plate.

Required Materials

• Framing video: posted on E3 under Week 7 Self-paced Modules.
• Reading: Anthropic, “Define tools” (~15 minutes) — read the sections on descriptions, naming, input schema, input examples, and tool choice. Skim the rest.
• Reading: Model Context Protocol, “Architecture overview” (~15 minutes) — read Participants, Layers, and Primitives. You can skim the JSON examples.
• Reading: the two research paper abstracts and introductions only (~8 minutes) — Yao et al. (2022), “ReAct: Synergizing Reasoning and Acting in Language Models”, and Schick et al. (2023), “Toolformer: Language Models Can Teach Themselves to Use Tools”.
• Multiple choice questions: posted on E3 under Week 7 Self-paced Modules Response.

Optional Materials

If you want to go deeper on any of these topics (not required, but helpful if you're curious):

• Anthropic Engineering, “Writing effective tools for agents — with agents” (Sept 2025) — how Anthropic's team builds and evaluates tools: prototype, build evaluations from realistic multi-step tasks, consolidate tools, namespace them, return high-signal results, and write clear descriptions and actionable error messages. Highly recommended for your project.
• Anthropic Engineering, “Building effective agents” (Dec 2024) — distinguishes workflows (predefined code paths) from agents (the model directs its own process), and argues for the simplest solution that works. A preview of Week 13.
• Model Context Protocol, “Security best practices” — the project's own account of the main attacks and mitigations. Read the introductions to Local MCP Server Compromise, Confused Deputy, and Scope Minimization.
• Model Context Protocol, “Understanding MCP servers” — a fuller treatment of tools, resources and prompts, including who controls each.

Completion and Assessment

← Back to Calendar