Architecting Radar Researcher: Cloudflare’s Code Mode AI Agent and WebMCP Integration

Cloudflare Radar has collected and published global Internet traffic telemetry, DNS query metrics, speed performance data, and disruption logs since 2020. While these datasets are exposed via open REST APIs, querying them previously required navigating extensive documentation, constructing specific endpoint parameters, and manually configuring frontend visualization filters. To streamline this workflow, Cloudflare introduced Radar Researcher, an AI-powered conversational assistant designed to translate natural language prompts into live backend queries and interactive visual charts.

Built natively on the Cloudflare Developer Platform, Radar Researcher demonstrates a practical blueprint for constructing stateful, multi-model AI agents that operate directly over large API surface areas without hardcoded tool definitions. This article analyzes the underlying architecture, execution models, rendering techniques, and emerging web standard integrations powering Radar Researcher.

Architectural Overview: Serverless Agent Infrastructure

Radar Researcher relies entirely on Cloudflare’s serverless primitives. The core execution engine uses a Cloudflare Worker running the Cloudflare Agents SDK. Rather than relying on stateless API endpoints, the agent maintains state across user interactions using Durable Objects.

Each user session generates a dedicated Durable Object instance paired with an embedded SQLite database. This persistence strategy fulfills several architectural requirements:

• Session Continuity: Chat histories, conversation titles, and streaming tokens persist across network drops or browser refreshes.
• Background Generation: Because the execution loop lives within a Durable Object on Cloudflare’s edge network, inference processing continues server-side even if a user closes their browser tab mid-response. Upon reconnecting, the client re-establishes a stream and consumes the persisted output.
• Storage and Shareability: Shared conversation logs are serialized and stored in Cloudflare R2 object storage, generating public links configured with a automatic 30-day expiration threshold.

Model Orchestration and Resilient Fallback Chains

Rather than relying on a single Large Language Model (LLM) provider or instance, Radar Researcher utilizes Workers AI to orchestrate an ordered fallback chain across three distinct model families, including open models such as Kimi K2.7. When an execution request initiates, the agent routes the prompt through AI Gateway.

AI Gateway manages logging, cost monitoring, semantic caching, and safety guardrails. If the primary model experiences latency spikes or capacity errors, the Gateway transparently cascades the request to the second or third model in the fallback array. This prevents localized model outages or vendor throttling from impacting end-user availability.

To maintain low response latency, auxiliary tasks are offloaded from the primary reasoning model to smaller, specialized micro-models running asynchronously:

• Conversation Titling: A lightweight LLM processes the initial prompt in parallel to generate a short descriptive thread title.
• Follow-up Suggestions: A dedicated fast model evaluates the generated answer and formulates contextual follow-up prompts without delaying the primary response stream.

Dynamic API Access via MCP and Code Mode

Cloudflare Radar’s REST platform encompasses hundreds of distinct query endpoints. Hardcoding an individual LLM function tool for every API path would inflate context windows, increase latency, and introduce maintenance overhead whenever an endpoint updates.

Radar Researcher bypasses this limitation by adopting the Model Context Protocol (MCP) coupled with Code Mode. The model is granted access to a unified Cloudflare MCP server exposing only three core metaprogramming tools:

1. search: Queries the full OpenAPI specification stored on the MCP server.
2. docs: Retrieves detailed parameter definitions and response schemas for a selected endpoint.
3. execute: Runs a generated code snippet that executes the HTTP request against the live Radar API.

When a user asks a question, the LLM searches the OpenAPI spec to locate the appropriate endpoint, inspects its schema via docs, writes a JavaScript code snippet to query the dataset, and evaluates the results via execute. Because schema discovery happens dynamically at runtime, new endpoints added to the Radar API automatically become available to the agent without modifying its underlying prompt or logic.

Decoupling LLM Processing from Numerical Data Rendering

Generative models frequently struggle with precise numerical reporting. When an LLM directly emits raw numerical series into text, it risks truncating datasets, rounding values, or introducing hallucinated numbers. To enforce statistical accuracy while rendering rich visual representations, Radar Researcher decouples data fetching from prose generation.

