@bibryam: https://x.com/bibryam/status/2103847898882437408
Summary
This article discusses emerging standards for AI agents, such as Open Responses for model connections, MCP for tools, A2A for remote agent collaboration, and AG-UI/A2UI for user applications, highlighting their complementary roles in agent development.
View Cached Full Text
Cached at: 09/27/26, 05:16 AM
The Emerging Standards Behind AI Agents
Agents are becoming a primary unit of application development. To do useful work, an agent must connect to a model, tools, remote agents, users, organization-specific instructions and knowledge, operational systems, and, for coding work, an IDE.
A different contract is forming at each boundary. Some are communication protocols. Others specify an API, a telemetry vocabulary, an instruction file, or a package format. The distinction matters because these standards are complementary. You can adopt MCP for tools without adopting A2A for remote agents or ACP for IDEs.
Here is where the main standards fit.
1. Open Responses connects the model
An agent starts with a model API. Early integrations largely converged on Chat Completions concepts such as messages, roles, streaming, and structured tool calls.
Modern agent runtimes need to represent more than a text response. They coordinate messages, tool calls, tool results, and other actions across a run. Open Responses defines an open, multi-provider version of that model interface using typed items and semantic streaming events.
Open Responses is distinct from OpenAI’s Responses API, although it builds on the same design. The existing alignment around OpenAI-compatible APIs makes it a credible neutral specification, but it is still emerging.
2. MCP connects tools
Once an agent can call a model, it needs to reach its environment. It may need to read a document, query a database, operate a browser, or invoke an internal service.
The Model Context Protocol standardizes that connection. An MCP host contains clients that connect to servers. Those servers expose tools, resources, and prompts through a shared JSON-RPC contract.
MCP has also become an extension point. MCP Apps lets a tool declare an interactive HTML resource that a host can render. Skills over MCP explores how agents could discover and consume Agent Skills through MCP, although that work is still in development.
Broad client, server, and SDK support makes MCP the closest thing to a de facto standard on this map.
3. A2A connects remote agents
Tools are not the only external participants. An agent may need to delegate work to another agent built and operated by a different team or organization.
A2A gives those independent agents an external collaboration contract. Agent Cards describe what an agent offers and how to reach it. Messages carry content, Tasks represent stateful work, and Artifacts carry results. Streaming and push notifications support work that outlives one request.
The boundary with MCP is useful: MCP exposes a capability, while A2A delegates an outcome to an autonomous participant. A2A 1.0 is stable, although the release is still recent.
4. AG-UI and A2UI connect the user application
Most agents also interact with people. Their applications need streamed text, visible tool activity, shared state, frontend actions, and a way to pause for an approval or choice.
AG-UI standardizes the event stream between an agent backend and a user-facing application. It covers run lifecycle, messages, tool calls, and state without prescribing whether the client is a browser, mobile app, terminal, or chat surface.
A2UI covers an adjacent problem: what the application renders. It uses declarative component descriptions from a client-owned catalogue, so a client can render native widgets without executing arbitrary code sent by the agent.
AG-UI carries the interaction. A2UI describes the interface. An A2UI payload can travel over AG-UI, A2A, or another transport. Both specifications are promising, but their current versions are still forming.
5. Capability formats provide instructions and knowledge
Connections do not give an agent domain knowledge. Repository rules, company procedures, examples, scripts, and task-specific references cannot all live in the model or base prompt.
The simplest delivery layer is the filesystem. AGENTS.md gives coding agents a predictable place to find project instructions. Agent Skills packages instructions and knowledge in a directory with a required SKILL.md and optional scripts, references, and assets. An agent discovers a skill from its metadata, then loads the full content only when it is relevant.
Plugins package these capabilities for distribution. Claude Code plugins are product-specific and can include skills, agents, hooks, MCP servers, and other components. The Agent Plugins specification defines a smaller portable package built around Agent Skills and MCP server configuration. Its 1.0 specification is published, but real portability across clients still needs to be demonstrated.
6. OpenTelemetry GenAI connects operational tools
Once an agent crosses several boundaries, operators need to follow the complete run. OpenTelemetry GenAI semantic conventions provide shared names and attributes for model calls, agent and workflow invocations, planning, tool execution, and MCP activity.
This is an operational vocabulary, not another communication protocol. It lets one trace connect an agent run to the model and tool activity beneath it. OpenTelemetry is mature, but the GenAI conventions remain in Development, so implementations should pin the version they use.
7. ACP connects coding agents to IDEs
The final boundary appears during development. An IDE and coding agent need to initialize a connection, create and resume sessions, exchange prompts and progress, mediate permissions, and cancel work.
The Agent Client Protocol standardizes that relationship using JSON-RPC. Capability negotiation gives editors and coding agents a shared core while allowing optional functions when both sides support them.
ACP is specific to the IDE and coding-agent boundary. It does not replace AG-UI for user-facing applications or MCP for tools. ACP v1 remains stable, while v2 is still experimental and can change incompatibly.
The takeaway
These standards do not form a mandatory stack. They define replaceable connections around an agent.
read image descriptionALTComparing emerging AI agent standards by steward, purpose, and what each standard maps to, including Open Responses, MCP, A2A, AG-UI, A2UI, AGENTS.md, Agent Skills, plugins, OpenTelemetry GenAI, and ACP.
Comparing emerging AI agent standards by steward, purpose, and what each standard maps to, including Open Responses, MCP, A2A, AG-UI, A2UI, AGENTS.md, Agent Skills, plugins, OpenTelemetry GenAI, and ACP.
Adopt one when you need to change what sits on the other side of that boundary without rewriting the agent itself. Start with model access. Add MCP when the agent needs tools, A2A when it delegates to remote agents, AG-UI and A2UI when people need to interact with it, capability formats when it needs organization-specific knowledge, OpenTelemetry when the run needs operational visibility, and ACP when a coding agent must work across IDEs.That boundary-first view is more useful than treating every new specification as a competing agent protocol.
Check out the full post on my newsletter https://generativeprogrammer.com/p/the-emerging-standards-behind-ai
Similar Articles
The 'agent web' is coming — where AI agents talk directly to each other instead of scraping websites
The article discusses the future of AI agents communicating directly with each other via APIs and protocols like MCP, bypassing human-oriented web interfaces, and the author asks the community about adoption timelines and use cases.
@SuJinyan6: https://x.com/SuJinyan6/status/2073955240349770069
This blog post by SuJinyan6 examines the evolution of AI agents from simple LLM+tool use to context engineering and long-running harnesses, citing Anthropic's recent work and discussing how agent capability is now a system-level property involving multiple components.
New tools for building agents
OpenAI launches new tools for building agents including the Responses API, built-in tools (web search, file search, computer use), Agents SDK, and observability features designed to simplify agentic application development.
@Saboo_Shubham_: Google just dropped a 50-page guide on AI Agent tools and interoperability. It covers the open protocols including MCP,…
Google released a free 50-page guide on AI Agent tools and interoperability, covering open protocols such as MCP, A2A, A2UI, AP2, and UCP.
@0xCodez: https://x.com/0xCodez/status/2089393338977829278
This article outlines a 12-step roadmap for AI Agent Engineers in 2026, focusing on seven interconnected pillars like context, tools, and memory, with Claude-based workflows to build reliable production agents.