Turning an API into an MCP server sounds straightforward: expose each API operation as an MCP tool and let the agent decide which one to use.

For small APIs, that can work well.

But enterprise APIs can contain hundreds of operations. And as agents connect to more systems, the number of available tools can grow quickly.

That creates four compounding problems.

**Context window tax.** Every tool definition consumes context that could otherwise be used for the user’s request, conversation history, retrieved information, and the model’s reasoning.

**Reasoning degradation.** The agent has to choose among an increasingly large collection of tools, often containing similar or overlapping operations. More choices can make selecting the right tool harder.

**Higher token costs.** Tool definitions consume tokens whenever they’re sent to the model. Unnecessary definitions can become a recurring cost across every agent interaction.

**Higher latency.** More context to process and repeated model-to-tool interactions can translate into slower agent experiences.

The challenge isn’t simply connecting an API to an agent. It’s giving the agent efficient access to the capabilities behind that API.

Kong addresses this challenge with **Code Mode**.

Instead of representing every API operation as an individual MCP tool, Code Mode can expose a much smaller interface through which agents discover and execute the operations they need at runtime.

The pattern is simple:

**Search → understand the schema → execute.**

An agent can search the available API surface for the operation it needs, retrieve the relevant schema on demand, and execute it without requiring every available operation to be represented as a tool in the model’s context.

Instead of:

**API → hundreds of MCP tools → hundreds of tool definitions → agent selects one**

Kong enables:

**API → compact MCP interface → agent discovers the relevant operation → retrieves what it needs → executes**

The agent retains access to the breadth of the underlying API without requiring the entire API surface to consume its context at once.

Finding the right operation is only part of the problem.

Real enterprise tasks often require multiple steps.

An agent might need to retrieve a customer, inspect their orders, update a record, and trigger another process to complete a single task. Traditional tool calling can require repeated cycles between the model and individual tools to complete that workflow.

With Code Mode, agents can use code to compose multiple operations, including logic such as loops, conditionals, and error handling.

That can reduce the number of model round trips required to complete complex work while keeping unnecessary tool definitions out of the model’s context.

The result is an architecture designed to improve three things that matter when agents move into production:

• - **Cost:** Reduce unnecessary token consumption and model interactions.
• - **Performance:** Reduce context overhead and unnecessary round trips.
• - **Quality:** Give the model a more focused set of capabilities to reason over at any given time.

APIs are only one source of the context agents need.

Enterprise agents increasingly need to work across APIs, existing MCP servers, and enterprise data sources. Context Management provides a common way to bring these context sources together and use Kong AI Gateway to generate the MCP server interfaces through which agents can access them.

This builds on the vision introduced with Kong Context Mesh: helping organizations curate and deliver enterprise context to agents instead of simply exposing every available backend capability directly to the model.

Because when it comes to agents, **more context isn’t automatically better context**.

The objective is to make the breadth of the enterprise accessible while making the context presented to the model relevant and efficient.

The first generation of enterprise AI focused heavily on models.

The next challenge is connecting those models to the enterprise.

Agents need APIs to take action. They need data to make decisions. They need tools to interact with business systems. And increasingly, they use MCP as the standard interface through which those capabilities are exposed.

That makes context a new layer of enterprise infrastructure.

And like any other critical infrastructure, it needs to be managed.

Organizations need to control what context agents can access, how that context is exposed, and how efficiently agents can consume it.

That is the role of Kong Context Management: **helping organizations turn enterprise capabilities into context that agents can efficiently discover and use.**

MCP solves an important interoperability problem. But interoperability alone doesn’t make an agent production-ready.

As organizations connect agents to hundreds of APIs, tools, MCP servers, and enterprise data sources, the challenge shifts from simply providing access to providing that access efficiently.

The future isn’t about giving every agent every tool on every request.

It’s about making the enterprise available to agents while delivering the right context when it’s needed.

**Agents can access more of the enterprise without having to process all of it at once.**

That’s what Kong Context Management is built to enable.

**Kong Context Management is generally available as part of Kong AI Management.**