When the model executes an API call, the execution tool wraps the raw JSON response in a lightweight envelope containing the underlying API path and parameter map. The model is instructed explicitly not to print the raw data points inside its text output. Instead, it emits a compact chart specification string:

```radar-chart
{
  "type": "speedFlower",
  "title": "Internet speed quality — Portugal",
  "dataFrom": "/radar/quality/speed/summary?location=PT"
}
```

The Radar frontend interceptor reads this token, matches the dataFrom URI against the fetched result stored in the response envelope, and hydrates native web visualization components (such as time-series lines, stacked areas, histograms, donuts, or choropleth maps). This approach guarantees that rendered charts display verified API data while preventing the LLM context window from congesting with numeric arrays.

Context-Aware Multimodal Analysis: The “Explain with AI” Pattern

Radar Researcher handles unstructured exploration via the header assistant, but it also accepts visual state input directly from active UI elements using the Explain with AI feature present on every chart component.

When triggered from an existing visualization, the frontend passes three distinct payload elements to the agent simultaneously:

• Visual Snapshot: A client-side screenshot passed to a vision-capable LLM to capture rendered UI elements.
• Raw API Payload: The underlying JSON response corresponding to the visual block.
• Active View Parameters: Applied global parameters, including location ISOCodes, start/end timestamps, granularity parameters, and filter masks.

By processing the visual frame alongside exact data points and environment state, the model avoids generic answers and delivers pinpoint contextual explanations regarding the specific view displayed on the user’s screen.

Practical Implementation Examples

Scenario 1: Regional Connectivity Assessment

A user requests an evaluation of residential Internet performance in Portugal. The model executes the following pipeline:

1. Queries the OpenAPI schema for network quality tools.
2. Executes a request to /radar/quality/speed/summary?location=PT.
3. Receives the raw speed metrics, bandwidth distribution, and latency percentile data.
4. Outputs a brief qualitative summary alongside a speedFlower chart specification referencing the retrieved endpoint context.

Scenario 2: Technical Outage Investigation

During an investigation into multi-month Iranian Internet disruptions in early 2026, a network operator issues an open query regarding traffic stability. Radar Researcher runs a multi-step trace:

1. Fetches recorded disruption event logs for Iran (IR).
2. Queries the HTTP traffic index over the targeted timeframe.
3. Identifies a drop where the traffic index collapsed from approximately 0.58 on January 7 down to near zero by January 9, followed by initial recovery around January 17 and restoration near pre-shutdown levels by January 27. Flags a secondary interruption recorded on February 28.
4. Renders an annotated time-series chart alongside a tabular view mapping event metadata directly against traffic trendlines.

Native Browser Agent Integration with WebMCP

In addition to serving human users via its internal UI, Cloudflare Radar incorporates WebMCP—an emerging web standard enabling external browser-based AI agents to interact with web applications via structured interfaces rather than brittle DOM scraping.

Radar implements both standard WebMCP interaction models:

• Imperative API: Registered JavaScript tools expose functions directly to browser agents. External agents can programmatically invoke site methods to update geographical scopes, filter by Autonomous System Number (ASN), modify date windows, or switch visual sub-views.
• Declarative API: HTML forms are decorated with semantic attributes that expose UI components as executable tools. External browser agents can trigger URL diagnostic scans, evaluate domain security profiles, or verify post-quantum TLS key exchange compatibility.

These entry points operate as progressive enhancements. Standard web browsers execute UI logic without modification, while WebMCP-enabled client agents automatically detect and consume these structured bindings.

System Limitations and Operational Trade-Offs

While the architecture offers scaling advantages, developers implementing similar agentic architectures should evaluate several operational constraints:

• Shared Link Lifespans: Persistent state stored via Durable Objects and R2 for shared user threads carries an automatic 30-day decay policy to manage storage overhead.
• Code Execution Overhead: Using Code Mode requires the model to perform multiple sequential round-trips (searching spec, verifying schema, running code) before emitting a final answer, introducing incremental latency compared to direct single-prompt completions.
• Fallback Latency: Cascading through Workers AI fallback models during primary endpoint capacity pressure ensures uptime but can introduce processing delays during peak load.

Primary reference: Review the original announcement for exact release details. This article is an independent explanation and does not reproduce the source text.