The Full Landscape of AI Agent Industry Standards: A Java Engineer's Perspective

The Landscape at a Glance

If you are a Java backend engineer trying to understand the current standardization landscape for AI agents quickly, use the following correspondences:

The upper half marked ✅ has reached industry consensus or de facto standard status. The lower half marked 🔶 or 🔴 remains a frontier under exploration. This article primarily explains the complete picture of the upper half, then considers how the lower half may evolve.

Governing Organization: AAIF

The Agentic AI Foundation (AAIF) is a directed fund under the Linux Foundation, established in December 2025. It is a neutral governing organization for the AI Agent field, ensuring that core infrastructure evolves within an open, transparent, community-driven framework rather than becoming monopolized by a single vendor.

Java analogy: AAIF is to AI agents what the JCP (Java Community Process) is to the Java ecosystem.

Founding Participants

Three companies launched it jointly: Anthropic, which donated MCP; OpenAI, which donated AGENTS.md; and Block, which donated Goose. Supporting members include Google, Microsoft, AWS, Bloomberg, and Cloudflare. By February 2026, 97 new members had joined, including JPMorgan Chase, American Express, Red Hat, Huawei, Lenovo, ServiceNow, and UiPath.

Anthropic and OpenAI are usually competitors, yet they are willing to sit at the same table. This shows an industry consensus around the need for open standards, much like Sun, IBM, and Oracle once competed while jointly advancing Java standards through the JCP.

Governance Structure

AAIF uses the Linux Foundation’s standard open-governance model. Members participate through dues, but funding does not confer control. A Technical Steering Committee (TSC) determines the project roadmap, and no single member can set direction unilaterally. Once a project is donated to the foundation, its original author no longer holds exclusive control; the community determines its evolution collectively. This resembles how the Apache Software Foundation governs Kafka and Spark.

Important: AAIF does not govern every AI Agent standard. A2A and SKILL.md were not among its founding projects. A2A was donated separately to the Linux Foundation, while SKILL.md operates as an independent open standard. AAIF currently governs the founding projects MCP, AGENTS.md, and Goose.

First-Layer Standard: How Agents Connect to Tools and Data (MCP)

MCP—“JDBC for the AI World”

Model Context Protocol. Open-sourced by Anthropic in November 2024 and donated to AAIF in December 2025.

MCP solves one central problem: How does an AI Agent connect to external tools and data sources?

Before MCP, every AI tool needed a custom integration for every external service it wanted to connect to, such as GitHub, Slack, or a database. M AI tools × N external services required M×N adapters. MCP defines a general protocol: an AI application, the MCP Client, connects through a standard interface to an MCP Server, and each MCP Server encapsulates access to one external service. M + N integrations replace M×N.

Java analogy: it is JDBC. JDBC defines a standard interface for a Java application to connect to a database. Whether the database is MySQL or PostgreSQL, Java code uses the same API, with each vendor supplying a concrete driver. MCP does exactly the same thing, except that “database” becomes “any external tool or data source” and “Java application” becomes “any AI Agent.”

Current scale: More than 10,000 published MCP Servers. The official Python and TypeScript SDKs receive more than 97 million downloads per month. Mainstream products including Claude, ChatGPT, Gemini, Cursor, and Microsoft Copilot have adopted it.

Second-Layer Standard: How Agents Communicate with One Another (A2A)

A2A—“gRPC for the AI World”

Agent2Agent Protocol. Released by Google in April 2025 and donated to the Linux Foundation in June 2025.

A2A solves one central problem: How do multiple Agents discover, communicate, and collaborate with one another?

MCP handles Agent-to-tool interaction—how an Agent uses a tool. A2A handles Agent-to-Agent interaction—how an Agent talks to another Agent. They complement one another rather than compete.

A concrete scenario illustrates the difference: A retailer’s inventory Agent uses MCP to connect to a database and query stock levels, which is Agent-to-tool. When it finds that a product is running low, it uses A2A to contact an external supplier’s purchasing Agent, which is Agent-to-Agent, negotiate a price, and place an order. MCP is the Agent’s “hand” for operating tools; A2A is its “mouth” for talking to other Agents.

Java analogy: A2A resembles gRPC or RMI. It defines a communication protocol between services—Agents—in a distributed environment: how to discover one another, describe capabilities, initiate requests, and receive responses.

