When AI Learns to Make Its Own Phone Calls · MCP May Be the Quietest Tech Revolution of 2026

At eleven o'clock tonight, I typed one line on my Mac:

"cloudflare-api MCP, authenticate."

Three seconds later, the AI popped up an OAuth link. I opened the browser, authorized, and came back to the terminal. Then I said:

"Show me what Workers I have on Cloudflare."

Within ten seconds, it returned a complete list of Workers — account ID, project names, deployment status, all of it exact.

Not a single line of code written. Not a page of documentation flipped through. Not a single API endpoint looked up.

That's MCP.

What MCP Is

MCP stands for Model Context Protocol.

The name sounds academic. Put in plain terms, it means:

A standardized tool protocol that lets AI call third-party services directly.

Here's an analogy.

Getting AI to manage your Cloudflare used to be like telling an assistant who speaks fluent English but has no phone: "Call the telecom company and change my plan for me." He understands exactly what you mean, but he can't make the call — all he can do is write you an email teaching you how to make it yourself.

What MCP does is give this assistant a phone.

He hears you out, makes the call himself, and on the other end an operator verifies his identity, confirms his permissions, and executes the operation. From start to finish, all you have to do is speak plainly.

Where MCP Came From

The MCP protocol was formally released by Anthropic in November 2024 as an open specification.

The backdrop was this: AI models were getting smarter and smarter, but their hands and feet were tied. Large models like GPT-4 and Claude Opus can write code, do analysis, and understand complex instructions — but when it comes to acting on the outside world, deploying a website, querying a database, sending an email, they can't. There's a wall in the way: the API.

APIs are written for programmers. Hundreds of endpoints, each with its own parameters, its own authentication scheme, its own rate limit. Can an AI model read API documentation? Yes — it can even write the calling code itself. But here's the problem: there's a chasm between reading it and executing it reliably.

When a human programmer makes a mistake, they can debug, read the logs, trace the problem step by step. When AI makes a mistake, the whole call chain collapses. What it lacks isn't comprehension — it's a structured, executable tool interface.

MCP's core contribution is precisely filling in that missing link. But to be accurate, MCP itself is no piece of black magic. Its value lies in three things holding true at once:

1. Large models natively support function calling (function calling / tool use)
2. Tools are described with structured JSON Schema (name, description, parameters)
3. Everything plugs in through the MCP protocol — one standard across all platforms

Not one of them is dispensable. If the model doesn't support tool use, the best protocol in the world is useless. If the protocol isn't unified, every platform rolls its own, and developers go insane.

When the AI reads these structured descriptions, it immediately knows "list Workers with workers_list," "query logs with query_worker_observability," "change DNS with dns_record_update."

It's not that AI suddenly got smarter. It's that the infrastructure finally caught up with the model's capabilities.

Our Experience: The Full Cloudflare Setup in Three Sessions

Tonight's experience is representative, because it walks through the entire MCP lifecycle — configuration, authentication, and use.

Step One: Write the Config

In the first session, I had the AI add a Cloudflare MCP server to ~/.claude.json.

Cloudflare's MCP design is interesting — it offers two styles:

Style One: Product-specific server (the specialist)

Aimed at a specific product domain, offering type-constrained tools. Cloudflare currently has a dozen or so such servers:

Style Two: Code Mode server (the general practitioner)

cloudflare-api takes a completely different road. Rather than exposing all 2,500+ endpoints as separate tools (which would burn 1.17 million tokens and blow past the context window outright), it offers only two tools: search() and execute().

The AI first uses search() to find the right endpoint in the OpenAPI spec, then uses execute() to write a snippet of JavaScript that calls it directly. The code runs inside Cloudflare's isolated sandbox.

The cost of plugging in all 2,500+ endpoints? About 1,000 tokens.

That's Code Mode — replacing a tool list with code execution, improving token efficiency by three orders of magnitude.

The two styles are an either/or, not additive. I didn't get this at first and added all five. Only later did I figure it out: product-specific servers suit cases where you only use one slice of functionality; Code Mode suits cases where you need broad coverage. Hanging five at once just wastes context. This is a trap you only understand once you've stepped in it.

