Five terms under the hood of an AI agent

2026, Nov 09    

A coding agent can plan a task, write the code, run the tests and open the pull request with very little help. The model alone does none of that. A model is a conversation partner. What turns it into an agent is a handful of pieces around it, and five of them have names worth knowing.

These are my notes on 5 AI Agent Terms You Need to Know by IBM Technology (11 minutes), with a diagram for each term and a few things I would add.

Two terms shape what the agent knows, two let it reach outside itself, and one handles work too big for a single context. All five are, in the end, about the same scarce thing: what goes into the model’s context window, and when.

~/project  -  agent
1  AGENTS.md   # how this project works
2  skills/     # how to do a kind of task
3  MCP         # agent -> tools and data
4  A2A         # agent -> agent
5  subagents   # work that does not fit

-- all five decide what enters the context window

The five pieces around the model

Inside the box: what the agent knows. Arrows: how it reaches outside.

THE AGENT instruction layer 1 AGENTS.md every session 2 Skills when needed Model (LLM) generates text, reasons TOOLS & DATA Notion Stripe Database 3 MCP OTHER AGENTS Finance Legal 4 A2A subagent subagent subagent 5 Subagents each with its own context

1. AGENTS.md: a README written for the agent

AGENTS.md is a plain Markdown file at the root of a project. Whenever the agent starts work there, it reads the file first. It holds what a new colleague would need on day one: the setup commands, how to run the tests, the code style, how a pull request title should look.

The agent acts on it when it is relevant. If the file says run pnpm test before committing, the agent runs pnpm test before it commits.

Files can be nested. A monorepo can have one at the root and one per subproject, and the one closest to the code being changed wins where they disagree:

repo/
├── AGENTS.md          pnpm test before commit
└── packages/
    ├── web/
    │   └── AGENTS.md  Next.js lint rules
    └── api/
        └── AGENTS.md  go test   ← wins here

AGENTS.md came from OpenAI and is now stewarded by the Agentic AI Foundation (AAIF) under the Linux Foundation. Some agents read a file of their own name for the same job: Claude Code reads CLAUDE.md. Different name, same idea.

2. Agent skills: knowledge loaded only when it is needed

AGENTS.md is read every time. That is right for how this project works, and wrong for knowledge the agent needs only sometimes, such as how to build a PowerPoint deck. Loading that into every session would fill the context window with instructions the task at hand never uses.

An agent skill is a folder. Inside it is a SKILL.md file and whatever scripts or resources the task needs. The top of SKILL.md carries a name and a description that says, in effect, use me when the user wants X:

---
name: pptx
description: Create and edit PowerPoint decks. Use when the user asks for slides or a .pptx file.
---
# Building a deck
1. Start from template.pptx in this folder ...

The agent sees only the descriptions up front. When a request matches one, it pulls in the rest of the skill. When nothing matches, the skill sits out of the way. The video says it takes no context at all; strictly, the one-line description does, which is the price of the agent knowing the skill exists.

What the context window holds before the task starts

Three skills installed. Sizes illustrative.

AGENTS.mdskill descriptionsfull skillroom for the task
Everything up front all skills, every session PowerPoint PDF Spreadsheet Skills, idle descriptions only room for the task Skills, "make slides" one skill pulled in PowerPoint room for the task

Anthropic introduced skills for Claude and published the format as an open standard, and several agent platforms now read it. In short: AGENTS.md tells the agent how this project works; a skill tells it how to do a kind of task, in any project.

3. MCP: one plug for every tool

Now the agent knows what to do. Doing it means reaching outside: APIs, databases, developer tools, SaaS products. Each has its own interface, so without a standard every agent needs a custom connector for every tool it touches.

The Model Context Protocol is an open protocol for connecting AI applications to tools, data and workflows. A tool is wrapped once in an MCP server, which handles that tool’s own API. Any agent that speaks MCP can then use it. When the agent needs a page from Notion, it speaks MCP to the Notion server, and the server talks to Notion.

Connectors needed for 3 agents and 4 tools

WITHOUT A STANDARD Coding agent Chat app Your agent Notion Stripe GitHub Database 3 × 4 = 12 connectors WITH MCP MCP Coding agent Chat app Your agent Notion Stripe GitHub Database 3 + 4 = 7, each written once

Dark edge on a tool: its MCP server.

MCP started at Anthropic and is now governed by the same AAIF at the Linux Foundation, with broad industry support.

4. A2A: agents talking to agents

MCP covers an agent talking to tools and data. Agent2Agent (A2A) is the open protocol for an agent talking to another agent.

The video’s example: a procurement agent negotiates vendor contracts, a finance agent approves spend. Once procurement has a contract, it has to hand it to finance. Without a shared protocol, the two need a custom integration, or they do not coordinate well.

With A2A, every agent publishes an agent card: a short description of what it does and how to reach it. Another agent reads the card and knows whether, and how, to delegate. A trimmed one:

{
  "name": "Finance agent",
  "description": "Approves spend against the department budget.",
  "url": "https://finance.example.com/a2a",
  "skills": [
    { "id": "approve-spend", "name": "Approve spend",
      "description": "Approve or reject a contract or purchase." }
  ]
}

Procurement hands a contract to finance

Procurement agent Finance agent 1 · fetch the agent card 2 · card: "approves spend" 3 · task: approve this contract 4 · result: approved

A2A comes from Google and is also an open standard under the Linux Foundation. MCP is how an agent reaches tools and data; A2A is how it reaches other agents.

5. Subagents: when one context is not enough

Sometimes one agent is not enough. The task can be too big for one context window: reviewing a codebase of thousands of files by loading every file would fill it on its own. Or the work is embarrassingly parallel: twenty independent checks on twenty functions, done one at a time when they could all run at once.

A subagent is a child agent the main agent spawns for one piece of work. It starts with a fresh context, does the job, and returns only the result. Read these 500 files and give me a summary: the 500 files fill the child’s context, and the parent receives a few paragraphs.

The parent stays clean, the children do the reading

context usedreturned summaries
Main agent context mostly free tasks out, summaries back files 1–500 files 501–1000 files 1001–1500 … up to 20 in parallel

Subagents differ from the other four in one way: there is no standard document behind them. It is a pattern, but it looks almost the same everywhere. The parent spawns one or more children, each child gets its own context, does what it was told and returns a result, and the parent carries on with its own context intact.

The five together

TermAnswersEnters the contextStandard
AGENTS.mdHow does this project work?every sessionopen spec, AAIF
Agent skillsHow do I do this kind of task?description always, the rest on a matchopen spec
MCPHow do I reach this tool or data?tool list, then each resultopen protocol, AAIF
A2AWho can I hand this work to?the card, then the resultopen protocol, Linux Foundation
SubagentsWhat if the work does not fit?only the child's summarya pattern, no spec

Read the middle column top to bottom and the five turn out to be one idea: the context window is the scarce resource, and each term is a rule for what is allowed into it, and when.

What I would add: four of the five are things the agent obeys

AGENTS.md and SKILL.md are instructions in plain text, followed by a program that can run commands. An MCP server is a dependency that holds your credentials. An agent card is a stranger describing itself. None of that is a reason to avoid them, but it is a reason to treat them like code: review them, pin their versions, and give each the narrowest access it needs. And keep a record of what the agent actually did, not only what it was told to do. No technology fixes bad design, it only mitigates it, and an agent is a very fast way to carry out a design, good or bad.