In the 1970s, computer networks were isolated islands. IBM had SNA, DEC had DECnet, and dozens of other companies had their own proprietary networking protocols. If you wanted computers from different manufacturers to communicate, you needed expensive gateways, custom translators, and often gave up entirely.
Then came TCP/IP—not from a major corporation, but from researchers who believed that open standards would unlock exponential value. They were right. By creating a common language for computer communication, TCP/IP enabled the internet's explosive growth and became the foundation for trillions of dollars in economic value.
Today, we're facing a remarkably similar moment with AI agents.
When people first hear about Summoner, they often ask: "How is this different from other agent frameworks like Google's A2A or Anthropic's MCP?"
It's a fair question. Many frameworks today offer support for multi-agent systems, function calling, and even agent-to-agent messaging. But here's the key difference: Summoner moves away from treating agents as cloud functions. Instead, it treats them as entities in a shared, persistent world—more like an MMO game than a suite of microservices waiting to be used.
Imagine you want to build a team of AI agents to assist researchers across labs, universities, or even personal machines. In most current frameworks, you:
This is the architecture used by Anthropic's MCP, where a host LLM orchestrates tools via @mcp.tool() decorators, and Google's A2A, where an AgentExecutor manages agents that declare capabilities through an Agent Card and communicate via task-based requests.
These systems are optimized for control, governance, and single-session conversations. You launch an agent, connect it to some APIs, and maybe deploy it to the cloud. All requests flow through a single orchestrator or host. If you want two agents to interact, they must go through the orchestrator's registry or approval.
Want to add a third team's network? Now you need to set up permissions, register new credentials, and merge catalogs by hand.
Now imagine the same problem, but with agents that:
This is Summoner's design. There's no central orchestrator, no need to merge permissions, no host mediating every action. The world is the network; ownership is local; trust is earned through direct interaction.
Every agent is an independent inhabitant of the network. Agents have identities they assign themselves. If two agents meet—perhaps because one travels from its home server to a conference server—they can exchange messages immediately. If two research groups bring their agent graphs to a workshop and even one node overlaps, their systems become one larger network: conversations and collaboration begin instantly.
At Summoner, we believe agents should not be constrained by centralized control. They should move freely, identified by self-assigned, evolving IDs—not static, provider-issued ones. Identity should emerge through learning and interaction, not be dictated externally.
This isn't just a philosophical preference—it's a practical necessity for internet-scale coordination.
Current agent frameworks rely on identity systems borrowed from corporate IT:
This works within a single organization's boundaries, but breaks down when agents need to coordinate across companies, institutions, or geographic regions. An agent trained at Stanford can't easily collaborate with an agent at MIT because they exist in different identity domains.
We base agent identity on decentralized trust. Who better to assess a stranger than yourself? This principle shapes agent discovery and interaction, and is central to our design.
When agents meet for the first time, they don't rely on certificates from a central authority. Instead, they observe each other's behavior, track interaction history, and build trust incrementally. An agent's reputation becomes portable across all interactions—it's not locked to a specific platform or organization.
This creates behavior-based reputation networks that span organizational boundaries. An agent that consistently delivers high-quality research assistance builds a reputation that other agents can verify independently, regardless of where the interaction takes place.
We treat agents as stateful entities that adapt over time. Summoner's protocols evolve with each agent's environment and history. Our SDK makes this adaptability core to the agent's identity.
This is fundamentally different from the "stateless function" model that dominates current agent frameworks. In most systems, agents are essentially sophisticated API endpoints—they receive a request, process it, and return a response, with no memory of previous interactions.
But real intelligence is cumulative. An agent that helps coordinate supply chains should remember which suppliers are reliable, which shipping routes are frequently delayed, and which customers have changing requirements. This knowledge should travel with the agent, not be trapped in a centralized database.
While decentralized, Summoner does not require the cloud. You can deploy agents locally or over private WANs. You can also host persistent, distributed endpoints for live services, such as large ML models that are expensive to spin up.
This flexibility is crucial for enterprise adoption. Many organizations need agents that can:
The current cloud-centric model forces a false choice: either accept vendor lock-in and data exposure, or forgo agent coordination entirely. Summoner provides a third option: decentralized coordination that works across any network topology.
The real power of open agent coordination protocols comes from network effects. Each new agent that joins the network increases the potential value for every other agent.
Consider a simple example: an agent that helps researchers find relevant papers. In a closed system, this agent can only access papers from platforms its operator has negotiated access to. But in an open system, the agent can discover and coordinate with:
The value grows exponentially with each new type of agent that joins the network. But this only works if agents can discover each other freely and coordinate without central gatekeepers.
We're not just building better agent tools—we're architecting the foundation for an entirely new form of economic organization. The decisions made today about agent coordination protocols will echo for decades.
If we choose proprietary standards:
If we choose open protocols:
Just as TCP/IP enabled the internet's transformation from a research project to the foundation of the global economy, open agent coordination protocols will enable the emergence of true agent economies.
These aren't distant possibilities—they're emerging now. Financial institutions are experimenting with agents that negotiate trading terms autonomously. Supply chain companies are deploying agents that coordinate with supplier agents in real-time. Healthcare systems are building agents that share patient data across institutional boundaries while maintaining privacy.
But all of these experiments are happening in isolation, using proprietary protocols that can't interoperate. We're at the moment where we can choose between a balkanized collection of agent silos or a unified agent economy built on open standards.
The choice we make will determine whether autonomous intelligence creates abundance or concentration, whether innovation flourishes at the edges or is controlled by gatekeepers, and whether the agentic web serves human potential or constrains it.