The config itself is a few lines of JSON.

Step Two: OAuth Authentication

After restarting the terminal, the MCP servers loaded in. But they still had no permission to access my Cloudflare account.

In other words: the phone is installed, but the operator on the other end doesn't recognize you.

So I told the AI to "authenticate." It automatically found the authenticate tool and generated an OAuth authorization link. I clicked it in the browser, logged into my Cloudflare account via Google SSO, and authorized. Back in the terminal, the connection established itself.

This experience is worth dwelling on. OAuth is secure — I don't have to hand my API Token to the AI, and I don't have to write a plaintext password into a config file. What the AI gets is a session-level temporary credential whose permission scope is controlled on Cloudflare's side.

The difference from handing someone a key is this: you didn't give it a key — you had the building management open the door for it, once.

Step Three: Verification

Authentication done, I wanted to see whether it actually worked.

I had the AI run a simple query: list all the Workers under my account.

Through cloudflare-api's execute() tool, the AI ran this code in the sandbox:

async () => {
  const result = await cloudflare.request({
    method: "GET",
    path: `/accounts/${accountId}/workers/scripts`
  });
  return result;
}

This is how Code Mode actually works — the AI didn't call some workers_list tool; it wrote a snippet of JS itself and called the underlying API through cloudflare.request().

Results came back in ten seconds. Account ID correct, Workers list correct. All green.

From config to verification: three sessions, maybe ten minutes total.

Do the same thing the traditional way — read the Cloudflare API docs, register an API Token, write a request script, debug the parameters, handle authentication — and it takes at least an afternoon.

The Key Insight: The Economics of MCP vs. API

What follows is the most valuable stretch of discussion from tonight.

After authentication succeeded, a question suddenly occurred to me: from the standpoint of token economics, which is the better deal — MCP, or traditional CLI + API?

The answer is subtler than you'd think.

The Traditional Model

You write code (a one-time investment)
→ The code calls the API (0 tokens per run)
→ You can drop it into a cron job and run it forever

Write once, run for a lifetime. Every run costs nothing.

The MCP Model

You speak plainly (AI has to participate every time)
→ AI reasons over which tool to pick (burns tokens)
→ Tool schemas sit resident in context (burns tokens)
→ Results get stuffed back into the conversation (burns tokens)

Every run burns money. The tool schema descriptions alone take hundreds to thousands of tokens, and the AI still has to reason about which tool to call and what parameters to pass.

Comparison table:

One important evolution to add: Code Mode is rewriting this table.

As mentioned above, Cloudflare's cloudflare-api uses Code Mode to compress the whole API's context overhead down to about 1,000 tokens. Do it the traditional way — expose each endpoint as a tool — and the schemas alone come to 1.17 million tokens, exceeding the context window of the vast majority of models outright.

Code Mode represents a trend: MCP's exploration mode is getting cheaper. But what it changes is the cost-benefit ratio, not the fundamental logic — landing deterministic operations as scripts is still the optimal solution.

The Conclusion: MCP's Greatest Strength Today Is Exploration, but It's Evolving Toward Production Systems

The right way to use it is a two-step approach:

Step one: MCP exploration
  → "What Workers does Cloudflare have?"
  → "What do this Worker's logs look like?"
  → "How do I create a KV namespace?"

Step two: land it as a script
  → Once you're done exploring, write the deterministic operations as code
  → Drop them into a cron job / CI/CD
  → 0 tokens, running forever

What MCP truly eliminates isn't the API call — it's the cost of "I don't know what to search for."

The old workflow was: Google → flip through ten docs → filter → find the right endpoint → write code. That stretch of manual filtering in the middle, MCP just kills outright.

A Third Model: When MCP Meets Amazon Advertising

At this point, I thought two models could explain everything. Until I thought of Amazon Ads.

We sell on Amazon and manage the ACoS across various ASINs; one of the daily jobs is running ads — pulling data, analyzing performance, adjusting bids. Claude Code is plugged into Amazon Ads' MCP server, so it can operate the ad manager directly in natural language.

But there's a question here: is this actually MCP or API?

