APIContext home
Blog & News

Opinion

Taking the P out of APIs: did the intent work?

A robot recoils from an open mailbox, flag up, with nothing inside, between a sent letter and a full box.
8 min read

Written by

Mayur Upadhyaya

CEO

Mayur is CEO of APIContext, building tools that help enterprises understand and prove API resilience at scale.

In Britain, "taking the P" is the polite version of saying someone is taking the piss. Take the P out of API and you get AI. It is a conference joke, but it points to something serious: we talk as though AI has replaced the old software stack, while almost every practical way of putting AI into production still depends on APIs.

Call OpenAI, Claude, or Grok? API. Put OpenRouter in front of several models? Another API. Host a smaller model yourself? Your applications still need an interface to call it. Give an agent a useful job and it will reach for tools, often with yet more APIs behind them. Apparently nobody told the API key about the revolution.

The API layer stayed. The caller changed.

To see why that matters, imagine a deliberately simple request: find the correct customer record, return it within an agreed time, and use only permitted access. A person making that request does not care whether the application used a direct API, a Model Context Protocol (MCP) tool, or several services in sequence. They care whether the right record came back, on time, through an authorised route.

In a conventional application, engineers usually define the sequence. There may be branches and retries, but we can specify and test the expected paths. An agent can choose a different route for the same intent. One run might call a direct API. Another might discover an MCP tool. A third might take a longer chain. The destination is still "the right customer record"; the dependencies along the way are less predictable.

That is the shift I want to examine. This post is the written version of my talk at the Nordic APIs Summit 2026 in Stockholm on 14 October. For years, a central operating question has been: is the API working? In an agentic workflow, we also have to ask: did the intent work?

A green number only describes the check that ran

Availability remains important. Three nines, or 99.9%, permits 43 minutes and 12 seconds of downtime in a 30-day month. But before treating any availability figure as a judgement on an AI service, we have to ask what was actually checked.

An October 2026 snapshot in our API directory showed 99.85% availability for an OpenAI project. That sounds like a verdict on model availability until you inspect the monitor. The active check requested the model catalogue at /v1/models; it did not run inference. It can tell us about that catalogue request. It cannot tell us whether a model would answer, whether its answer would be correct, or whether our customer-record task would finish.

Table 1. Different checks in one directory snapshot

ProjectAvailabilityActive scenarioWhat it cannot establish
OpenAI99.8492%Model catalogue /v1/modelsInference availability
Anthropic99.9699%Expected 401 authenticationInference quality
AssemblyAI100.0000%Submit plus follow-up workflowOther providers' performance
Deepgram99.9360%Control-plane checkTranscription (excluded from the current schedule)
Grok100.0000%Routing; expected 421Inference quality
Google PaLM100.0000%Catalogue; generation paths returned 404Successful generation

This is not a reason to discard component monitoring. It is a reason to state its boundary. A response from one endpoint proves something useful about one endpoint, from the places and at the times we tested it. It does not automatically prove the business outcome sitting on top of it.

The first blind spot is time. In saved API directory analysis from June 2025 to May 2026, we looked at project-week rows where at least 99% of checks passed but the 95th-percentile latency was at least five times the median. The share meeting that rule rose across four successive saved blocks, from 5.9% to more than 9%. Those are shares of project-week observations, not shares of unique endpoints or foundation models. The composition of the monitored projects can change between blocks, so this is a signal to investigate, not proof of a universal industry trend.

For the customer waiting on a record, the distinction is immediate. An answer that arrives after the agreed deadline can be a failed task even when every component eventually returns a successful HTTP status. If a workflow chains several services, latency tails matter more than the comfortable median shown on a dashboard.

A nearby front door is not the whole journey

The next blind spot is place. Applications and agents do not all call from the same cloud region. A customer in Australia may trigger work from one location while the model, tool, and business system sit elsewhere. A distributed edge can make the first connection quick, but that only measures the front door. The work behind it may take a different route.

Our historical Hugging Face checks show why the distinction matters. In the Asian vantage points we observed, median connection time fell from 185 ms on 17 February 2025 to 2 ms a week later. Europe and North America improved too. By March, median connection setup was 1 to 2 ms across the observed continents. That is a striking improvement in how quickly the caller reached the service.

The whole response still varied by geography. In March, median total response ran from 131 ms in North America to 395 ms in Oceania, a spread of more than 3x. By May, the corresponding project medians were 107 ms and 237 ms. Both figures improved, but the regional gradient did not vanish.

