What Is AgentProto? The Beginner's Guide (AIPs, the Open-Source Spec Layer, and How It Differs From A2A and MCP)

CodexFuse Team · 2026-11-04T12:49:13.584Z · 11 min read min read

What Is AgentProto, Exactly?

AgentProto is an open, numbered-standards project for the markdown files that AI agents read, write, and run from. That is the short answer to "what is agentproto" — and everything below is the long one. Its GitHub organization, agentproto/agentproto, puts it in one line: "AIPs — open numbered standards for the markdown files agents read, write, and run from. Like BIPs/EIPs/PEPs, but for agents." (GitHub, agentproto/agentproto README, opened 2026-11-04)

If "agentproto explained" is your whole search, stop here: it is not a framework, not a model, and not a wire protocol. It is a registry of numbered specifications — AgentProto Improvement Proposals, or AIPs — that codify de-facto conventions like SKILL.md, AGENTS.md, and TOOL.md into one shared vocabulary every runtime can implement. Its own FAQ is blunt about scope: it replaces neither MCP nor A2A, and the repo holds markdown specs only — no code.

The closest mental model is the one the project itself uses: AIP is to AI agents what a PEP is to Python. One numbered document per primitive, one place to look it up, and proposals instead of unilateral changes. If you already build agents with a dedicated agent skills studio for authoring reusable skills, the instinct will feel familiar — AgentProto tries to make the underlying specifications of those skills portable too. Its sibling lane, the Model Context Protocol guide, covers the transport layer AgentProto deliberately sits above.

What Is an AIP? (AgentProto Improvement Proposals)

An AIP — AgentProto Improvement Proposal — is one numbered specification document. If you searched "agentproto aips" for the mechanics, here they are: the project's rule is one spec per primitive. AIP-3 codifies SKILL.md as Anthropic shipped it; AIP-14 declares a tool's contract in TOOL.md (schemas, side effects, approval class); AIP-30 declares an implementation in DRIVER.md, so one TOOL.md can have many drivers — OpenAI, Replicate, or local.

That is also the answer to "what is an agent specification" in AgentProto's world: a markdown file describing one component of an agent — a skill, a tool contract, an identity, a memory layout — in a format both humans and agents read every turn. The project chose markdown over YAML or JSON for exactly that reason; its FAQ answers "Why markdown, not YAML or JSON?" with "Because the agent reads the file every turn."

As of 2026-11-04 the repo carries 33 specs organized into 8 semantic layers (GitHub, agentproto/agentproto):

Crucially, the specs are "aligned with the de-facto standards they grow out of, not forks of them" (README). AIP-3 does not invent a new skill format; it writes down the SKILL.md convention teams already use, so any runtime can read it. That alignment-first philosophy is the whole bet: portable definitions beat lock-in.

How does a new idea become an AIP? The contribution path, per the README:

1. Pick the primitive. One spec per component — a new tool-contract flavor, a memory pattern, a governance role.
2. Copy the AIP-2 template. AIP-2 is the meta-spec for writing specs.
3. Fill all seven required sections — from Abstract through Security Considerations.
4. Submit for review. Specs are proposals, not pronouncements; they stabilize through discussion.

Status note, stated honestly: the README carries "Status: 0.1.0-alpha. Specs are stabilising; expect minor breaking changes between alpha releases." The repo (created 2026-04-30, 206 commits as of 2026-11-04) has no published GitHub releases. Rendered docs live at agentproto.sh/docs, and two sister repos carry the rest of the project: agentproto/ts, a TypeScript reference runtime with packages like @agentproto/tool and @agentproto/driver plus adapters for Mastra and ai-sdk, and agentproto/site, the Next.js docs renderer.

AgentProto vs A2A: What's the Difference?

AgentProto and A2A solve different problems on purpose. A2A — the Agent2Agent protocol, "an open standard, originated by Google and donated to the Linux Foundation" — is "an open standard for seamless communication and collaboration between AI agents," the "definitive common language for agent interoperability" (a2a-protocol.org). It is agent-to-agent: agents discovering each other, delegating tasks, sharing results.