The answer: neither, entirely. This is a third model.

Managing Amazon ads is a judgment loop:

Pull data           → can be scripted (API)
Analyze performance → requires judgment (Claude)
Make a bid decision → requires judgment (Claude)
Execute the change  → can be scripted (API)

Two of the four steps need AI; two can be automated. They're interwoven, and every turn of the loop needs Claude's judgment.

That means you can't pull Claude out entirely and turn this into a pure script. Every loop has to burn tokens.

But what's burning here isn't friction cost. What you're burning is judgment.

Traditional (exploratory) MCP's competitor is Google search. Amazon ad management's competitor is the time you spend sitting there watching the dashboard yourself.

A few thousand tokens is worth a few cents. What's an hour of you watching ads worth?

More importantly, this "judgment in the loop" model is accelerating its evolution. The current implementation is human-driven — you say one thing, the AI takes one step. But the combination of MCP + Agent + memory is already changing that. The future version is more likely to look like:

You set a goal ("keep ACOS under 20%")
→ The Agent loops on its own: pull data → analyze → decide → execute
→ It only notifies you on anomalies

That's the Agent Loop — an autonomous decision system. The human retreats from "step-by-step commander" to "goal-setter plus results-reviewer."

Let's lay out all three models in one table:

The third is MCP's true endgame form.

Who's Shipping MCP

As of April 2026, platforms that already have an official MCP include:

In January 2026, Anthropic released MCP Apps, with an initial cohort of partners including Amplitude, Asana, Box, Canva, Clay, Figma, Monday.com, and Salesforce. This is a landmark moment — MCP formally moving from "developer tool" into the "enterprise SaaS ecosystem."

There are also some unofficial community-built MCP servers — Telegram, Notion, Linear, for instance. The quality varies, but the protocol is standardized.

My personal read on who's most likely to ship MCP next:

• AWS Console — there's no way they let Cloudflare monopolize this ecosystem
• Google Cloud Console — GCP resources controlled directly in natural language
• Shopify — the whole e-commerce API wired up
• Vercel / Netlify — front-end deployment
• Azure — Microsoft won't be absent

It boils down to one sentence: any platform with an API — MCP is its natural-language shell.

My Predictions

Short term (2026–2027)

MCP will become a standard feature of every SaaS platform, just like OAuth. A platform that doesn't ship MCP will be seen as behind.

Developers' daily workflow will become: explore with MCP first, then land it with API. MCP won't replace the API — just as navigation doesn't replace the steering wheel. You still have to drive the car yourself, but you no longer have to read a paper map.

Medium term (2027–2028)

The third model — "judgment in the loop" — will become mainstream. Ad management, content moderation, customer support, financial analysis — this kind of repetitive work that requires human judgment, AI will embed deeply into via MCP.

Token costs will keep falling. The scenarios that feel uneconomical today because "every loop burns tokens" may, two years from now, be cheap enough to ignore.

Long term

The Console will recede from primary entrance to backup entrance.

Everyday operations — checking data, changing configs, pushing deployments — will increasingly be done in natural language. You won't need to open the Cloudflare dashboard and click buttons by hand. You won't need to log into Amazon Seller Central to look at reports.

But the Console won't disappear. Permission management, billing audits, confirmation of risky operations — these scenarios require visual confirmation and compliance trails, and can never rest on a single sentence of natural language.

A more precise way to put it: the Console shifts from operations interface to audit interface.

Seen this way, MCP is more than just a protocol. It's the inflection point in human-computer interaction, from the graphical user interface (GUI) to the natural-language interface (NLI).

The mouse click let ordinary people operate a computer. MCP lets ordinary people operate every cloud service.

The barrier drops another notch. But the security gate is still there.

A Closing Note

Back to tonight.

Three sessions, 20 minutes, the whole Cloudflare MCP wired up. I can now manage all my Cloudflare resources in natural language — domains, storage, deployments, logs, DNS.

Honestly, the feeling is a bit like using an iPhone for the first time in 2007.

It's not that it did anything earth-shattering. It's that you suddenly realize: all those things you thought you had to do that way — you don't, actually.