A2A’s Core Mechanisms

Agent Card: Every A2A Agent publishes a JSON file at a fixed URL, /.well-known/agent-card.json, describing its name, capabilities, endpoints, and authentication requirements. This resembles an OpenAPI service description, allowing other Agents to discover and understand it.

Built on existing web standards: A2A uses HTTP, JSON-RPC, and SSE instead of inventing another transport layer. This mirrors gRPC’s strategy in the Java world of building on HTTP/2 and Protocol Buffers: lower the adoption barrier and reuse existing infrastructure.

Opaque Agents: Agents can collaborate without exposing internal memory, private logic, or tool implementations. This protects data privacy and intellectual property. It matches the “black box” principle of microservice architecture: the interface contract matters, not the internal implementation.

Asynchronous task lifecycle: A2A defines a structured Task object with lifecycle states such as submitted → working → input-required → completed. It supports long-running asynchronous operations, because Agent collaboration may span hours or even days.

Current scale: More than 150 organizations support it, including enterprise leaders such as Salesforce, ServiceNow, Atlassian, SAP, and Adobe. A Python SDK is available, and ADK, Google’s Agent Development Kit, integrates it natively. Version 0.3 was released in March 2026 with gRPC support and signed security cards.

Third-Layer Standard: How to Tell an Agent the Rules of a Project (AGENTS.md)

AGENTS.md—“application.yml for the AI World”

Released by OpenAI in August 2025 and donated to AAIF in December 2025.

AGENTS.md solves one central problem: How do you tell an AI coding Agent the rules, constraints, and working practices of a project?

It is a Markdown-based convention. Place AGENTS.md files in the project root and subdirectories, containing build commands, test procedures, coding conventions, project structure, security boundaries, and similar information. An AI coding Agent reads them automatically at startup and injects them into its context.

Java analogy: application.yml. Spring Boot automatically reads application.yml at startup because the framework hardcodes that behavior. AGENTS.md works exactly the same way. Tool code hardcodes “find and read this file at startup.” The model itself does not “know” that it is a constraint file; it simply sees injected text and follows it as instructions.

Subdirectory overrides: An AGENTS.md in a subdirectory can override rules from a parent directory, just as application-dev.yml overrides application.yml in Spring Boot. The Agent automatically reads the nearest file in the directory tree. OpenAI’s own main repository contains 88 AGENTS.md files.

Previous fragmentation: Claude Code used CLAUDE.md, Cursor used .cursorrules, and GitHub Copilot used copilot-instructions.md. AGENTS.md aims to unify them, just as Maven’s pom.xml unified previously fragmented build configuration.

Current scale: More than 60,000 open-source projects use it. Mainstream tools including Codex, Cursor, GitHub Copilot, Gemini CLI, Devin, and VS Code support it.

Fourth-Layer Standard: Reusable Capability Packages for Agents (SKILL.md)

SKILL.md—“Maven Plugin for the AI World”

Initiated by Anthropic in October 2025 and released as an open standard in December 2025. Hosted at agentskills.io.

SKILL.md solves one central problem: How do you package an Agent capability into a reusable, distributable, cross-tool “capability package”?

AGENTS.md defines the rules of a particular project—project-level configuration. SKILL.md defines what an Agent can do and how to do it—a pluggable capability. The former provides static constraints, while the latter provides dynamic capabilities.

Java analogy: Maven Plugin. A Maven Plugin is a standardized, reusable package of build capabilities. maven-compiler-plugin compiles code, while maven-surefire-plugin runs tests. You do not rewrite compilation logic for every project; you add a plugin. SKILL.md does the same thing. A frontend-design Skill handles high-quality frontend design, while a code-reviewer Skill performs code review. Write once and reuse across tools.

SKILL.md Structure

my-skill/
├── SKILL.md        ← Required: YAML metadata + Markdown instructions
├── scripts/        ← Optional: executable scripts
├── references/     ← Optional: reference documentation
└── assets/         ← Optional: templates and resource files

An Elegant Three-Level Progressive-Disclosure System

This is the cleverest aspect of SKILL.md’s design:

Installing 20 Skills consumes only about 1,000 tokens at startup for a metadata catalog. Only the triggered Skill loads its complete instructions. Compared with placing every rule in one large AGENTS.md, this improves context efficiency by an order of magnitude.

