Why AI Needs A Common Language

As AI clients move from data consumers to active intermediaries, they need structured communication, not just secure APIs or natural language. Natural language is too ambiguous for reliable agent interaction. To scale multi-agent systems safely, we need infrastructure that is auditable, structured, and designed for machine coordination.

We’ve built APIs assuming the client is a person or a service acting on a person’s behalf. But that’s no longer the norm. Increasingly, the client is an autonomous model — a system that doesn’t just query data, but interprets user intent, synthesizes context, and generates actions.

These models aren’t just consuming data, they’re also shaping what gets requested. They act as intermediaries. And that means they need more than secure endpoints or user-auth logic. They need rules of engagement. They need to communicate.

We’ve started discussing how to guide AI behavior through safeguards like harm limiting . But that’s only half the story. The next question is this:

What infrastructure do we need for AI systems to interact with each other?

That’s not just a hypothetical. At WunderGraph, we’ve started building toward that future with Cosmo , our GraphQL federation platform. By integrating Anthropic’s Model Context Protocol (MCP), Cosmo acts as a structured interface between AI agents and APIs—turning autonomous models into first-class API consumers.

We like to imagine models "understand" language, but really, they calculate probability distributions over text. Natural language is ambiguous, sensitive to phrasing, and full of human context that models don't inherently grasp.

At the end of the day, it’s still a computer—just bits and bytes.

Even small tweaks in wording can lead to large shifts in behavior. This makes natural language a risky foundation for AI-to-AI interaction.

A Stanford-led study with contributions from Google DeepMind on multi-agent LLM simulations found that coordination often broke down due to unclear or overly natural instructions. The agents failed not because they lacked reasoning, but because they lacked shared structure and struggled to maintain consistent memory across interactions.

Structured communication, using defined schemas, roles, and formats, is how we get repeatable results. It’s how we make multi-agent systems predictable instead of fragile. There’s growing interest in how structured, non-natural formats might improve model-to-model communication, especially in low-latency or high-frequency use cases.

Today, most LLMs operate alone. They’re prompted in isolation, occasionally extended with tools or plugins. But real-world reasoning is collaborative. Humans work in teams. A general practitioner consults a specialist. A software engineer hands a design off to QA. Each role carries unique capabilities, and coordination is what makes complex work possible.

We need models to do the same: specialize, delegate, collaborate.

The Agora Protocol , developed by researchers at Oxford, enables foundation model agents “to autonomously choose which communication protocol to use when collaborating with other agents.” The system takes inspiration from human coordination: “Humans often adopt or negotiate a shared protocol […] when collaborating.” That flexibility depends on agents sharing “a semantic understanding of protocol documents.”

One key tension I keep coming back to is whether any one protocol can become standard before the ecosystem consolidates. We’re still in a race, and until there is a clear winner in the AI race, I don’t think we’ll see the kind of broad standardization these protocols need.

Model-to-model communication today is mostly ad hoc. Agents send plain-text instructions or JSON blobs over HTTP. That works for simple use cases, but it breaks down fast as complexity grows.

What we need instead is a real protocol—one that carries not just data, but roles, goals, capabilities, and trust signals. These aren’t just metadata tags. They’re the scaffolding of intelligent coordination.

Anthropic’s Model Context Protocol (MCP) is an early attempt at this. It standardizes how models retrieve and interact with structured context.

I think about MCP as a kind of USB-C port for AI knowledge and tools—one standardized interface that lets models plug into new contexts.

We’ve implemented this approach directly at WunderGraph. In Cosmo, MCP (currently in beta) acts as the interface that lets federated GraphQL services expose structured, permissioned APIs to intelligent agents. Instead of stitching together brittle prompt-based integrations, agents can now speak to backends through a standardized layer—defined by schema, enriched by context, and governed by federation.

It’s not the final answer—but it’s the kind of infrastructural thinking this moment demands.

The LangChain team has echoed this shift, noting: “The biggest challenges with agents have not been the models, but the communication.” They now focus on structured orchestration—not just prompting—as the path to reliable, scalable systems.

