Back to Blog
TechnicalNovember 4, 2026

AI Coding Agents Changed the Game: Why Mezite Now Inspects Requests

Why AI coding agents changed our trade-off on request inspection, how Iddio became msh local, and why inspection belongs on the workstation rather than in MezHub.

In August, we published Rejecting the Everything Proxy. In September, we made the argument again in Do One Thing Well. Both posts draw a firm boundary: Mezite does not parse database or Kubernetes protocols inside its access control plane.

Today, Mezite ships a local gateway that inspects Kubernetes and cloud API requests. That deserves an explanation, especially for anyone who chose Mezite because of those earlier posts.

We have merged our sibling project, Iddio, into Mezite. Iddio built request-level controls for AI coding agents. That work now ships as msh local, MCP Access and Mezite Desktop, with managed local policy and central audit in MezHub.

The earlier reasoning still holds for human sessions. AI coding agents change the trade-off enough that we now need a second boundary, closer to where commands run.

What the Earlier Posts Assumed

The operator in those posts is a human sitting at a terminal. They authenticate, receive access, and work inside a session. Their intent lives in their head: inspect a failed deployment, repair a configuration, restart a service.

Session-level access answers whether that person may reach the system. Short-lived credentials limit how long that access lasts. Recording and audit provide evidence of what happens. The person remains responsible for choosing each operation and interpreting its consequences.

In that world, placing another parser between the terminal and every infrastructure service has a substantial cost. It adds certificate handling, protocol compatibility, streaming behaviour and failure modes. A general-purpose database gateway also needs to understand database wire protocols. Kubernetes brings interactive streams as well as ordinary API requests.

That complexity needs to earn its place. For a human operator who already understands the task, routing every operation through a central interpreter often adds less value than tightening identity, access duration and session accountability. Keeping those parsers out of MezHub remains a useful architectural constraint.

A Session Is Too Large a Unit for an AI Coding Agent

An AI coding agent also works in a terminal, but the resemblance hides an important difference. A developer delegates an objective. The AI coding agent chooses a sequence of commands to pursue it, often using the developer’s existing credentials.

Those choices are non-deterministic. A second attempt may take a different route through the same problem. Tool output becomes input to the next decision. Repository files, issue descriptions and responses from external services can contain prompt injections that try to redirect the work.

The volume changes too. An AI coding agent can inspect resources, apply changes and retry failures at machine speed. A developer approving the original task cannot reasonably review every intermediate decision in advance. A short-lived credential still permits a great deal of damage during its valid lifetime.

“This AI coding agent may use kubectl” is therefore the wrong unit of permission. It bundles reading pod status, changing a deployment and opening a shell in production into one decision. Approving a troubleshooting session does not establish that every request made during it is appropriate.

We need a place to stop an individual operation while allowing useful work to continue around it.

The HTTP Method Does Not Tell the Whole Story

Consider an AI coding agent investigating an unhealthy Kubernetes deployment. Listing pods and reading deployment status are reasonable first steps. Scaling the deployment to zero is a very different response to the same incident.

At the API boundary, that scale-to-zero operation can be a PATCH setting the replica count to zero. Cordoning a node can be a PATCH setting spec.unschedulable. A rollout restart can be a PATCH changing a pod-template annotation. A rule that treats every PATCH as the same ordinary write misses the operational meaning of the request.

The same problem appears with interactive access. kubectl exec into a production pod opens a path to commands inside the workload. It deserves different treatment from reading that pod’s status, even though both operations target a pod in the same cluster.

For Google Cloud, a call made through gcloud that deletes a dataset needs scrutiny for the destructive API operation it invokes. The fact that the developer authorised cloud access earlier does not make that deletion part of the approved task.

These are the distinctions request classification exists to expose. The classifier examines the supported API’s method, path and relevant payload semantics, rather than relying on the executable name or HTTP verb alone. Policy can then make a decision about the operation actually heading upstream.

Four Tiers, With a Human at the Risk Boundary

