---
title: "The open agent standards: A2A, Agent Skills and AGENTS.md"
description: "The open standards stack for agents A year ago, every agent platform had its own way of connecting tools, describing skills and talking to other agents…"
url: https://optimizeall.com/learn/latest-ai-techniques-rag-agents-mcp/open-agent-standards
updated: 2026-10-05
---

Latest AI Techniques: RAG, Tool Use, Agents & MCP · The Model Context Protocol (MCP) and open agent standards · lesson 17 of 20 · 13 min

# The open agent standards: A2A, Agent Skills and AGENTS.md

## The open standards stack for agents

A year ago, every agent platform had its own way of connecting tools, describing skills and talking to other agents. That is changing fast. Several open standards now cover different layers of the problem, and knowing which does what saves you from building the same integration three times.

| Layer | Standard | What it standardises | Governance (at the time of writing) |
|---|---|---|---|
| Agent to tools and data | **Model Context Protocol (MCP)** | How AI apps connect to tools, resources and prompts | Agentic AI Foundation (Linux Foundation) |
| Agent to agent | **Agent2Agent (A2A)** | How independent agents discover each other, exchange messages and hand off tasks | Linux Foundation project (contributed by Google) |
| Reusable know-how | **Agent Skills** | Packaging instructions, scripts and resources as folders an agent loads when relevant | Open specification (originated at Anthropic) |
| Repository guidance | **AGENTS.md** | A predictable file where coding agents find project-specific instructions | Agentic AI Foundation (contributed by OpenAI) |

These are complementary: an agent might load a skill (how to prepare our monthly client report), call MCP tools (fetch analytics, create a draft in the CRM), and delegate a sub-task to a partner's agent over A2A (ask the media-buying agency's agent for spend data).

## Agent2Agent (A2A)

MCP connects an agent to tools; **A2A** connects agents to other agents, typically across organisational or vendor boundaries, where neither side should expose its internal tools, memory or prompts. Core ideas:

- **Agent Card:** a machine-readable description that an agent publishes (its name, what it can do, how to reach it, what authentication it needs), so other agents can discover it.
- **Tasks:** units of work with a lifecycle (submitted, working, input required, completed, failed) and results delivered as messages and artefacts, with streaming and asynchronous updates for long jobs.
- **Opacity:** each agent stays a black box; they collaborate through the protocol without sharing internals.