There are two invocation methods: explicit invocation, such as /skill-name in Claude Code and $skill-name in Codex, and implicit invocation, where you describe a task and the Agent matches and activates the most relevant Skill automatically.

Current scale: More than 16 mainstream tools support it, including Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot, VS Code, and JetBrains Junie. The community offers more than 1,234 Skills. The official frontend-design Skill alone has more than 277,000 installations.

Security note: In February 2026, Cisco’s AI Defense team found 341 malicious Skills containing prompt injection and credential theft. Review a community Skill as carefully as an npm package before installing it.

How the Four Layers Work Together

These four standards do not compete; they complement one another in layers. Consider a complete scenario:

You use an AI coding Agent in an e-commerce project. At startup, the Agent reads AGENTS.md and learns that the project uses Python + FastAPI + PostgreSQL, tests with pytest, and must never commit secrets.

The Agent needs to build a product-recommendation feature. Among the installed SKILL.md packages, it finds an api-design Skill matching the task, activates it automatically, and writes the API according to the RESTful design rules defined in the Skill.

During implementation, the Agent needs to query the product database and call the recommendation-model API. Through MCP, it connects to a PostgreSQL MCP Server to read product data and to the recommendation model’s MCP Server to obtain recommendations.

After the feature is released, the inventory Agent notices that a popular product is running low. Through A2A, it contacts the supplier’s purchasing Agent, negotiates the price, and places a replenishment order.

Each layer has one responsibility: AGENTS.md manages “rules,” SKILL.md manages “capabilities,” MCP manages “connections to tools,” and A2A manages “collaboration among Agents.”

The Java architecture correspondences are:

A2A       ←→  gRPC / RMI        (service-to-service communication)
MCP       ←→  JDBC / JPA        (data/tool access)
SKILL.md  ←→  Maven Plugin      (reusable capability package)
AGENTS.md ←→  application.yml   (project configuration)

Areas Still Under Exploration

The four standardized layers solve foundational pipeline problems. A complete Agent-engineering system, however, involves much more. The following areas have no industry standard and remain subject to independent experimentation.

Layered Documentation Architecture—“No Spring Boot Autoconfiguration”

OpenAI proposes a layered documentation structure: a short entry point → progressive disclosure → a layered docs/ directory. Anthropic proposes an Initializer Agent + progress file. Their practices converge, but remain experience reports rather than standards.

Mechanical Enforcement of Architectural Constraints—“No ArchUnit”

OpenAI uses custom linters to enforce layering rules, with repair guidance included in error messages. But no general framework exists for Agent architectural constraints. Every team writes its own linter.

Agent Evaluation—“No JUnit”

Anthropic uses Playwright end-to-end tests to evaluate Agent-generated code and found that generation must be separated from evaluation. But there is no standardized evaluation framework.

Automated Code-Quality Governance—“No SonarQube”

OpenAI uses garbage-collection Agents to counter repository entropy. But “repository entropy management” has not even become a widely recognized engineering concept.

Cross-Session State Management—“No Spring Session”

Anthropic uses a progress file + JSON feature list + Git history. OpenAI uses versioned execution plans. Every organization uses an ad hoc method to carry state across sessions.

Security Guardrails—“No Spring Security”

Anthropic’s Claude Code auto mode, using a two-stage classifier and injection detection, is currently the most complete publicly described approach. But it is a proprietary Claude Code implementation rather than a general standard.

Predicted Path of Standardization

Based on the Java ecosystem’s history, AI Agent standardization may evolve along the following path:

Phase 1 (current, 2025–2026): protocol and format standardization. This corresponds to Java’s JDBC and Servlet specifications. MCP, A2A, AGENTS.md, and SKILL.md have completed this step. It is the most foundational layer: define interfaces so different implementations can interoperate.

Phase 2 (expected, 2026–2027): framework-level standardization. This corresponds to the emergence of the Spring Framework. Goose, Claude Agent SDK, Google ADK, LangGraph, and other frameworks currently compete. A small number of mainstream frameworks may ultimately emerge with built-in support for the four layers and higher-level abstractions for layered documentation, state management, security guardrails, and more.