Table 2. Hugging Face connection and total response medians

ContinentJan connJan totalMar connMar totalMay connMay total
Africa22578813141253
Asia18868923792237
Europe9135313011176
North America1517021311107
Oceania19865013951237

Milliseconds; historical AWS-vantage project medians. Connection setup is not a measure of inference location.

These measurements are consistent with a change in ingress. They do not locate model inference or prove that compute was centralised in North America. The same public IP can also represent different physical edges through anycast, so resolving to one address does not settle the question. What we can say is narrower and more useful: bringing connection setup close to the caller did not make the end-to-end response identical everywhere. If a task has a deadline, where the caller sits remains part of its dependability.

Another AI project illustrates the same need for careful scope. In late September and early October 2026, Anthropic vantage points in several regions resolved the same public IP and showed single-digit millisecond median connection times. But that monitor expected a 401 authentication response. It supplied evidence about network setup and the behaviour of a rejected request, not about inference performance. Under the CASC score, that bounded authentication scenario passed every check in September and scored 9.72 out of 10. The score is meaningful within that scenario; it is not a provider-wide grade for an agent task.

The tool has a front door too

Now put MCP into the customer-record journey. MCP gives agents a way to discover and call tools. That can make useful capabilities available, but the MCP service, its identity path, any proxy, and the underlying API all become part of what the agent depends on.

We monitored GitHub MCP session setup and tools/list from multiple locations over 30 complete days, from 6 September to 6 October 2026. Stockholm passed all 357 discovery checks. On availability alone, that looks reassuring. Yet the median discovery session took 1.58 seconds in Stockholm, against 0.35 seconds in US East and 3.55 seconds in Chennai. Chennai also had three failed checks among 340 observations, while US East passed all 358 of its checks. Across all monitored vantages, the GitHub session monitor recorded ten connection failures in 8,635 observations.

Table 3. GitHub MCP discovery results by vantage

VantageChecksPassesP50 msP95 msP99 ms
US East358358345.5612.6674.43
Stockholm35735715841883.61971.56
Chennai3403373550.5910219643.33

6 September to 6 October 2026. Across all monitored vantages: 8,625 of 8,635 passed; ten connection failures.

Those timings are not the latency of every GitHub agent task. A client may reuse a session, and our check stopped at discovery. It did not invoke a business tool or retrieve a customer record. Still, a successful discovery check can hide a material regional wait before the useful work begins. A single global pass rate conceals that difference.

We also checked a Pipedream proxy path associated with HubSpot. It returned three HTTP 502 responses in 8,561 observations during the same 30-day window. We observed failure on the proxy path; the result does not identify which upstream component caused it. Nor does a successful tools-list response prove that a later HubSpot operation will succeed. The point is architectural: a proxy is another boundary to observe, and its result is not interchangeable with the result of the underlying business task.

The assurance gap is after the green check

This is where I think the observability conversation needs to be more precise. Logs, traces, and component checks inside our systems are essential. They can show whether an API returned 200, whether an MCP session opened, or how long a server spent on a request. But a collection of green component lights does not, by itself, show that the agent selected the right tool, followed an allowed route and returned the correct customer record before the deadline.

The outside-in question is what the caller experienced. From the places where customers or agents actually run, we need to know which path was taken, how long the task took, what result came back, and whether that result still meets the agreed expectation over repeated runs. A technical assertion can establish that a response was valid JSON. A task assertion must go further: was this the right record, obtained with permitted access? With probabilistic orchestration, we also need to notice when the behaviour changes after a model, prompt, tool, or dependency changes. That is the job for outside-in monitoring of AI workflows, which measures the route as the caller takes it.

Our own MCP examples stop before that last step. They show that a session could start and tools could be listed. They do not prove the agent chose a permitted tool or achieved the business outcome. That is not a flaw to hide in the footnotes. It is the assurance gap the industry has to close. The next test must define a real task, execute its permitted routes and judge the result with controls appropriate to that task.

So I would not replace the old question. We should keep asking whether the API is working. We should add the question the user actually cares about: did the intent work? For our simple example, that means the right customer record, on time, through permitted access. If your dashboards are green but your customers or agents still struggle, pick one critical workflow and compare what you currently measure with what successful completion requires.

That is where dependability begins.

See what your APIs look like from the outside.

APIContext gives engineering, product, and customer success teams a shared view of API reliability, conformance, and customer impact.

Start free
Agent View