Models operate within hard limits. Context windows, memory constraints, inference boundaries. They hallucinate. They forget.

As Park et al. noted in their study:

“Generative agents’ memory was not without flaws: they can fail to retrieve the correct instances from their memory.”

Structured input doesn’t fix these issues, but it helps hold probability in place.

And when we chain models together, or ask one to manage many, the system becomes more fragile. Without shared assumptions or consistent formats, every handoff is a risk. Structure is the way we manage that complexity.

We’re not just designing for developers anymore. If models are going to act on behalf of everyday users, especially people without a technical background, they need infrastructure that can be trusted without being manually verified. Most users, and especially those outside of engineering, aren’t going to know how to read API calls. They won’t even know what they’re looking at.

We’re still designing APIs like the end user is a person. We build docs, guides, and developer portals. But future clients won’t be people. They’ll be systems. They won’t read Swagger docs or OpenAPI specs—they’ll parse protocols.

Agents will become the dominant API consumers. They’ll make decisions, request data, and delegate sub-tasks. For that to work, APIs need to be machine-readable and semantically structured.

Google’s A2A (Agent-to-Agent) Protocol uses JSON schemas and capability graphs to structure agent interactions—no UI, no human prompt engineering.

One emerging idea from the agent infrastructure community is an agents.json file, like robots.txt, but for AI clients. Proposed by researchers at UC Berkeley and Interagent.org, it would let agents discover what APIs a system offers, under what rules, and how to authenticate. A related proposal, llms.txt , focuses on how websites can offer structured, markdown-readable summaries and key resources to language models. Both aim to formalize how AI systems interpret and access digital environments. They’re not standards yet, but it’s the kind of machine-native thinking that aligns with where this ecosystem is heading.

Anthropic has emphasized that AI safety isn't just about output filters, but designing systems that are interpretable, controllable, and grounded in a reliable context. That vision implies structure. As they put it in their AI Harms framework, safety requires models to behave predictably even under distributional shifts, which is only possible when communication is well-bounded and auditable.

Protocols also create boundaries—machine-readable guardrails that can encode trust, provenance, and permissions into every exchange. This isn’t just about coordination, it’s about control. Just as we need to know what a model is allowed to do, we also need to understand what information it is passing on and why it can be trusted.

The Partnership on AI has emphasized this need in their guidance on safe foundation model deployment: machine-readable usage policies and verifiable outputs are essential for ensuring responsible behavior in agentic systems.

AI systems are becoming actors. That means we need more than safety filters or rate limits. We need a communication layer. We need a protocol stack.

Just like humans rely on grammar and context to collaborate, models will need structure to align. The point isn’t to slow things down, it’s to make them possible.

This isn’t just strategy—it’s infrastructure. WunderGraph is building toward that protocol-native future, where agent interactions are auditable, composable, and context-rich from the start.

The foundation is already here. We just need to agree on how to use it.

The future of APIs isn’t human-first. It’s machine-readable, agent-native, and protocol-driven.

If we want machines to collaborate safely and effectively, the language they speak needs to be designed, not assumed.

At WunderGraph, we are already putting this infrastructure into practice. Our MCP Gateway extends Cosmo with a protocol-native layer that makes APIs machine-readable for intelligent agents, using Anthropic’s Model Context Protocol.

Cosmo’s MCP Gateway helps you expose structured, permissioned APIs to intelligent agents with secure discovery, controlled execution, and rich metadata. It eliminates brittle prompt engineering and enables machine-native communication. Learn more about the MCP Gateway .

Jens, our CEO, has written more about this work:

• How MCP is reshaping software development
• How Cosmo automates GraphQL Federation with MCP

• Anthropic: Introducing the Model Context Protocol
• Generative Agents (Park et al., 2023), Stanford University with contributions from Google DeepMind
• Agora Protocol, (Marro et al., 2024) Oxford University
• LangChain: Communication is All You Need
• Google Cloud: A2A Protocol
• Agents.json Proposal
• llms.txt Proposal