AgentProto, by contrast, is about how a single agent's components are structured on disk: where its skills live, how a tool's contract is declared, how its memory is organized. The project's own FAQ settles it: "Is this an A2A replacement? No. A2A solves agent-to-agent comms. AIPs are about how a single agent's components are structured on disk." (GitHub, agentproto/agentproto)

The two projects explicitly consider themselves complementary, not competing. The same FAQ adds that A2A and MCP are likewise complementary: "MCP standardizes agent-to-tool communication; A2A standardizes agent-to-agent communication."

AgentProto vs MCP: What's the Difference?

MCP — the Model Context Protocol — "is an open-source standard for connecting AI applications to external systems," letting applications like Claude or ChatGPT reach "data sources (e.g. local files, databases), tools (e.g. search engines, calculators) and workflows" (modelcontextprotocol.io). It is the transport: how the model talks to tools.

AgentProto sits one layer above transport. Its FAQ: "Is this an MCP replacement? No. MCP solves tool transport. AIPs specify the layer above transport, below frameworks: where context lives, roles are defined, memory is structured." (GitHub, agentproto/agentproto)

Concretely: MCP would carry the messages between your agent and a database; an AIP would specify what the agent's TOOL.md for that database looks like, and what approval class its side effects fall into. If MCP is the plumbing, AIPs are the blueprints of the fixtures.

Which "AgentProto" Do You Mean? The Five Name Collisions

Search "agentproto github" and you land on the right project — but the name is crowded, and a fresh 2026-11-04 page-1 check for "what is agentproto" surfaced five different things sharing it. Sorting them out is half of understanding the term:

The IETF collision deserves a longer look, because it is the one most likely to mislead you — it gets its own section next. The thin AI-generated news posts on undercodenews.com (October 2026) about the repo's "missing release page" describe the GitHub project but add little; note that one undercodenews piece's claims about published packages named @agentproto/core could not be corroborated against the README's actual package list and likely describe yet another different "Agentproto" project.

The IETF's Separate Agentproto Working Group: The December 2026 Watch

The IETF's "Agent Communication Protocols (agentproto)" working group is a separate standards effort from the GitHub org — same name, different venue, different people. It must not be conflated with the AIPs project above.

The facts, as of 2026-11-04: "The IESG approved Agentproto's charter on 8 October 2026. The group aims to adopt a use-cases draft in December, before taking on architecture and protocol drafts in 2027." (btw.media, 2026-10-17) A use-cases proposal updated on 15 October "remains an individual Internet-Draft. Its authors have revised a document; the working group has not thereby chosen it." The published plan targets an informational architecture-draft adoption in February 2027 and standards-track protocol drafts in March 2027, with drafts to the IESG as proposed standards in March 2028.

The WG's own charter frames the goal as defining "a common baseline agentic dialog management protocol and build a reference architecture to integrate related protocol building blocks, enabling interoperability across platforms and vendors" (mailarchive.ietf.org, WG review). And it is explicitly not designing a new transport: "Agentproto is not designing a new transport or replacing application-layer agent protocols. Existing IETF protocols are to carry the context." (btw.media)

The watch angle: the next consequential event is whether the WG adopts a use-cases draft in December 2026 — a timetable milestone, not a done deal. Track it if you care about Internet-layer agent standards; the GitHub AIPs project evolves on its own schedule regardless.

Who Is AgentProto For — and Should You Use It Now?

AgentProto is for agent builders who are tired of every framework inventing its own SKILL.md, its own tool contract, its own memory layout. If you ship agents across runtimes — or consume skills written by someone else's runtime — a shared vocabulary for those files is genuinely useful. The alignment-first philosophy (codify what teams converged on, don't fork it) is what makes it plausible rather than just another format.

Should you build on it today? Honestly: treat it as a spec to watch, not a foundation to bet a production system on. Status 0.1.0-alpha, breaking changes expected between alpha releases, no published releases as of 2026-11-04. Reading the AIPs to borrow ideas is cheap and useful; pinning your agent's file layout to alpha specs is a commitment you should make with open eyes.