A2A reached a 1.0 release in early 2026 and is supported by major cloud platforms. Use it when you genuinely need to delegate to an agent you do not control (a supplier's, a partner's, another department's). Inside your own system, ordinary function calls or sub-agents are simpler.

## Agent Skills

A **skill** is a folder containing a `SKILL.md` file (YAML front matter with at least a name and description, then Markdown instructions), plus optional scripts, reference documents and assets. The key idea is **progressive disclosure**: an agent initially sees only each skill's name and description (a few dozen tokens each); when a task matches, it loads the full instructions, and only opens the bundled files it needs. That lets an agent have access to many skills without flooding its context.

```markdown
---
name: monthly-client-report
description: Prepare the agency's monthly performance report for a client from exported GA4 and ad-platform CSVs. Use when asked for a monthly report, performance summary or client recap.
---

# Monthly client report

1. Load the CSVs the user provides. Compute metrics ONLY with scripts/metrics.py (never in your head).
2. Compare with last month and the same month last year if available.
3. Write the report using templates/report.md: summary (5 bullets), wins, issues, hypotheses, next tests.
4. Label every hypothesis as a hypothesis. Never state causes as facts.
5. Flag any metric that moved more than 25% for human review before sending.
```

Anthropic published Agent Skills as an open standard in December 2025, and it has since been adopted by many agent products and coding tools. Because skills can include executable scripts, treat third-party skills like third-party code: review them, pin versions and run them in a sandbox.

## AGENTS.md

For software teams, **AGENTS.md** is a plain Markdown file at the root of a repository that tells coding agents how to work there: build and test commands, code style, architecture notes, "never do" rules. It is deliberately simple and is read by many coding agents; some tools also read their own files (for example `CLAUDE.md`), so teams often keep one source of truth and reference it from the others.

```markdown
# AGENTS.md
## Setup
- Install: `npm ci`  | Test: `npm test` | Lint: `npm run lint`
## Conventions
- TypeScript strict mode; no `any`. API handlers live in `src/api/`.
## Never
- Never commit secrets or edit files under `migrations/` by hand.
```

## How the standards fit together: worked example

A Dubai-based e-commerce agency builds an "account manager assistant":

1. **Skills** hold the agency's playbooks: monthly report, campaign post-mortem, new-client onboarding checklist.
2. **MCP servers** connect it to GA4 exports in cloud storage, the CRM and the project tool; write tools create drafts only.
3. **A2A** is used for one partner: a media-buying partner exposes an agent that answers "spend and ROAS by campaign for client X, last month", without giving the agency access to its ad accounts.
4. The engineers who maintain the internal tooling keep an **AGENTS.md** in each repository so their coding agents follow the same conventions.

Each standard solved a distinct problem; none of them replaced good design, least privilege or evaluation.

## Hands-on: write and test your first skill

1. Pick a task you repeat monthly (a report, a proposal section, a QA checklist).
2. Create a folder `my-skill/` with `SKILL.md`: a precise name and a description that says **what** it does and **when** to use it (this is what the agent sees before loading it).
3. Add numbered steps, quality rules and "never" rules. Move long reference material into separate files the instructions point to.
4. If a step needs exact computation or formatting, add a small script and tell the skill to use it.
5. Load it in a tool that supports Agent Skills, try five realistic requests (including one that should **not** trigger it) and refine the description until triggering is reliable.

## Video lecture: The open agent standards: A2A, Agent Skills and AGENTS.md

Lecture coming soon · 15 chapters · about 9 minutes. Read the full transcript below.

1. The open agent standards
2. Why standards matter
3. Agent2Agent (A2A)
4. Agent Skills
5. Skills safety + AGENTS.md
6. Simple example: a weekly recap skill
7. Worked example: agency assistant
8. Business example (illustrative)
9. Hands-on: your first skill
10. Descriptions decide triggering
11. Common mistakes
12. How you'll know they help
13. Watch me do it: SKILL.md
14. Recap
15. Try this now (30 minutes)

## Lecture transcript

### The open agent standards

Not long ago, every agent platform invented its own way to connect tools, package know-how and talk to other agents. Build for one, and you rebuilt for the next. That's changing. A small set of open standards now covers different layers of the agent stack. In this lesson you'll learn what MCP, Agent2Agent, Agent Skills and AGENTS dot M D each standardise, how they fit together, and you'll write your first skill.

### Why standards matter

Why do open standards matter to a small team? Because they decide whether your work is portable. Think of shipping containers. Before they were standardised, every port handled cargo differently, and moving goods was slow and expensive. Once containers had a standard size, any ship, crane and truck could handle them. MCP, A2A, Agent Skills and AGENTS dot M D are standard containers for tools, agent conversations, know-how and repository instructions.

### Agent2Agent (A2A)

You already know MCP: it connects an agent to tools, data and prompts. Agent2Agent, or A2A, connects agents to other agents, usually across company or vendor boundaries, where neither side should expose its internal tools or prompts. An agent publishes an Agent Card describing what it can do and how to reach it. Other agents send it tasks, which move through a lifecycle, submitted, working, input required, completed, and results come back as messages and artefacts, with streaming for long jobs. A2A was contributed by Google to the Linux Foundation and reached version one point oh in early 2026.

### Agent Skills

Use A2A when you genuinely need to delegate to an agent you don't control, like a supplier's or a partner's. Inside your own system, ordinary functions or sub-agents are simpler. Now Agent Skills. A skill is a folder with a SKILL dot M D file: a name, a description, then instructions, plus optional scripts, references and templates. The clever part is progressive disclosure. The agent first sees only each skill's name and description, a few dozen tokens. When a task matches, it loads the instructions, and opens bundled files only when needed.

### Skills safety + AGENTS.md

Anthropic published Agent Skills as an open standard in December 2025, and many agent products and coding tools have adopted it. Because skills can include executable scripts, treat third-party skills like third-party code: review them, pin versions and run them in a sandbox. The fourth standard, AGENTS dot M D, is aimed at software teams. It's a plain Markdown file at a repository's root telling coding agents how to work there: build and test commands, conventions, and never-do rules. It was contributed by OpenAI, and alongside MCP it sits under the Linux Foundation's Agentic AI Foundation.

### Simple example: a weekly recap skill

A simple example of a skill. Your team writes the same weekly social media recap every Monday. You create a folder called weekly social recap with a SKILL dot M D file. Its description says: prepare the weekly social recap from exported platform CSVs; use when asked for a weekly recap or social summary. The instructions list five steps and one rule: compute numbers only with the included script. Now any compatible agent can do the recap the same way, every week.

### Worked example: agency assistant

Here's how they fit together. A Dubai e-commerce agency builds an account manager assistant. Skills hold its playbooks: the monthly report, campaign post-mortems and onboarding. MCP servers connect to analytics exports, the CRM and the project tool, with write tools that only create drafts. A2A connects to one media-buying partner whose agent answers questions about spend by campaign, without handing over ad-account access. And the engineers keep AGENTS dot M D files so their coding agents follow house conventions.

### Business example (illustrative)

A deeper business example, illustrative. Before skills, three account managers produced the monthly report in three different styles, and each took about three hours. With the monthly report skill, the assistant produced a consistent first draft in minutes, computed every figure with the included script, and flagged movements above twenty-five percent for review. Each report now takes about forty minutes of human checking, and clients see the same structure every month.

### Hands-on: your first skill

Standards reduce integration work. They don't replace good design, least privilege, sandboxing or evaluation. A poorly written skill still produces poor reports, and an MCP server with an admin token is still dangerous. In the hands-on section you'll write your first skill. Pick a monthly task, write a precise name and a description that says what it does and when to use it, add numbered steps and never rules, move long reference material into separate files, add a script for anything that needs exact computation, and test five requests, including one that should not trigger it.

### Descriptions decide triggering

One more tip on descriptions. They're the only thing the agent sees before loading a skill, so they decide whether it triggers. Too vague, and it never fires. Too broad, and it fires for everything. Include the words your colleagues actually use when they ask for the task, like monthly report, performance summary or client recap, and test until triggering is reliable.

### Common mistakes

Common mistakes with these standards. Using A2A inside your own system where a simple function call would do. Writing skill descriptions so vague they never trigger. Installing third-party skills without reading their scripts. Letting AGENTS dot M D go stale, so coding agents follow last year's commands. And assuming a standard makes something safe. Standards are plumbing: security, permissions and evaluation are still your job.

### How you'll know they help

How will you know the standards are helping? Skills trigger on the right requests and stay quiet on the wrong ones. The same skill produces consistent output across different people and tools. Your MCP servers are reused by more than one assistant. And, if you use A2A, partner agents can be swapped or added without rebuilding your side. Standards should show up as less duplicated work.

### Watch me do it: SKILL.md

Watch me do it. I create a folder called monthly client report and open SKILL dot M D. First, the front matter: name monthly client report, and a description that says what it does, prepare the monthly performance report from exported GA4 and ad-platform CSVs, and when to use it, for a monthly report, performance summary or client recap. Next, the body: step one, compute metrics only with scripts slash metrics dot py. Step two, compare with last month and the same month last year. Step three, use the report template. Step four, label hypotheses as hypotheses. Step five, flag any metric that moved more than twenty-five percent. Then I add the script and the template file. I test five requests. Four report requests trigger the skill. The fifth, write a caption for Instagram, correctly doesn't. Finally, I tweak the description to include client recap, which one colleague uses, and re-test.

### Recap

To recap: MCP for tools and data, A2A for agent-to-agent delegation, Agent Skills for packaged know-how with progressive disclosure, and AGENTS dot M D for repository guidance. They're complementary, openly governed, and no substitute for good design and security. Your next step is to write one SKILL dot M D for a task you repeat, and test it. Next, in the final module, we turn to guardrails and security for agents.

### Try this now (30 minutes)

Try this now. Pick one task you repeat every week or month. Create a folder with a SKILL dot M D file: a name, a description that says what it does and when to use it using your team's real words, numbered steps, quality rules and a never list. If a step needs exact numbers, note which script should do it. Then test it with five requests, including one that should not trigger it.

## Key takeaways

- MCP connects agents to tools and data; A2A connects agents to other agents; Agent Skills package know-how; AGENTS.md guides coding agents.
- A2A uses Agent Cards for discovery and task lifecycles for delegation, keeping each agent opaque.
- Skills use progressive disclosure: name and description first, full instructions and files only when relevant.
- Open standards reduce integration work but do not replace design, least privilege, sandboxing or evaluation.

## Try it

Write a SKILL.md for one repeated task in your work, test it with five requests (one that should not trigger it), and note which of MCP, A2A or AGENTS.md your setup would also need.

- [Previous: Building your first MCP server](https://optimizeall.com/learn/latest-ai-techniques-rag-agents-mcp/building-an-mcp-server)
- [Next: Guardrails and human-in-the-loop](https://optimizeall.com/learn/latest-ai-techniques-rag-agents-mcp/guardrails-and-human-in-the-loop)
- [All lessons of Latest AI Techniques: RAG, Tool Use, Agents & MCP](https://optimizeall.com/learn/latest-ai-techniques-rag-agents-mcp)