# How Cloudflare adopted MCP and made it enterprise-ready | LinearB Blog

> Cloudflare adopted the Model Context Protocol (MCP) and made it enterprise-ready by using a "customer zero" dogfooding philosophy, leveraging observability as a killer use case, and building a foundation for agent-to-agent communication.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "How Cloudflare adopted MCP and made it enterprise-ready",
      "item": "https://linearb.io/blog/cloudflare-mcp-enterprise-ready-dogfooding"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

How Cloudflare adopted MCP and made it enterprise-ready

# How Cloudflare adopted MCP and made it enterprise-ready

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/cloudflare-mcp-enterprise-ready-dogfooding#andrew-zigler)

|

October 3, 2025

![Blog_Cloud_Flare_Adopted_MCP_2400x1256_19ea0303ed](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Cloud_Flare_Adopted_MCP_2400x1256_19ea0303ed?_a=BAVMn6ID0)

In just over a year, Model Context Protocols (MCP) have gone from an intriguing experiment to a critical piece of the AI infrastructure puzzle. But for large, security-focused organizations, adopting such a fast-moving technology can be a daunting challenge. How do you embrace innovation while maintaining enterprise-grade stability and security?

[Brendan Irvine-Broque](https://linearb.io/dev-interrupted/podcast/mcp-next-internet-infrastructure-cloudflare), Director of Product at CloudFlare, offers a clear blueprint based on their successful MCP implementation. The key to their approach is a deeply ingrained philosophy of internal dogfooding. As he explains, "When we build products, we're building for our own internal customer, zero. First." This principle ensures that by the time a product reaches an external customer, it has already been battle-tested by CloudFlare's own engineering teams.

This article explores CloudFlare's journey with MCP, from their "customer zero" adoption strategy and high-value use cases like observability, to the common challenges they've navigated and their vision for an agent-to-agent future.

## **The adoption journey: a philosophy of internal dogfooding**

CloudFlare's [journey with MCP](https://linearb.io/blog/exploring-the-power-of-linearbs-mcp-server) began about a year ago, with the team's "ears to the ground on what developers wanna build." Initial experiments with the local-only protocol from Anthropic quickly accelerated in early 2025 as developer enthusiasm exploded. The technology was a natural fit, representing an elegant solution to the service communication challenges their teams were already contemplating for the new era of AI clients that are becoming, as Irvine-Broque puts it, "the new web browsers."

The core of their strategy was their "customer zero" approach. Instead of just building MCP for external customers, they built it for themselves first, creating a powerful, real-time feedback loop. This internal-first philosophy allowed them to rapidly test, refine, and harden the technology—especially around security and the complexities of remote authentication—before it ever reached an external customer. "I wouldn't feel good as a product leader," Irvine-Broque notes, "if I'm telling a customer... they should go and adopt something if we're not really using it ourselves."

This tight integration between the platform builders and their internal users proved invaluable. For example, engineering teams began using their own MCP servers to debug CloudFlare workers and investigate observability issues. When they encountered challenges or identified opportunities, they could immediately collaborate with the teams building those platform features. This ability for engineers to go "back and forth really, really quickly in fast cycles" is what allows CloudFlare to build products that are not only powerful but also practical and reliable.

## **A killer use case: enterprise observability**

[Observability has emerged](https://linearb.io/platform/software-engineering-intelligence) as one of the most compelling and high-value starting points for MCP adoption. Engineering organizations often use four or five different tools for logs, traces, and metrics, creating a significant pain point during incident response. Engineers are forced to "pull up six or seven different tabs in Chrome and like, correlate different things just to figure out, okay, it's this."

MCP servers solve this problem by acting as a powerful correlation engine. An engineer can now use an AI agent to query logs from one system and metrics from another simultaneously. As Irvine-Broque explains, the agent can "look at correlation and look at what might be happening here and piece the two things together." This transforms a manual, time-consuming task into an automated, intelligent query.

This use case is an ideal entry point for enterprise adoption for three key reasons. First, it's a universal problem that nearly every engineering team faces. Second, it's a focused implementation that doesn't require exposing every possible tool at once. Third, and most importantly, it's fundamentally a read-only operation. This dramatically reduces the security concerns associated with AI agents that can mutate data, allowing organizations to gain significant value while maintaining a strong security posture.

## **The future: from APIs to agent-to-agent communication**

While MCP started as a way for [agents to talk to APIs](https://linearb.io/blog/ai-agents-changing-software-design-mcp-agent-experience), Irvine-Broque is most excited about its future as a "protocol for agents to communicate" with each other. This vision of a more dynamic, interconnected AI ecosystem is where the true potential of MCP lies. CloudFlare's "durable objects" technology, which provides stateful workers that can maintain instances, proved to be a natural architectural fit for this forward-looking vision.

The MCP specification requires managing long-lived, stateful connections between clients and servers, a task that can be complex on other platforms. For CloudFlare, however, durable objects provided a ready-made solution. "There was just this like very natural fit for us," Irvine-Broque notes. This architectural alignment gave them a head start in building scalable and reliable remote MCP servers.

This technical foundation is now enabling teams to explore more advanced capabilities, such as agents that have their own memory and can persist context across different sessions and platforms. This tackles a key question in the AI space: will a user's memory be controlled by a single provider like OpenAI, or can it be decentralized? Irvine-Broque sees a future where MCP lets "people bring memory across platforms," creating more coherent and personalized AI experiences that are not locked into a single ecosystem.

## **Common implementation challenges to avoid**

As organizations race to adopt MCP, Irvine-Broque identifies several common pitfalls. The most frequent is blowing up the context window. In their excitement, teams often expose too many tools at once. "You've given it 25 tools that all start with the word 'update'," he says, and the LLM "is quite confused." This leads to poor results and developer frustration.

Another critical, often overlooked, challenge is the quality of tool descriptions. Engineers are used to naming methods clearly, but often forget that for an AI, the natural language description is the primary source of information for how and when to use a tool. Irvine-Broque has seen teams develop "mini evals frameworks" just to iterate on their tool descriptions to get the best results, a practice that requires a [shift in mindset from traditional API design](https://linearb.io/blog/measuring-developer-and-agent-productivity-in-an-api-driven-world).

Ultimately, these challenges highlight the need for a more focused and deliberate approach. The initial trend of one-to-one API mapping has given way to a more thoughtful process of curating specific tools for specific use cases. CloudFlare's experience suggests that starting with a narrow, targeted implementation is the most effective path to success, allowing teams to learn and iterate before scaling more broadly.

## **A blueprint for enterprise MCP adoption**

CloudFlare's journey provides a powerful blueprint for how any large organization can successfully adopt emerging AI technologies like MCP. Their success wasn't based on a top-down mandate or a rush to implement every possible feature, but on a pragmatic, engineering-led approach.

It began with a core philosophy of being their own "customer zero," which allowed them to harden the technology in a real-world environment. They focused on a high-value, low-risk initial use case—observability—to build momentum and demonstrate value. Finally, they leveraged their existing architectural strengths, like durable objects, to not only solve immediate challenges but also to unlock a more sophisticated, agent-to-agent future.

For [engineering leaders navigating the hype cycle](https://linearb.io/resources/engineering-leader-guide-to-goals-and-reporting?%5Fbt=&%5Fbk=&%5Fbm=&%5Fbn=x&%5Fbg=&utm%5Fterm=&utm%5Fmedium=cpc&utm%5Fcampaign=Pmax%5FDemo&utm%5Fsource=google&gad%5Fsource=1&gad%5Fcampaignid=22016756304&gbraid=0AAAAACpkcxOTSChiWgBooupgcwrqmPnBp&gclid=CjwKCAjw6P3GBhBVEiwAJPjmLuyip%5F9lgFib6x470TomZBJVNyfakX35zV9mBKOxl1XTMrwGsbsVvBoCtvUQAvD%5FBwE), CloudFlare's experience offers a clear and repeatable lesson: start with your own teams, solve a real internal problem, and build from there. This methodical, internally-focused approach is the most effective way to build the expertise and confidence needed for a successful enterprise-wide implementation.

For the full story on how CloudFlare made MCP enterprise-ready, listen to Brendan Irvine-Broque discuss these ideas in depth on the Dev Interrupted podcast.

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for AI agents are killing the pull request and reinventing CI/CD](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_496cdfde2d?_a=BAVMn6ID0)](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

AI

[AI agents are killing the pull request and reinventing CI/CD](https://linearb.io/blog/circleci-rob-zuber-ai-agents-pull-request-cicd-sdlc)

CircleCI CTO Rob Zuber explains why AI adoption is killing the pull request and forcing engineering teams to completely reimagine the software development...

[![Cover image for Rippling's employee graph turns HR data into an agentic AI platform](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_be5ec4183f?_a=BAVMn6ID0)](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

AI

[Rippling's employee graph turns HR data into an agentic AI platform](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

Rippling CTO Albert Strasheim explains why the employee graph serves as the essential context layer for enterprise agentic AI. Discover how unifying HR, IT,...

[![Cover image for Deterministic guardrails must evolve to control probabilistic AI systems](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_f5375661ec?_a=BAVMn6ID0)](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

AI

[Deterministic guardrails must evolve to control probabilistic AI systems](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

LaunchDarkly CTO Cameron Etezadi explains why traditional engineering pipelines are breaking down in a probabilistic, AI-driven world. Discover how to safely...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "How Cloudflare adopted MCP and made it enterprise-ready",
  "url": "https://linearb.io/blog/cloudflare-mcp-enterprise-ready-dogfooding",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2025-10-03T07:00:00.000Z",
  "dateModified": "2025-10-03T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1759539343/Blog_Cloud_Flare_Adopted_MCP_2400x1256_19ea0303ed.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Cloudflare adopted the Model Context Protocol (MCP) and made it enterprise-ready by using a \"customer zero\" dogfooding philosophy, leveraging observability as a killer use case, and building a foundation for agent-to-agent communication."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Watch now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)