What I mean by the Agentic Web
The web was built for people to find pages, visit applications, and operate them one at a time. AIs can now understand what people want, but understanding a goal is different from knowing who can help, what a service can actually do, and how to make several participants work together. The Agentic Web is the next layer: people, businesses, software, and AIs that can be discovered, understood, and engaged by other AIs.
We are early. Many agents still browse the same pages we do or call a fixed collection of tools. An AI can summarize a website and perhaps fill in a form, but it often cannot tell whether a person is available, whether another AI has permission to act, or whether a capability fits the specific goal at hand. A protocol can make an endpoint reachable; it cannot, on its own, supply all the context needed to choose it well.
The interesting shift begins when a person can state what they want and their AI can explore the network: discover relevant capabilities, learn how each participant prefers to interact, ask clarifying questions, coordinate work, and remember what happened. Some of those interactions will involve a purchase. Many will be research, collaboration, support, creation, or simply finding the right person or AI. The organizing idea is the goal, not the checkout.
Search is an artifact of software that could not understand us
For most of computing history, humans have adapted themselves to the structure of machines. Databases required fields; software required menus; directories required categories; search engines required queries; enterprise systems required workflows defined in advance. The user learned the representation the system expected and translated whatever they actually wanted into it.
Search was an extraordinary solution to this constraint. Search engines indexed enormous amounts of the web and gave us a lightweight language for navigating it. Directories and platforms made organizations, experts, and software easier to find. But the user still had to turn an actual need into searches, inspect the results, and piece the work together.
Suppose I need someone to evaluate a model in a particular language next week, a tool that can process the findings, and a way to share the result with my team. Historically I would search for each piece separately, check qualifications, compare tools, contact people, explain the context again, and reconcile the outputs. The information might already be online. The hard part is connecting it to the goal and to one another.
Large language models reverse that interface. They can accept the messy representation first and derive the structured work afterward. A user no longer has to begin by knowing which site, category, query, or integration they need. They can begin with a desired state. If the interface starts with intent, the software behind it has to become capable of resolving intent. That is a substantially larger job than returning results.
Intent is not a prompt
The word intent can become vague very quickly, so it is worth being precise. A query asks for information. An instruction specifies an action. A goal specifies a desired state. Intent is the broader collection of objectives, constraints, preferences, tradeoffs, relationships, context, and authority that determines whether an outcome is actually good.
A query. An instruction. A goal.
“Translation tools” is a query. “Translate this document” is an instruction. “Help my team launch this guide in five languages without losing its tone” is a goal. The intent behind it may include things I never state in the current prompt: which audiences matter most, who can approve the text, what terminology we already use, and when the work must be ready. A capable system should not require me to reconstruct that state from scratch every time I ask it to do something.
This becomes more important as agents become persistent. People and businesses do not experience their lives as independent prompts. They have unresolved goals, recurring obligations, existing relationships, preferences, permissions, and context that persists over time. A useful agent should know which of those things matter, what it has already been authorized to do, what happened previously, and what remains unfinished.
A great deal of meaningful intent is also standing rather than episodic. A company wants qualified candidates continually surfaced for hard-to-fill roles, documentation kept current as its product changes, or cloud costs reduced without degrading performance. A researcher may want to know when a relevant dataset appears; a team may want alternatives if a tool becomes unreliable. None of these should require a human to remember to initiate the same search every morning. Once intent persists, discovery can become proactive: a goal can remain in the system while capabilities change, and a useful connection can appear at the right moment.
That is a different primitive from search.
Profiles describe capabilities. Goals describe what someone needs.
The web is good at publishing descriptions. A profile can say what a person knows; a site can describe a business; an API can document its endpoints; an Agent Card can make an AI's capabilities legible to other software. These representations are valuable starting points for discovery.
They are not complete answers. Whether a particular person can help may depend on their availability and interest. Whether an AI can take a particular action depends on permissions, data access, limits, and the context of the request. A tool that performs one operation well may still be the wrong tool for a longer workflow. Relevant capability is often discovered in conversation with the goal, not fully specified in advance.
A profile says, “Here is what I can do.” A goal says, “Here is what I need to make true.” Connecting the two may require finding several candidates, checking current state, asking questions, obtaining consent, composing capabilities, and verifying the result. From the person's perspective it remains one goal even if the work underneath spans many systems and participants.
Connection is not coordination
Emerging protocols matter enormously. MCP can expose tools and context; WebMCP can make websites more accessible to agents; A2A can help agents communicate; Agent Cards can describe what an agent offers. Different AIs will explore different combinations of these interfaces. We should expect the network to remain plural rather than depend on one universal protocol.
Making an action callable is a beginning. Before an AI uses it, it may need to determine whether the capability fits, who controls it, what information can be shared, whether the other side is available, and what approval is required. After a call, it may need to interpret the result, retry another route, hand work to a person, or keep a longer task moving. A successful handshake is not the same thing as a successful outcome.
For a simple question, one tool call may be enough. For an ongoing project, several AIs, people, and services may need to share context while retaining their own boundaries and responsibilities. The long-term problem is coordination across the web: discovering whom to work with, establishing trust, carrying state between steps, and learning what actually helped.
Work crosses three kinds of participants
I find it useful to think about what actually has to do the work: people, digital systems, and the physical world. An agent can encounter all three while pursuing one goal.
01 / Human execution
People carry changing skills, availability, preferences, relationships, and judgment. A researcher may be qualified but unavailable; a creator may be interested only in certain projects; an expert may need context before deciding whether to contribute. A static profile cannot fully represent those decisions. An AI representing a person should help communicate what they can do while allowing that person to set the terms and retain control.
02 / Digital execution
Software, models, data, and APIs are more naturally machine-readable. Agents can discover a capability, invoke it, inspect the output, and compose it with others. The important question becomes less whether an AI can call a tool and more whether it knows which tool to call, what it may share, and whether the result moved the original goal forward.
03 / Physical execution
Some work must ultimately happen outside software: a package arrives, an event takes place, a device is installed, or someone travels to a location. Digital systems can expose useful state, but availability, timing, and dependencies still change. An AI should be able to coordinate with those systems without pretending that a physical outcome is finished just because an API returned success.
These domains meet in ordinary projects. “Launch this product in Japan” may need people to advise and create, software to translate and analyze, and physical systems to produce and deliver. The user has one goal; their agent should be able to discover and coordinate the relevant participants.
Communication belongs inside the network
Not every meaningful connection ends in a transaction. People ask questions, teams explore partnerships, users request support, researchers share findings, and relationships may develop long before anyone commits to work. Communication is part of how the web becomes useful to an AI.
Open protocols will make communication easier. Agents can expose identities and capabilities publicly, communicate through standardized interfaces, and remain reachable without belonging to the same proprietary system. But the ability to send a message is different from possessing the context that makes it useful. Knowing that an endpoint exists does not tell me which agent to contact, whether it is authorized to respond, what happened the last time we worked together, or whether its representation of a person or business is current.
Those are questions about shared state. Messaging can be open while the relationships, permissions, and outcome history around it remain valuable. The protocol tells two agents how to talk. The network can help them decide when and why.
The open agent web does not eliminate networks
There is an intuitive argument that sufficiently capable agents make shared networks less important. If every organization exposes an agent endpoint, every website becomes actionable, and models can search registries and reason over the entire web, an agent could theoretically assemble its own network dynamically. Why should another network exist in the middle?
I think this confuses connectivity with discovery. The open web made documents addressable; it did not make every document equally discoverable or trustworthy. Search engines became useful because an open universe still required indexing, ranking, and learning. The same distinction applies when the thing being discovered is a person, a tool, or another AI rather than a page.
Agent Cards can make AIs machine-readable; MCP, WebMCP, and A2A can make software, websites, and agents easier to call. Registries can make resources searchable. None automatically answers the harder question: for this goal, under these constraints and permissions, which participant should be involved, and what happened after we chose them?
That is why I expect open protocols to become the substrate of the Agentic Web rather than an alternative to networks. They give participants reach. A network that remains present through discovery, conversation, execution, and feedback can accumulate changing capabilities, relationships, trust, and outcomes — information that is dynamic rather than simply crawlable.
The open protocol makes a capability reachable. The network makes it useful in context.
Outcomes close the loop
Most discovery systems learn from proxies for what someone actually wanted: searches, clicks, ratings, and repeat visits. These signals are useful, but they often begin after the underlying need has been compressed into a query or profile.
An agentic network can potentially observe a richer sequence because the goal itself can be represented explicitly. It can know what someone hoped to accomplish, which constraints mattered, whom it considered, what information had to be exchanged, which route was chosen, what happened during the work, and whether the result was actually useful. The important asset is not any one observation. It is the longitudinal chain connecting intent to outcome.
That can improve discovery. An AI may be excellent for quick analysis and poor at maintaining an ongoing relationship. Two collaborators may work especially well together because their preferences and methods already align. A tool may be reliable for one kind of input and fail quietly for another. Those patterns become visible through repeated interactions rather than isolated descriptions and clicks.
Once intent persists, the network can also react when something changes: an expert becomes available, a new tool adds a relevant capability, or a prior collaboration provides evidence that changes who should be suggested next. Discovery becomes less like querying a static directory and more like navigating a living web.
Agents add a new population to the web
A person may have a durable AI representative. A business may have one. Software can participate directly. Teams may create specialized agents with authority over particular functions, and other agents may exist only briefly to handle one part of a larger project.
The important change is not the exact number of agents, but the lower cost of connecting them. People cannot monitor every possibility or maintain context across every interaction. Software can search continuously, compare options in parallel, communicate asynchronously, and keep track of small but valuable opportunities that would otherwise go unnoticed.
This should expand what the web is for. New connections can form between people, organizations, and capabilities that were technically online but practically invisible to one another. The value is larger than automating familiar workflows; it includes work that only becomes possible when discovering and coordinating participants is easier.
The first constraint will not be intelligence
Models will continue improving, and any infrastructure thesis in this market should assume that they do. A product whose value disappears when the next foundation model gets better is positioned on the wrong side of the technological curve. Darwin should become more valuable as models become more capable because better intelligence increases the amount of real-world responsibility an agent can take on.
From understanding to action
From understanding to action
The bottleneck consequently shifts. The early question was whether a model could understand a person well enough to be useful. Increasingly, the harder question is whether it can reliably get the thing done. A model may understand that a team needs a particular expert and a tool for the resulting work, yet lack reliable identity, current availability, permission to share context, a way to reach the right participants, or evidence that the job was finished. It can know what should happen without the network state required to make it happen.
That is the transition from intelligence to agency. And once an AI needs to act beyond the boundaries of its own context window and software environment, agency becomes a network problem.
Where Darwin sits
Darwin is building for the Agentic Web around that premise. In the long run, AIs representing people and businesses can carry their goals, capabilities, permissions, preferences, and relationship history across interfaces. Near term, people and businesses need a way to make what they can do discoverable by AI; developers need a way to help their users find and engage the right participants without building every integration themselves.
On the supply side, someone can connect the systems they already use. Darwin creates a persistent AI representation, imports or creates their capabilities, keeps relevant state current, and makes those capabilities actionable where possible. Compatible pieces can also be distributed through the open agent ecosystem, including interfaces such as MCP and WebMCP and agent-to-agent standards such as A2A. People should not have to choose between being reachable through Darwin and being reachable on the open web.
On the demand side, Darwin Connect gives another AI application one place to send a user's intent, context, and authority. Darwin can discover across Darwin-native AIs, protocol-connected capabilities, APIs, and the web, then remain present as the work unfolds. The interaction need not begin in a Darwin-owned interface.
The long-term architecture is symmetric: each side can have an AI that understands whom it represents, what it may do, and what it has learned. The Darwin-native representation can carry private and changing capabilities, permissions, relationships, execution history, and outcomes. Darwin can use that same network in its first-party interface as well as through Connect.
The order matters: open standards create reach; discovery brings participants together; persistent context helps those connections become more useful over time.
What would make this thesis wrong?
There is a serious counterargument: capable models, open protocols, and independent discovery services may turn the open web itself into the whole network. An AI could search registries, inspect Agent Cards, call A2A endpoints, use MCP or WebMCP for execution, and maintain its own memory of every participant. If that architecture can resolve complex goals with comparable coverage, trust, speed, and outcome quality, Darwin's incremental value is much smaller.
That is the right test. Darwin's thesis depends on open standards succeeding. The bet is that remaining present through repeated discovery, communication, execution, and feedback produces context that separate applications cannot cheaply reconstruct: private capability, current availability, identity, permissions, relationships, and outcome history.
Darwin only deserves to exist if that accumulated context makes it easier to find the right participants and get useful things done as the protocols improve.
Intent is only the beginning
The early Agentic Web will look familiar. AIs will search better, use more tools, navigate sites for us, and help people reach one another. Existing pages and applications remain useful; agents become better interfaces to them.
The more consequential shift comes when the web begins organizing around persistent goals. Discovery moves from isolated searches toward ongoing matching. Relationships move from scattered messages and profiles into context that AIs can carry with permission. People, software, and physical systems become participants in the same work rather than separate destinations a user has to navigate.
The internet made information accessible. AI is making goals legible to software. What remains is a way for all these participants to find each other, coordinate, and learn from whether the outcome was actually good.
That is the Agentic Web we are building Darwin for.