Cloudflare has added an AI research interface to Radar, its public platform for exploring Internet traffic, outages, routing, security and technology trends. Radar Researcher lets someone describe an investigation in natural language, then identifies relevant Radar data, invokes the appropriate APIs and returns an explanation with interactive visualisations.
That sounds like another example of conversational analytics. It is, but that is probably the least interesting part.
Microsoft Fabric, Snowflake, Databricks and Tableau already allow users to interrogate data through natural language. What makes Cloudflare's experiment more revealing is the architecture underneath the conversation: an agent can discover tools, identify appropriate API operations, execute an investigation and return results through existing application components. Radar has also added WebMCP support so compatible browser agents can discover defined functionality directly from the website.
The larger idea is that software may be acquiring another surface.
For decades, applications have primarily been designed to make functionality discoverable to people. APIs subsequently made that functionality addressable by other software. AI agents introduce another requirement: capabilities that machines can discover, interpret and invoke dynamically on a user's behalf.
Software is becoming agent-addressable.
Software has always encoded assumptions about its user
A graphical user interface (GUI) assumes that a person will understand enough about an application's structure to operate it.
To produce a report, the user finds the reporting area. To filter results, they locate the relevant controls. To change an account, they navigate to its settings. The GUI makes complex underlying functionality discoverable through screens, menus, forms and buttons.
APIs introduced a different relationship.
Instead of asking a person to operate the application, an API gives another piece of software a defined mechanism for requesting data or invoking functionality. But the relationship has traditionally been programmed in advance. A developer knows that an endpoint exists, understands its parameters and writes software specifically to call it.
Agentic interaction changes a different part of the equation.
The capabilities may still be conventional APIs. What changes is how the consuming system decides what to use.
An agent can potentially begin with an objective, inspect the capabilities available to it and select the appropriate combination at runtime. Instead of every interaction path being encoded beforehand, some of the selection moves into the model.
The significant transition is therefore not simply from human interaction to machine interaction.
Software has supported machine interaction for decades.
It is from predefined invocation towards intent-led capability discovery.
Agents make software capabilities semantically discoverable
Model Context Protocol (MCP) provides one increasingly important mechanism for this interaction model. MCP servers can expose tools with descriptions and schemas that language models can discover and invoke. Those tools can call APIs, query databases or perform computations.
Cloudflare's implementation shows why this matters.
According to the company, Radar Researcher accesses a unified MCP server through search, execution and documentation tools. Rather than inserting every Radar API operation into the agent's prompt, the system can inspect the API specification, identify relevant operations and execute them as the investigation develops.
Consider the difference.
A conventional integration might be explicitly programmed:
When the user asks for X, call endpoint Y.
An agent-addressable application can support a looser relationship:
Here are the capabilities available, their meaning and their boundaries. Determine which are relevant to the user's objective.
That makes the quality of the machine-facing description increasingly important.
Humans discover software spatially and visually. We infer meaning from position, labels, grouping and previous experience.
Agents need much of that meaning expressed structurally.
Tool names, descriptions, parameter schemas, business definitions and predictable responses become part of application usability.
An API can therefore be technically complete while remaining poorly suited to agentic use.
WebMCP asks what an agent-friendly website looks like
The web makes this issue particularly visible.
A person can look at a page and infer what a form, button or menu is intended to do. Browser agents can also attempt to operate websites by analysing rendered pages, accessibility structures or the document object model.
But that approach effectively asks the agent to reverse-engineer functionality from an interface designed for people.
WebMCP explores another model.
The proposed browser API enables web applications to expose structured JavaScript-based tools to AI agents. Chrome describes WebMCP as a proposed standard, while the W3C Web Machine Learning community currently lists it as a Community Group incubation. It should therefore be treated as an emerging approach rather than a settled web standard.
Cloudflare has enabled WebMCP on Radar and says compatible browser-based agents can use functions including search, URL scanning and domain lookup.
The implication is subtle but important.
A conventional website exposes functionality indirectly: the machine observes the same controls that a person sees and attempts to understand them.
An agent-addressable website can additionally state:
These are the actions available. This is what they mean. These are the inputs they accept.
The visual experience remains, but the application's capabilities become explicitly legible to machines.
For humans, good interface design makes functionality visually discoverable.
For agents, good interface design may increasingly mean making functionality semantically discoverable.
AI does not need to become the application
One of the strongest details in Cloudflare's implementation concerns how Radar Researcher produces charts.
The model interprets the request and decides what information is needed. According to Cloudflare, however, it does not regenerate the underlying numerical series in prose and ask a generative model to draw a plausible chart. Instead, Researcher creates a visualisation specification referring to the API result, and Radar's existing front-end components render the data.
That separates two different engineering problems.
The probabilistic system handles ambiguity:
- What is the user asking?
- Which data could answer the question?
- Which tools should be invoked?
- How should the findings be explained?
Deterministic software handles defined execution:
- Retrieve the requested data
- Apply established operations
- Preserve authoritative values
- Render the visualisation consistently
The distinction is important because agentic software does not require every function to become generative.
The model does not need to replace the database, calculation engine, charting library, permissions system or workflow service. It can interpret intent and coordinate capabilities that remain conventional software.
This may prove to be one of the more durable architecture patterns for agentic applications: probabilistic interpretation connected to deterministic execution.
Agent-addressability creates a different usability problem
Making an application callable is not the same as making it understandable.
Imagine an enterprise application exposing hundreds of operations. An agent might technically be able to invoke all of them while still lacking enough context to choose reliably between them.
Machine-facing usability therefore extends beyond API availability.
Meaning has to be explicit
A tool called getCustomer() is not useful simply because its schema is valid. The agent needs to know which customer identity it accepts, what information it returns, when the operation should be used and how its result relates to other tools.
The conversational analytics market already demonstrates the importance of this semantic layer.
Snowflake's Cortex Analyst uses semantic views to represent business concepts and relationships. Databricks has domain experts configure Genie Agents with datasets, example queries and instructions that reflect organisational terminology. Microsoft Fabric similarly supports semantic models and ontologies for grounding natural-language interaction with enterprise data.
Natural language does not remove the need for structure. In many cases, it makes explicit structure more important.
Authority has to travel with the request
Discovering a capability must not imply permission to execute it.
Reading an order, cancelling an order and refunding an order have different risk profiles even if all three are represented as callable tools.
Agent-addressable software therefore needs to preserve authentication, authorisation and delegated authority as interaction becomes less direct.
The question changes from simply:
Can this user access the function?
to:
Can this agent invoke this function for this user, in this context, with these parameters?
Execution has to be observable
A user clicking through an application leaves relatively familiar application events.
An agent may dynamically select several tools, pass outputs between them and alter its plan as results arrive.
Understanding behaviour therefore requires visibility into the execution path: what was requested, which tool was selected, which arguments were supplied, what response came back and what action followed.
MCP's own work on tool annotations reflects the growing importance of distinguishing behaviours such as read-only, destructive and idempotent operations in agentic workflows.
Failure has to be machine-readable
Human error messages frequently assume a person will interpret the problem and decide what to do next.
An agent requires enough structured information to distinguish between a retryable failure, invalid input, insufficient permission, unavailable dependency and an action that should stop altogether.
Once machines become application users, error design becomes part of agent experience design.
The GUI is not disappearing
The most dramatic interpretation of agent-addressable software is that conventional interfaces become unnecessary.
The evidence does not support that conclusion.
Cloudflare Radar Researcher still relies on Radar's existing visualisation components. Tableau explicitly combines its conversational assistant with its conventional visual analysis interface. MCP Apps now allows MCP tools themselves to return interactive forms, dashboards and other interface elements inside compatible conversational clients.
The direction looks additive.
People remain particularly effective at scanning, comparing visual information, inspecting unfamiliar environments and exercising judgement where several possibilities need to remain visible at once.
Agents are valuable when the objective is easier to describe than the sequence of steps required to achieve it.
The appropriate interface can therefore depend on the task.
A dashboard may remain the better way to explore an unfamiliar dataset. An agent may be better for asking a precise question that requires several datasets.
A form may remain appropriate when the user needs to inspect and approve every value. An agent may be better at assembling those values from several authorised sources before presenting them.
The future application may therefore support several complementary forms of interaction:
Direct manipulation when the user wants control and visibility.
Programmatic APIs when another system has a known integration path.
Agent-mediated execution when the user knows the objective but not necessarily the workflow.
Agent-addressability extends the application rather than automatically replacing its existing surfaces.
Software is acquiring a machine-facing surface
Radar Researcher remains a beta product. WebMCP is still an emerging browser proposal. Neither proves that agent-addressable software will become the dominant application model.
But the underlying signals are becoming harder to dismiss.
MCP gives AI applications a common mechanism for discovering and invoking external tools. WebMCP is exploring how web applications can make functionality explicit to browser agents. Conversational data platforms are already showing that reliable natural-language interaction depends on governed data, semantic definitions and carefully bounded capabilities rather than language models alone.
The progression is therefore more nuanced than GUI → API → agent, with each generation replacing its predecessor.
Software is accumulating ways to expose the same underlying capability.
The GUI made application functionality discoverable to people. APIs made it addressable by software that knew what it wanted to call. Agent-facing tools add the possibility that a machine can inspect available capabilities and decide how to use them in response to intent.
If that model matures, one measure of software quality will change with it.
We will still ask whether an application is easy for people to use and straightforward for developers to integrate.
We may increasingly ask a third question:
Can an authorised machine understand what this software can do?
That is what makes Cloudflare Radar Researcher interesting beyond the chat box. It offers an early view of software designed not just to be navigated or integrated, but to be understood and invoked.