msh local uses four named tiers:

  • observe covers routine reads, lists and describes.
  • modify covers ordinary changes.
  • sensitive covers destructive or high-impact operations.
  • break-glass covers exceptional access such as interactive execution and changes to access controls.

Classification and permission are separate decisions. A tier describes the operation’s risk; policy determines whether to allow it, deny it or hold it for approval. Being a read does not automatically make access to credentials harmless, and being a write does not make every change equally dangerous.

A policy can allow routine observation, require approval for changes and destructive operations, and deny break-glass access unless an operator explicitly permits it. This gives the AI coding agent room to investigate without granting an unattended path from investigation to deletion.

When policy requires approval, the gateway holds the request before forwarding it upstream. The developer reviews it in Mezite Desktop or through msh local approval. Approval becomes a decision about a concrete operation rather than a guess about everything an AI coding agent might do during the next hour.

There is still a cost in interruptions. Policies that ask for a nod on every routine read train people to approve without looking. The point of tiers is to put attention where the consequences justify it. Time-boxed access escalations use Mezite Access Requests through msh request; individual request approvals belong in the local approval workflow.

Inspection Happens on the Workstation

The placement matters as much as the classification. msh local runs on the workstation where the AI coding agent drives tools such as kubectl, gcloud, aws and fly. It classifies requests locally and enforces policy before inspected requests leave for their destination.

Interception is selective and opt-in per host. The inspect list in policy defines which destinations receive request-level inspection. Connections outside that list pass through without payload inspection. Installing a gateway does not mean every application on the workstation suddenly has its HTTPS traffic decrypted.

For inspected hosts, this is real interception: the local gateway terminates TLS, examines requests and establishes the upstream connection. It brings certificate trust, parser maintenance and compatibility work. Moving that work to a workstation does not make the engineering cost disappear.

What changes is the benefit and the scope. We can intervene at the point where an AI coding agent turns a broad instruction into a specific infrastructure operation. We can also limit inspection to the hosts an operator chooses, instead of putting a universal protocol interpreter in the central access path.

MezHub still does not run a general-purpose database or Kubernetes protocol proxy. Kubernetes and cloud API requests inspected by msh local do not need a new central data path through MezHub. We have added local request enforcement while retaining the control-plane boundary described in the earlier posts.

Tool Calls Need the Same Decision Point

CLIs are only one way an AI coding agent reaches infrastructure. MCP servers expose tools directly, so a policy boundary limited to terminal commands would leave a second route to consequential operations.

MCP Access applies per-tool policy, approvals and audit to AI coding agents’ tool calls through Mezite. The decision attaches to a tool invocation instead of a shell command. An AI coding agent being allowed to connect to an MCP server does not, by itself, justify unrestricted use of every tool that server exposes.

The common requirement is an enforceable decision before the operation runs, with a record afterwards. The local gateway documentation and MCP Access documentation describe those two entry points.

Central Policy Without Central Protocol Parsing

A local enforcement point still needs consistent administration. Enrolled workstations receive managed local policy from MezHub. Administrators use mezctl local-policy get, mezctl local-policy set -f policy.yaml and mezctl local-policy history to manage that policy centrally.

The local audit log lives at ~/.mezite/local/audit.jsonl, one JSON line per decision, appended and never rewritten. When a workstation is enrolled, its audit events also upload to MezHub’s audit log. That connects central oversight with the requests enforced locally, without requiring MezHub to interpret the live Kubernetes or cloud protocol stream.

This does not make prompt injection impossible or turn an AI coding agent into a trusted operator. It gives administrators a narrower permission boundary and gives developers a chance to stop risky requests before they take effect.

For existing users, nothing changes for SSH. Your certificates, sessions and access workflows continue as before. msh local, MCP Access and Mezite Desktop are opt-in capabilities. If you want request-level controls for AI coding agents, they are now part of Mezite; adopting them does not require routing all your infrastructure protocols through MezHub.


MT

Mezite Team

Engineering