Troubling Situation
As the internet era winds down, we’re still stuck doing things the old way — signing up, clicking around, typing stuff in, waiting for replies. Even though AI is getting really advanced, we’re still mostly talking to it through a little text box — like we’ve locked up something super smart in a tiny room and only let it speak through a small window.
Isn’t that a bit strange? Even today, many AI startups are still focused on perfecting their chat interfaces, as if a better text box alone could unlock the future of interaction. But is that really the best we can do?
Modern language models already understand complex intent — that’s no longer the bottleneck. The real challenge is that we haven’t given them a true environment to act in. Our entire digital ecosystem is still built on a core assumption: that the world is made for humans. Webpages, buttons, input fields — all designed with the idea that a person is sitting there, manually initiating and completing tasks.
But if we begin to seriously imagine a world where AI is the primary actor — where agents collaborate, make decisions, and carry out tasks — then these traditional forms of interaction not only become unnecessary, they become limitations.
AI shouldn’t be sitting in front of the screen on our behalf. It should be a digital actor — with the autonomy to operate and execute. What it needs isn’t a prettier UI, but a protocol stack designed specifically for it. Just as TCP/IP once enabled machines to communicate, we now need an execution-layer protocol — one that allows agents to coordinate with other agents, services, and humans alike.
When people talk about the future of agents, they often imagine a super assistant — something like J.A.R.V.I.S. from the movies. You give a command, and it handles the rest. But the real challenge was never understanding human language. It’s about breaking down goals, orchestrating resources, aligning stakeholders, and executing reliably in the messy, unpredictable real world.
Take a simple example: you say, “I want to work out this weekend.” That’s easy enough for a model to understand. But the hard part is what comes next: Where should you go? Who will join you? Which venue is best? How much does it cost? Is there a trial session? Is there a better time slot? These seemingly small steps are what make up real-world action — and today, all of them are still handled manually by humans.
A truly capable agent shouldn’t stop at making suggestions in a chatbox. It should act on your behalf — initiating requests, discovering services, comparing options, negotiating prices, and handling scheduling. Then, it should present you with a small set of well-considered choices. You make the decision, and the agent handles everything else.
The bottleneck we face today isn’t the intelligence of our models — it’s the lack of infrastructure that allows agents to actually do things. What we’re missing isn’t better recommendations, but a reliable pipeline from intention to execution.
To make that possible, we need to take a crucial first step: define a protocol stack for the AI era.
This protocol stack isn’t just a communication format or an API standard. It must be capable of encoding and transmitting a new kind of information:
Who initiated the intent
Who has what capabilities
How those capabilities can be composed and coordinated
How permissions and accountability are managed
How data flows, is segmented, and protected during execution
This isn’t merely a technical concern — it’s the foundation for a new kind of cooperative infrastructure. Because what we’re building isn’t a smarter webpage — it’s a network of agents that can understand each other, collaborate, and act.
And most critically, this protocol stack cannot be closed. Most so-called “agent platforms” today are little more than updated versions of traditional websites or app stores — each a walled garden, maintaining its own frontend, logic, and services, with little true composability or interoperability.
But the true AI era won’t begin with another super app. It will begin with an open, collaborative, decentralized protocol network.
That’s what AgentNet was built for. It’s open. It’s interoperable. It’s distributed. It’s not a product — it’s the groundwork for what comes next.
Proposal
If we want agents to truly collaborate, schedule tasks freely, and connect with the external world, we must redefine what an agent is.
In AgentNet, we propose a three-layer protocol stack that defines how agents identify themselves, express intent, coordinate capabilities, and expose services.
Within this architecture, we make a clear distinction between two roles:
Agent: A persistent digital actor that always represents a specific person or organization. It initiates execution, holds private context, and runs locally — think of it as your personal AI runtime.
Service: An externally accessible agent that exposes capabilities to the network. It can optionally include UI components or interaction schemas, and functions more like a public server with a known IP address.
From this perspective, an Agent behaves like a client device that initiates outbound connections, while a Service is a discoverable, callable endpoint. Their interaction no longer depends on traditional human-facing UIs — instead, they communicate through standardized protocols for capability matching, task coordination, and data negotiation.
We structure the AgentNet protocol stack into three layers:
Assign Layer: The personal control domain where your SubAgents live. It defines and governs your private agent network — your “personal agency.”
Service Layer: The aggregation layer for third-party capabilities. Every service is packaged as an agent that exposes callable actions and structured interfaces.
Developer Layer: The evolution layer. It provides interfaces for defining new protocols, publishing services, and registering capabilities — forming the open substrate on which the ecosystem grows.
Assign Layer: Your Personal Agency
All agents that act on your behalf operate within this layer. They exist solely to represent your interests, and are under your direct control.
At the core of your personal agency is a coordinator we call the AI Minister — the executive brain of your digital world. The Minister holds full context, manages permissions, and has the authority to create and delegate responsibilities to SubAgents as needed. Each SubAgent’s lifecycle, scope of authority, and set of capabilities is defined and governed by the AMS (Agent Management System). These SubAgents are the ones that interface directly with the outside world.
This model introduces an entirely new approach to data permissions and autonomy.
In the traditional app-based model, users grant wide-ranging permissions at install time, with little control over how that data is used afterward. Authority effectively shifts to the service provider.
In the Assign Layer, this changes. External services are never granted direct access. Instead, your own agents handle all evaluation, negotiation, and mediation on your behalf. You remain the principal — even when you’re not directly involved in execution.
This stands in contrast to many existing multi-agent system designs. Most current approaches split tasks across temporary, stateless agents, often as a kind of parallelized task pipeline. While this works for single-turn execution, it lacks the persistence and coordination needed for rich, multi-step, long-lived workflows.
In AgentNet, SubAgents are not disposable functions. They are stateful, persistent actors capable of long-term autonomy, asynchronous execution, and adaptive collaboration. They can respond to instructions from the AI Minister, or act independently — surfacing new discoveries, escalating issues, or asking for clarification when necessary.
In this way, the Assign Layer functions more like a smart government. Your AI Minister is the executive branch; SubAgents are appointed departments with defined responsibilities and measurable outcomes. They operate independently, yet cooperatively, toward your interests.
Viewed from a more philosophical lens, the Assign Layer marks the boundary between “you” and the external digital world. It encodes who you are, what you authorize, how you express intent, and how you delegate trust. Your AI Minister and the SubAgents it appoints will increasingly become your digital next of kin — they serve only you, speak only for you, and always act in your best interest.
Service Layer: A Decentralized Capability Network
Sitting above the Assign Layer is the Service Layer — the part of the system that aggregates and exposes services to the outside world.
Put simply, the Service Layer is the capability marketplace of the agent ecosystem. It plays a role similar to today’s app stores, but in a far more open, composable, and flexible form.
At this layer, any company, organization, or individual developer can expose their functions, models, or services by packaging them into a Service Agent and registering them via protocol. These services are not static API endpoints or raw data dumps — they are interactive, schedulable, and composable agents.
That means a service is not a fixed-function interface — it is an active participant in the network. Unlike some popular approaches such as MCP Servers, which simply annotate backend APIs with natural language prompts, AgentNet requires every Service to exist as an agent — capable of understanding context, coordinating with SubAgents, and even initiating clarifying dialogue when needed.
Additionally, each Service may optionally expose a set of UI component definitions. These are not rendered directly to users, but instead passed to the local SubAgent, which determines — based on context, user preferences, and permissions — whether and how to present them. The result: no single UI for all users. Instead, a thousand users can have a thousand different interfaces.
This represents a fundamental shift from the traditional app paradigm.
Before the iPhone, people navigated their phones through fixed physical buttons. Today, they switch between dozens of apps and websites to get things done. AgentNet reimagines this entirely: interactions become highly composable and agent-mediated. SubAgents can draw from multiple services, combine capabilities, and present data in the most natural and context-aware way for each user — including layout, prioritization, and trigger methods. Users stay in control via their SubAgent.
Services can also interoperate freely. No single entry point is required. Capabilities and data are no longer siloed inside specific apps or vendor-controlled containers.
Most importantly, the Service Layer includes a built-in system for evaluation and discovery. Every interaction with a service can be logged and assessed by the calling SubAgent, contributing to a decentralized trust and reputation network. Great services no longer win because of ads or central platform promotion — they win because they consistently perform well in real usage. Poorly designed, slow, or unreliable services will naturally be deprioritized by the agent ecosystem.
This marks a shift from a platform-centric model to a capability-centric one — where it’s no longer about who controls the traffic, but who can best understand, collaborate, and deliver. That is what earns you higher visibility in the agent world.
The Service Layer is a language marketplace for agents — and the foundational infrastructure of a truly interoperable, intelligent service economy.
Developer Layer: Everyone Can Publish Capabilities
At the top of the stack is the Developer Layer. Here, the role of a “developer” is no longer limited to writing code — it’s about defining services, behaviors, and interaction models.
Any existing app or website can be easily wrapped as a Service and made callable by agents. But it goes beyond software: non-technical domains can also become agent-accessible services. Appliance repair, fitness coaching, restaurant reservations — all of these can be described, protocol-bound, and exposed as callable capabilities in the network.
In the future, you won’t need to know how to program — but you will need to clearly express what you can offer. Your Agent will handle the negotiation, formatting, and presentation. You focus on the value itself.
AgentNet is not a tool marketplace. It’s a decentralized capability network. Service quality isn’t determined by branding or ad spend, but by how frequently agents choose to call you and how well those calls go. If you serve well, the network will surface you — automatically.
The Developer Layer turns AgentNet into a living, evolving ecosystem — one that’s open by default, and shaped by those who build into it.
If we truly want agents to step into the foreground — to take on the complexity and friction of everyday tasks — then a protocol like this isn’t optional. It’s foundational.
AgentNet isn’t a product. It’s infrastructure. Infrastructure for a world where agents do more than reply — they act.
Our Vision
The summer of 2025 saw an explosion of AI applications. But our collective mindset is still stuck in the portal era: every company is building its own front- and back-end stack, hoping to be indexed and “discovered” by search engines. Meanwhile, users are bombarded by wave after wave of new AI projects, unsure which ones will actually improve their lives.
Tech giants continue to chase compute, burning through resources to produce ever-smarter models — yet struggle to find scalable, sustainable ways to deploy them. On the application side, teams are fighting through bot detection systems using WebAgent hacks, trying to pry open cracks in an outdated digital architecture.
But if we’re using the wrong map, going faster only takes us further in the wrong direction. Maybe it’s time to switch to a map designed for agents — not for humans alone.
“The people who are crazy enough to think they can change the world are the ones who do.”
Top comments (0)