✦ Zenity is a Founding Member of ServiceNow's Control Tower Alliance

Isolation or Inspection? Homegrown AI Agents Need Both

Portrait of Dan Levy
Dan Levy
•
Cover Image
Ask AI to

Key Takeaways

  • Runtime protection is two control classes. Isolation and permission controls decide what an agent can do; content guardrails inspect what flows through it.
  • They fail differently. Isolation fails through misconfiguration and default-off settings, while content guardrails fail through evasion.
  • Score them separately. An agent with sophisticated inspection and an unrestricted environment isn’t at the same level as one with both.
  • Treat rendered output as egress. Links, images, and other rendered content can carry data out.

AI agent runtime protection often means one thing in practice: a filter that checks prompts and responses. It’s a sensible control and a visible one. It’s also only half of what Domain 4 of the Homegrown Agent Maturity Model for Execution & Risk (HAMMER) asks about.

The domain’s key question has two parts: are there controls on what an agent is permitted to reach, and are there controls on what passes through it? The two are easy to conflate, and they fail in different ways. A program that treats them as one will tend to overestimate its own maturity.

blog post

Two Control Classes, Two Failure Modes

The table below summarizes the difference.

Isolation & permission controls

Content guardrails

What they do

Determine what an agent is structurally capable of, making an outcome impossible rather than discouraged

Inspect what flows through the agent

What they cover

Filesystem and network scope, execution environment, available tools, required approvals

Prompts, retrieved data, tool output, generated responses

How they fail

Misconfiguration, default-off settings, and paths that never pass through them

Evasion, because they depend on recognizing something

In Zenity’s terms, isolation and permission controls are hard boundaries, and content guardrails (the inspection side) are soft guardrails. Asking an agent to behave isn’t the same as building an environment in which it can’t misbehave. A mature program needs both, and should score them separately.

Strong inspection on top of an unrestricted environment is not the same maturity as having both, yet organizations routinely have the first while believing they have the second.

The Default Is Often Wide Open

At Level 1, runtime controls are close to nonexistent. The agent generally does what a cleverly worded input tells it to, and nothing sits between it and its tools. Level 2 is more deceptive: there’s basic input and output filtering on some agents, and isolation is available but left at its default. Depending on the runtime, that default can mean no filesystem or network restriction at all. Many vendors ship their agent and code-execution environments with outbound traffic enabled by default. Even when the documentation calls this out explicitly and explains how to turn it off, the default remains what it is, and defaults tend to stick.

Configuration alone isn’t enforcement, either. The Model Context Protocol’s own security guidance describes configuration-level allowlists as “cooperative boundaries” and places enforcement in the isolation layer above them.

Consider the common version of this. A customer-facing bot has an output filter, and the team feels covered. Meanwhile, the internal agents that read sensitive data run wide open, because nobody has changed the isolation settings from whatever shipped. Human-in-the-loop approval exists only where a developer happened to add it. The filter is real, the protection is partial, and the mismatch isn’t visible from the dashboard.

Defined, Then Tamper-Resistant

Level 3 makes the environment a deliberate choice. Agents run in a defined execution environment, with filesystem and network scope set explicitly rather than inherited from a default. The same scope applies to sub-agents and delegated work. Human approval is required for high-impact actions, and tool calls use dynamically updated allow lists. Enforcement also covers what the agent emits: links, images, and other rendered output are treated as an egress path, not as formatting. A markdown image whose URL carries encoded data, for example, leaves the environment the moment the client tries to load it.

Level 4 adds three properties that separate a configured environment from an enforced one:

  • Inline, context-aware enforcement. Intent and behavior analysis block unsafe tool chaining, and inline data loss prevention (DLP) stops sensitive data from leaving. The detection logic is tuned to your business-specific use cases and reviewed on an ongoing basis.
  • A mapped egress path for every tool. Network controls on one tool are never assumed to cover the rest. Egress paths are reviewed whenever an agent changes or a new release ships.
  • Tamper resistance. As covered in a previous article in this series, an agent can’t widen its own scope, disable its own isolation, add to its own allowlists, or create new sub-agents, skills, or hooks without the same approval path as any other privileged change.

A working kill switch completes the picture, and it only counts if it has been tested. These controls map closely to the goal hijack and tool misuse risks in the OWASP Top 10 for Agentic Applications, and to how Zenity approaches inline prevention of risky agent behavior.

Attacking Your Own Controls

At Level 5, enforcement is unified across build, runtime, and governance layers rather than split across disconnected point tools. Autonomy is constrained in proportion to risk, and containment through kill switches and circuit breakers operates at agent speed.

The distinctive habit of this level is adversarial testing of your own defenses on a schedule. Allowlists, egress controls, and output sanitizers are attacked deliberately, and whatever gets through changes the controls. A red team that tries to bypass your own egress enforcement tells you something no dashboard can.

See How Your Runtime Controls Score

Runtime protection is the domain where the gap between what teams believe and what’s enforced tends to be widest. Scoring isolation and inspection separately is a quick way to find it, and it makes the next request to engineering far more specific.

Download the HAMMER eBook to see all five levels of Runtime Protection & Guardrails and score isolation and inspection on their own terms.

All Articles

Secure Your Agents

We’d love to chat with you about how your team can secure and govern AI Agents everywhere.

Get a Demo