5 AI Agent Terms You Need to Know

Summary of Technological Concepts / Product Features

The video explains five “under the hood” concepts that enable modern agentic AI systems to plan tasks, execute work, and coordinate with tools and other agents.

1. agents.md (Project instruction layer)

A Markdown (.md) file at the root of a project that an agent reads every time it starts work in that project.

It acts like an agent-specific “README for agents,” defining operational rules such as:

• which commands to run for tests
• coding conventions / code style
• formatting rules (e.g., PR title format)

The agent can execute commands specified in this file when relevant (e.g., run tests before committing).

Key details:

• Supports nested agents.md files for sub-projects.
• Files closer to the working directory override earlier ones.
• Mentioned lineage/support: introduced by OpenAI, later contributed to the agentic AI foundation under the Linux Foundation.
• Note: some platforms use different filenames (example given: Claude uses Claude.md).

2. Agent Skills (skill.md folders)

An agent skill is a folder containing a skill.md file plus related scripts/resources.

It includes metadata describing when the skill should be used (e.g., “invoke me when the user wants to make a PowerPoint”).

Key points:

• Skills are only pulled into context when the user request matches the skill’s description, preventing unnecessary context bloat.
• Described as an open standard supported by multiple agent platforms.

3. MCP — Model Context Protocol (tools/data interoperability)

An open protocol to connect AI applications/agents to tools and data sources/workflows.

How it works:

• Uses an MCP server that exposes a tool/data source through a standard interface.
• Agents speak MCP to the server.
• The server handles the tool’s underlying API (example targets: Notion, Stripe, etc.).

Origin/governance mentioned:

• Started at Anthropic
• Now governed under the AAIF at the Linux Foundation

It’s emphasized as solving the “connector explosion” problem by standardizing integrations.

4. A2A — Agent-to-Agent protocol (agent coordination)

An open protocol for communication between agents.

Example scenario:

• a procurement agent negotiates contracts
• then hands off to a finance agent for approval

Coordination mechanism:

• Agents publish an “agent card” describing:
  • what the agent does
  • how to talk/delegate work to it
• Another agent reads the card and delegates accordingly (no bespoke integration required).

Mentioned origin/support:

• described as coming from Google
• also an open standard under the Linux Foundation

5. Subagents (spawning multiple agents / fresh contexts)

A pattern for spawning child agents to handle work that doesn’t fit in a single context window.

Key behavior:

• Each subagent runs in a fresh context window
• performs its assigned task
• returns results to the parent agent

Use cases highlighted:

• large codebase review (thousands of files) without blowing context
• parallelizable work (e.g., checking 20 independent functions concurrently)

Noted distinction:

• no formal standard document like the other four terms, but the pattern appears widely in modern systems.

Main Speakers / Sources (as stated)

• OpenAI (for agents.md)
• Anthropic (initial MCP origin)
• Google (origin of A2A)
• Linux Foundation (governance/support mentioned for these standards)
• AAIF (mentioned in relation to MCP governance)
• Platform example: Claude (uses Claude.md instead of agents.md)