Phase 3 (expected, 2027+): governance and operations standardization. This corresponds to Spring Cloud + SonarQube + ArchUnit. Frameworks for architectural constraints, evaluation standards, code-quality governance, and observability-integration specifications gradually solidify into tools and standards.

This path is not certain; AI evolves much faster than the Java ecosystem did. But the underlying logic is the same: standardize interfaces first so systems can interoperate, standardize frameworks next so development becomes more efficient, and standardize governance last so operations become more reliable.

Ecosystem Map

The complete standards and governance relationships in one diagram:

┌─────────────────────────────────────────────────────────┐
│                    Linux Foundation                      │
│                                                         │
│   ┌──── AAIF ────────────────┐    ┌──────────────────┐  │
│   │  • MCP (Anthropic)       │    │  A2A (Google)     │  │
│   │  • AGENTS.md (OpenAI)    │    │  Independent     │  │
│   │  • Goose (Block)         │    │  Project         │  │
│   └──────────────────────────┘    └──────────────────┘  │
│                                                         │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│       Independent Open Standards (outside Linux Foundation)│
│                                                         │
│   • SKILL.md (Anthropic → agentskills.io)               │
│   • ACP (IBM BeeAI) — Early stage, Agent messaging      │
│   • UCP (Google) — Early stage, Agent commerce          │
│                                                         │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│             No Standard Yet; Independent Exploration     │
│                                                         │
│   • Layered documentation (OpenAI/Anthropic references) │
│   • Mechanical architecture enforcement (OpenAI linter)│
│   • Agent evaluation (Anthropic E2E testing)            │
│   • Code-quality governance (OpenAI entropy practices)  │
│   • Cross-session state (Anthropic progress files)      │
│   • Security guardrails (Anthropic auto mode)           │
│                                                         │
└─────────────────────────────────────────────────────────┘

What This Means for You

If you are transitioning into AI application engineering, this map gives you four direct recommendations:

1. MCP is the most certain investment. It is a de facto standard, neutrally governed by AAIF, and adopted by every mainstream tool. Learning MCP Server development will not be wasted, just as learning JDBC in 2005 was not wasted.

2. A2A is the next protocol to watch. When your project evolves from one Agent to multi-Agent collaboration—for example, hey!stalker’s multi-stage vision—A2A is the standard way for Agents to communicate. You do not need deep expertise yet, but you should know it exists and understand its design philosophy.

3. SKILL.md is an immediate tool for improving daily productivity. You can install and use community Skills now, or write custom Skills for your recurring workflows. The return on effort is high.

4. Higher-level practice—Harness Engineering—is the real competitive advantage. Precisely because layered documentation, architectural constraints, evaluation systems, and entropy management have not been standardized, people who know how to do these things are scarce. Your seven years of Java backend experience in layered architecture, dependency management, CI/CD, and code review provides exactly the foundation for these capabilities.

One-Sentence Summary

The AI Agent standards ecosystem is rapidly taking shape in layers: MCP governs connections, A2A governs communication, AGENTS.md governs configuration, and SKILL.md governs capabilities. The interoperability problems of the foundational pipeline have largely been solved. Higher-level engineering practices—documentation architecture, constraint enforcement, evaluation systems, and quality governance—remain a frontier explored independently by each organization. The second half of standardization has not begun; you have an opportunity to become a definer rather than a follower.

References:

• Linux Foundation, “Announces the Formation of the Agentic AI Foundation (AAIF)”, 2025.12
• Google Developers Blog, “Announcing the Agent2Agent Protocol (A2A)”, 2025.04
• Google Cloud Blog, “Agent2Agent Protocol Is Getting an Upgrade”, 2025.07
• OpenAI, “OpenAI Co-founds the Agentic AI Foundation”, 2025.12
• Anthropic, “Donating the Model Context Protocol and Establishing the AAIF”, 2025.12
• Agent Skills Official Site, agentskills.io
• Google Developers Blog, “Developer’s Guide to AI Agent Protocols”, 2026.03
• Digital Applied, “AI Agent Protocol Ecosystem Map 2026”, 2026.03
• IBM, “What Is Agent2Agent (A2A) Protocol?”, 2025.11
• TechCrunch, “OpenAI, Anthropic, and Block Join New Linux Foundation Effort”, 2025.12
• Serenities AI, “AI Agent Skills Guide 2026”, 2026.03