Until now, KAi could tell you how to set up a service, suggest the right plugins, and point you at the docs. Useful, but you still had to do *some *of the work yourself.

V2 changes that. With our new Code Mode MCP integration, KAi can create, update, and delete resources directly in Konnect. Ask it to "create a new service and route for konghq.com at 5 requests per second with rate limiting and API key auth for a new user," and it does exactly that. It spins up the service, the route, the plugins, and the consumer, and then hands it off to you. 

Of course, anytime an agent is responsible for making a change (i.e., writing, not just reading) in critical API and AI platform infra, you want human-in-the-loop governance. And KAi provides just that. It’s smart enough to know that any write operation must require human approval. 

Before KAi touches anything, it lays out exactly what it intends to do and waits. You review the plan, then hit execute. Nothing changes in your environment without that explicit go-ahead.

If approved, KAi will be off to the races. In this instance, creating exactly the route and plugin config John asked for. Even better, the agent shows its work as it goes, so you can follow each step rather than waiting on a black box.

KAi can now generate downloadable artifacts from whatever it builds. Configure a set of resources, then ask KAi to hand it back as a decK file, and it produces a syntax-highlighted decK config to recreate the whole thing. Want the same setup as Terraform instead? Ask, and it builds it against our Terraform provider.

Every artifact opens in a dedicated panel, and you can copy it or download it directly. Generate several in one session, and they're all collected in the artifacts view, so nothing gets lost in the scroll. You can even pull an artifact back into context later to ask questions about it.

Standing up services and routes is half the job. The other half is seeing what they're doing — and V2 lets KAi build that too.

Now you can ask KAi for a full analytics dashboard in plain language. Tell it what you care about: request volume by service, p99 latency, top consumers, error rates on a specific route, and it assembles the dashboard for you, charts and all, right inside Konnect. No hunting through menus or hand-placing each report.

And because KAi already understands your environment through the MCP server, these aren't generic templates. They're wired to your actual control planes, services, and routes. Spin one up to keep an eye on an API you just launched, or ask for a focused view while you're chasing down a traffic spike, then hand it off to the rest of your team.

It's the same pattern as everything else in V2: describe the outcome you want, review what KAi proposes, and let it build.

A few early KAi adopters asked for visibility into consumption, so V2 makes it transparent. Each chat shows how much context you've used, and the sidebar tracks your daily usage across the org. When you hit the daily limit, KAi blocks further chat and resets the next day — no surprises, no guessing. You can also spin up fresh chats straight from the sidebar.

Not every team is ready to let an agent run creates, updates, and deletes against production on day one. So admins now get a switch.

Under organization settings, the new AI settings include an "enable right operations in KAi" toggle. Turn it off and KAi keeps working as a guide — it still reads your docs, answers questions, and suggests decK and Terraform — but it can't perform any API actions. Ask it to delete a plugin while write operations are disabled, and it simply tells you that's not enabled for the organization.

The point is a staged rollout. Admins can give KAi to their teams as a read-only assistant first, then open up write access when they're ready, rather than flipping everything on at once.

Here's the thing that makes all of this work: KAi isn't a closed box. Everything you've seen so far is powered by the Kong Konnect MCP server — and that same server is yours to plug into whatever agent harness you already live in.

What makes it powerful is the shape of the toolset. Instead of dumping hundreds of Konnect operations into your agent's context, the MCP server exposes four lean tools that let the agent discover what it needs and then act:

• - `tags` lists the available tool categories, so the agent can browse before it searches
• - `search` finds the right operations by query, ranked by relevance
• - `get_schema` pulls the exact parameter schema for the operations the agent picked
• - execute is the Code Mode layer — it runs a Python block that chains `call_tool(...)` calls and returns the result

This same Code Mode integration powers KAi inside Konnect. Rather than firing one tool call per step and waiting on each round trip, the agent writes a single block of Python that orchestrates the whole workflow — discover the control plane, create the service, wire up the route, attach the plugins, register the consumer — and hands back the final result. Lean context, fewer round trips, real multi-step work in one shot, all while having access to the full power of Konnect’s Admin API.

And because the MCP server authenticates with your token, every call respects your organization's role-based access controls and regional data boundaries — your agent only ever sees and touches what you're allowed to. (Admins who'd rather not expose it at all can disable MCP access org-wide from Organization Settings.)

The net: KAi gives you the polished, governed experience inside Konnect, and the Konnect MCP server gives you that same engine — Code Mode and all — wherever you build. Grab the plugin from the [_Kong AI marketplace_](http://developer.konghq.com/skills/install)_Kong AI marketplace_ and point your agent at Konnect.

You might be wondering: if KAi is now able to write changes, what else could it do? 

KAi still has some learning to do, but in future releases, we expect to broaden KAi’s platform capabilities and extend it into more platform use cases, such as:

• - Standing up full Konnect Metering and Billing pricing and packaging plans based on natural language or spreadsheet inputs
• - Generating MCP server interfaces on top of APIs with Context Mesh
• - Automatically debugging APIs and making Gateway config changes if KAi notices health or performance issues (with your approval in the loop, of course!)
• - And much…much more

All of this is deployed and ready anywhere where KAi is currently active. KAi is currently a Labs Feature and can be enabled in your organization’s Konnect Labs settings page.

If KAi is missing from your org, make sure to reach out to your platform admin or the Kong team. We can’t wait to see what you all build with your new agentic platform assistant!

[Learn more](https://developer.konghq.com/konnect-platform/kai/)Learn more in the docs.