Cloudflare has added an AI research assistant to Radar, its free public site for exploring internet traffic, outages, routing, security and technology trends. With Radar Researcher, you describe what you want to investigate in plain English. It finds the relevant Radar data, calls the right APIs and gives you an explanation with interactive charts.
That sounds like yet another "ask your data a question" tool, and in a sense it is. Microsoft Fabric, Snowflake, Databricks and Tableau all let users query data in plain language already. What makes Cloudflare's version worth a closer look is how it reaches the data.
Underneath the conversation, an AI agent finds the tools available to it, works out which API operations it needs, runs the investigation and shows the results using Radar's existing charts. Radar has also added support for WebMCP, so compatible browser agents can find out what the website can do directly.
The bigger idea is that software is gaining a new kind of surface. For decades, applications were designed so people could find their features. APIs then let other software call those features. AI agents add a third need: features that a machine can find, understand and use on a person's behalf, without being programmed in advance. In short, software is becoming agent-addressable.
Every interface assumes something about its user
A normal screen-based interface assumes a person will learn enough about the application to operate it.
To get a report, you find the reports section. To filter results, you find the filter controls. To change your account, you go to the settings. Screens, menus, forms and buttons make complex features findable for a human.
An API works differently. It gives another program a defined way to request data or trigger a feature, so no person has to click through the screens. But the connection has always been written in advance. A developer knows the endpoint exists, understands what it needs and writes code to call it.
AI agents change who decides what to call. The features may still be ordinary APIs. But an agent can start with a goal, look at the tools available and choose the right combination while it works. Some of the decision-making moves into the AI model, where every path used to be written out by a developer beforehand.
Software talking to software is nothing new. What is new is software finding and choosing features based on what the user wants to achieve.
How agents find what software can do
The Model Context Protocol (MCP) is becoming one of the main ways this works. An MCP server publishes a set of tools, each with a description and a definition of the inputs it accepts. An AI model can read those descriptions and decide which tools to use. The tools themselves can call APIs, query databases or run calculations.
Cloudflare's setup shows why this matters. According to the company, Radar Researcher connects to a single MCP server that offers tools for searching, running operations and reading documentation. It does not load every Radar API operation into the agent's instructions up front. It reads the API specification, picks the operations it needs and runs them as the investigation develops.
Compare the two approaches. A traditional integration is written explicitly:
When the user asks for X, call endpoint Y.
An agent-addressable application allows a looser relationship:
Here are the features available, what they mean and their limits. Work out which ones fit what the user wants.
That makes the machine-readable description far more important. People find their way around software by sight. We read labels, notice how things are grouped and draw on past experience. Agents need most of that meaning written down in a structured form.
Tool names, descriptions, input definitions, business definitions and predictable responses all become part of how usable an application is. An API can be technically complete and still be hard for an agent to use well.
What an agent-friendly website looks like
The web makes this especially clear. A person looks at a page and understands what a form, button or menu is for. A browser agent can try to do the same by analysing the page layout or the page's underlying code. In effect, it has to reverse-engineer features from a design made for people.
WebMCP takes a different approach. It is a proposed browser feature that lets websites publish structured tools for AI agents to use. Google's Chrome team describes it as a proposed standard, and the W3C Web Machine Learning group lists it as early-stage community work. Treat it as an emerging idea, not a settled web standard.
Cloudflare has switched on WebMCP for Radar and says compatible browser agents can use features including search, scanning a web address and looking up a domain.
A normal website only shows its features indirectly: a machine has to look at the same controls a person sees and guess what they do. An agent-addressable website can also say plainly:
These are the actions available. This is what they do. These are the inputs they accept.
The visual design stays the same. What changes is that the site's features are also spelled out for machines. For people, good design makes features easy to see. For agents, good design means making features easy to understand.
The AI does not have to do everything
One of the most useful details in Cloudflare's design is how Radar Researcher draws charts.
The AI model works out what the user is asking and what data is needed. But according to Cloudflare, it does not retype the numbers and ask an AI model to draw a plausible-looking chart. Instead, it produces a chart specification that points to the actual API results, and Radar's existing charting code draws them. That splits the work in two.
The AI handles the questions that need interpretation:
- What is the user asking?
- Which data could answer it?
- Which tools should be used?
- How should the findings be explained?
Ordinary, predictable software handles the defined work:
- fetching the requested data
- running the standard calculations
- keeping the real values intact
- drawing the chart the same way every time
This matters because agent-based software does not need every part to be generated by AI. The model does not have to replace the database, the calculations, the charting library, the permissions system or the workflow engine. It can understand what the user wants and coordinate features that remain conventional software.
This split, with AI interpreting the request and dependable code doing the work, may turn out to be one of the lasting design patterns for agent-based applications.
Callable is not the same as usable
Making an application callable by agents is not the same as making it understandable. Picture a company system that publishes hundreds of operations. An agent could technically call any of them and still not know enough to choose the right one reliably. Four things make the difference.
Meaning has to be spelled out
A tool called getCustomer() is not useful just because its definition is valid. The agent needs to know which customer ID it expects, what it returns, when to use it and how its result relates to other tools.
The "ask your data" market already shows how much this matters. Snowflake's Cortex Analyst uses semantic views to describe business concepts and how they relate. Databricks has subject experts set up Genie Agents with datasets, example queries and instructions that use the organisation's own terms. Microsoft Fabric supports semantic models and ontologies to anchor plain-language questions to company data.
Plain language does not remove the need for structure. Often it makes clear structure more important.
Permissions have to travel with the request
Finding a feature must not mean permission to use it. Reading an order, cancelling an order and refunding an order carry very different risks, even if all three are published as tools.
So agent-addressable software has to keep sign-in, permissions and delegated authority intact even when the user has stopped clicking the buttons. The question changes from "Can this user use this feature?" to "Can this agent use this feature for this user, in this situation, with these inputs?"
We look at how to manage that in AI governance is becoming an identity problem.
What happened has to be visible
When a person clicks through an application, the system records familiar events. An agent may pick several tools as it goes, pass results from one to the next and change its plan as answers come back.
Understanding what it did means being able to see the whole path: what was asked, which tool was chosen, what inputs were sent, what came back and what happened next. MCP's work on tool labels reflects this, so systems can tell apart operations that only read data, those that delete or change things, and those that are safe to repeat.
Errors have to be readable by machines
Error messages are usually written for a person who will work out what went wrong.
An agent needs enough structured information to tell the difference between a failure worth retrying, a bad input, missing permission, a service that is down and an action that should stop altogether. Once machines become users, designing error messages becomes part of designing for agents.
Screens are not going away
The most dramatic reading of all this is that normal interfaces will become unnecessary. The evidence does not support that.
Radar Researcher still uses Radar's existing charts. Tableau pairs its conversational assistant with its normal visual analysis tools. MCP Apps now lets MCP tools return interactive forms, dashboards and other interface elements inside compatible chat tools. The trend is to add, not replace.
People are good at scanning, comparing visual information, exploring something unfamiliar and making judgements when several options need to stay visible at once. Agents are useful when the goal is easier to describe than the steps needed to reach it. So the right interface depends on the task.
- A dashboard may still be the best way to explore a dataset you do not know. An agent may be better for a precise question that needs several datasets.
- A form may still be best when you need to check and approve every value. An agent may be better at gathering those values from several approved sources before showing them to you.
Future applications may offer three ways in to the same features:
- Direct use, when the user wants control and to see everything.
- APIs, when another system has a known integration.
- Agents, when the user knows the goal but not necessarily the steps.
The same idea applied to websites in the browser is explored in WebMCP could turn the web into an agent-native interface.
What this means for software teams
Radar Researcher is still in beta, and WebMCP is still an early browser proposal. Neither proves that agent-addressable software will become the main way applications work. But the signals are getting harder to ignore. MCP gives AI applications a common way to find and use outside tools. WebMCP is exploring how websites can make their features explicit to browser agents. And the "ask your data" platforms show that reliable plain-language interaction depends on well-governed data, clear definitions and carefully limited features, as well as on the AI model.
If you build or buy software, it is worth asking:
- Could an agent tell what our features do? Check whether names, descriptions and input definitions would make sense to someone who has never seen the screens.
- Are risky actions labelled as risky? Make sure reading, changing and deleting are clearly distinguished, and that permissions apply to agents acting for users.
- Would we know what an agent did? Check that logs record the tools chosen, the inputs and the results.
- Do our errors explain themselves? Make error responses specific enough for a program to decide whether to retry, fix the input or stop.
We have always asked whether software is easy for people to use and straightforward for developers to connect to. A third question is starting to matter: can an authorised machine understand what this software can do?
That is what makes Radar Researcher interesting beyond the chat box. It is an early example of software designed to be understood and used by agents, as well as by people and developers.



