In recent months, the hype machine around agentic API consumption has been working overtime. In 2025, Kong reported that as many as 90% of enterprises are actively adopting AI agents and 79% expect full-scale adoption within three years. The agents aren’t coming; they’re here.

The importance of agent experience has taken center stage, while AI and large language models (LLMs) are literally changing the way we build API specifications. But there’s an elephant in the room that needs to be addressed: consumption of APIs by AI agents as we know it today can be messy, insecure, and prone to failure.

“If you wrap your 100 endpoints in MCP tools, kick them over the fence, and expect an agent to make something that works out of them, you might be surprised,” Frank Kilcommins, head of enterprise architecture, Jentic. “Because it likely won’t lead to the results you want.”

For instance, benchmarking by Orbital found that accuracy falls to as low as 30% when LLMs are exposed to 300 API endpoints. On the other hand, enterprises with more composable implementations are far better equipped to support AI at scale, according to a recent report from the MACH Alliance.

At our 2025 Platform Summit, Kilcommins joined us to talk about how Arazzo, a new specification from the OpenAPI Initiative, can help to address some of those issues without stifling agent productivity. As the co-author and maintainer of the specification and a governance board member of the OpenAPI Initiative, these are problems that Kilcommins is intimately familiar with.

To him, Arazzo is poised to play a key role in bringing determinism to agent-based workflows to make them more reliable. Below, we’ll dig into what that process looks like in practice.

Chatbots vs. Agents

“The difference between a chatbot and an agent is action: chatbots chat, but agents act.” There’s a lot of nuance in play with that distinction, which Kilcommins emphasizes in his talk.

Whereas chatbots are primarily conversational interfaces, with little agency of their own beyond responding to prompts, AI agents are goal-oriented systems that can plan and execute tasks, remember and respond to contextual cues, and compose their own workflows.

To misquote “Uncle” Ben Parker, with great agency comes great responsibility. We can’t afford to let agents get it wrong, and we already know the solution: “The ease and reliability with which agents can discover, reason about, and safely execute API operations is enabled by rich machine-readable documentation, clear boundaries, and predictable runtime behaviors.”

We’ve written elsewhere on facets of making documentation AI-ready, including the provision of readable summaries and descriptions, correct HTTP methods, full use of examples, semantically rich schemas, appropriate HTTP status code usage, and so on. But, as agentic API consumption increases, scalability and standardization will become even more important.

A Brief Introduction to Arazzo

The Arazzo Specification is an approach to document use-case-oriented workflows, which Kilcommins describes as a “series of API calls woven together to accomplish some business objective.” By defining this sequence in a programmatically readable format, the goal is to simultaneously improve both developer experience (DX) and agent experience (AX).

It’s worth noting that Arazzo stands within the OpenAPI Initiative but apart from the OpenAPI Specification, functioning as its own spec. This, Kilcommins explains, is because it’s underpinned by some fairly specific use cases and outcomes that relate mostly to workflows:

• Deterministic context-aware recipes for API use that make sense of unwieldy API descriptions
• Improving the discoverability of living documentation for both agents and humans
• Bridging gaps where workflows span more than one API, improving auditability and compliance
• Functional test specification to assert workflow promises throughout API evolution
• Open standard for codifying intellectual property in API-oriented capabilities

To put it another way: if the OpenAPI Specification standardizes how we describe the surface of a single API, Arazzo aims to do the same for how multiple APIs connect together in a workflow.

Arazzo is useful for things like mitigating errors. For example, Kilcommins outlines how a FailureAction Object can be used to set limits around the timing or frequency of retrying a call when encountering a 503 error. Or trigger a refresh token workflow when an API call returns a 401 error due to an invalid or expired bearer token.

Without the right framework in place, these errors could constitute breaking changes in a workflow. That can have some nasty consequences, like an agent hammering retries until it hits a rate limit or giving up on an entire flow because things have fallen down at the first step.

Can’t MCP Handle Workflows?

Released by Anthropic in 2024, Model Context Protocol (MCP) is an emerging standard for connecting AI agents with APIs. The protocol uses JSON-RPC messages to standardize interactions between models and tools or resources exposed by MCP servers. It’s seen by some as a de facto solution for interoperability between APIs and LLMs.

Kilcommins doesn’t necessarily agree, arguing that agentic API consumption needs predictability, discoverability, and deterministic execution to work at scale. There are examples of LLMs going off the rails, such as Air Canada’s chatbot inventing refund policies after failing to query an authoritative system, when not paired with workflows or grounding mechanisms.

As multiple API calls or APIs are connected together by agents, the risk of emergent behaviors compounds. The stakes of the “whose fault was that hallucination?” blame game become infinitely more serious when they result in data breaches or regulatory non-compliance.

Kilcommins suggests that, because it can’t figure out workflows safely or predictably due to LLMs having tool limits and reasoning strategies that are inherently indeterministic, MCP on its own isn’t enough. There are also factors like rapid token consumption within limited context windows, attention mechanism limitations, and performance and accuracy degradation to consider.

“MCP and similar protocols are useful exposure layers,” he states, “but they do not solve these deeper integration and reliability challenges.” He continues that “OpenAPI or AsyncAPI descriptions are the raw ingredients for the value that’s on offer but, ultimately, it’s the workflows that give you the recipes to extract success.” That’s where Arazzo might come in.

The Future of Arazzo Is Agentic (and Human)

Kilcommins doesn’t see this as a Betamax vs. VHS, Coke vs. Pepsi, or Mac vs. PC situation. The goal, he suggests, “is very precise deterministic control, so you expect the same outcome to happen correctly the first time you run, and every time after that.” And that vision could well be a collaborative one, with Arazzo and MCP working together side by side.

“Together, [they] can get you to a scenario where you can focus on the discoverability of the capabilities themselves, giving you the ability to surface use cases incredibly quickly and, once that’s done, call or invoke the tool for execution and hand back to the deterministic layer.”

As for implementation, he sees the potential in automation: “I don’t expect too many people to be authoring Arazzo documents by hand; we have AI-powered generators that will get us 90% of the way. We’ll have low code and no code implementation, with drag and drop mechanisms.” We can also encourage safe experimentation by agents with tools like the agentic sandbox.

For instance, AI agents may very well be primary Arazzo users. As Kilkommins tells Nordic APIs, “We’re also having some very interesting findings from letting OpenClaw loose on APIs, and it absolutely loves Arazzo as an effective brain dump.” This allows them to store a reusable deterministic workflow definition outside of context windows.

Additional power, Kilcommins suggests, comes from the tooling that can understand Arazzo. In representing the actual flow that’s taking place, he says, we have an example of living documentation. “Which is much more palatable than the 200 or so lines of code that might be there from a YAML perspective,” says Kilcommins. “And it’s also very good for machines.”

Arazzo provides a better look at real workflows and their business outcomes rather than a single piece of the puzzle, and that’s powerful for both humans and machines. It remains to be seen whether it will capture the imagination of developers or become the de facto solution in the same way that the OpenAPI Specification has, but we’re excited to see where it goes next.