Licensing is worth a line too, because it is split by design: the AIP markdown specs themselves are CC-BY-4.0, code samples embedded in specs are MIT, and the TypeScript reference runtime is Apache-2.0 (GitHub, agentproto/agentproto README). Practically, if you run your agent stack on a remote server, a solid VPS hosting setup is where those files actually live and get executed — specs don't run themselves. And if your agent style leans toward autonomous terminal-driven helpers, our OpenClaw agent guide shows the kind of runtime such specs would one day target.

Sources

• agentproto/agentproto README (github.com/agentproto/agentproto) — opened 2026-11-04: one-liner, AIP definition, FAQ ("Is this an MCP replacement? No…", "Is this an A2A replacement? No…", "Why markdown, not YAML or JSON?"), the 33-specs/8-layers structure, repo table (agentproto/ts Apache-2.0, agentproto/site MIT), license split (specs CC-BY-4.0, samples MIT), "markdown specs only — no code," 206 commits, created 2026-04-30, 0 releases, status 0.1.0-alpha.
• a2a-protocol.org — "The Agent2Agent (A2A) Protocol is an open standard for seamless communication and collaboration between AI agents…", "originated by Google and donated to the Linux Foundation," "MCP standardizes agent-to-tool communication; A2A standardizes agent-to-agent communication. They are complementary."
• modelcontextprotocol.io — "MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems…" (getting-started intro, 2026-07-28 docs).
• DeepWiki, "Protocol Design | agi-inc/agent-protocol" (deepwiki.com, published 2026-02-25) — "a single, minimal REST API that any AI agent can implement… It is not a runtime, not a framework, and not a model. It is a contract."
• Microsoft Learn, agent_framework.AgentProtocol class reference — "A protocol for an agent that can be invoked."
• vaia.com, "Agent Protocols: Definition & Applications" (updated 2024-09-05) — generic glossary definitions of "agent protocol."
• creati.ai, "Agent Protocol: Web3 AI Agents for Autonomous Automation" (updated 2026-09-29) — web3/no-code "Agent Protocol" listing; false positive.
• undercodenews.com, "AgentProto Just Updated: What an Agent-Focused Protocol Project Could Mean for AI Interoperability" (~2026-10-19) — "AIPs — AgentProto Improvement Proposals," "no published releases."
• undercodenews.com, "AgentProto Just Updated: Why the Missing Release Page Doesn't Tell the Whole Story" (2026-10-29) — "currently has no published releases."
• btw.media, "Agentproto: keeping AI conversations connected" (2026-10-17) — IETF charter approved 2026-10-08, December use-cases adoption milestone, 2027–2028 roadmap, "not designing a new transport."
• mailarchive.ietf.org — [secdir] WG Review notice for the "Agent Communication Protocols (agentproto)" charter; ietf.org draft-manyfolks-agentproto-arch-00 (Internet-Draft, October 2026).

Frequently Asked Questions

Is AgentProto a replacement for MCP?

No. Per the project's own FAQ: "MCP solves tool transport. AIPs specify the layer above transport, below frameworks: where context lives, roles are defined, memory is structured." They are designed to stack, not compete.

Is AgentProto a replacement for A2A?

No. The FAQ again: "A2A solves agent-to-agent comms. AIPs are about how a single agent's components are structured on disk." A2A handles agents talking to each other; AgentProto standardizes the markdown files a single agent reads and writes.

What does AIP stand for?

AgentProto Improvement Proposal — one numbered spec per primitive, on the BIPs/EIPs/PEPs model. As of 2026-11-04 there are 33 AIPs across 8 layers, from AIP-3 (SKILL.md) to AIP-30 (DRIVER.md).

Is the IETF's agentproto working group the same project as agentproto/agentproto on GitHub?

No — same name, different effort. The GitHub org publishes markdown specs (AIPs) for agent files; the IETF "Agent Communication Protocols (agentproto)" working group, chartered 2026-10-08, is an Internet-standards effort with a December 2026 use-cases adoption milestone.

Is AgentProto production-ready?

Not yet. The project labels itself 0.1.0-alpha, warns of breaking changes between alpha releases, and has no published GitHub releases as of 2026-11-04. Follow the specs and borrow ideas; don't pin a production agent layout to them blind.