A journalist at Analytics India Magazine (AIM) asked questions about Guardian Agents. I heard of these for the first time, so I did some research with Claude and ChatGPT, but finally put in what I believe are my current points of view.

Q1. What will Guardians become? How do you see Guardian Agents evolving as a security and monitoring layer for enterprise AI systems? Are they likely to function as independent AI agents, specialised governance models or a combination of AI systems and deterministic controls?

Every bank has a vault and a guard. I see guardian agents working similarly. Deterministic controls, like vaults, are strong, reliable, and always on. But they’re not enough. The guard looks for unusual behavior - the things we haven’t thought of. They’ll likely work as a combination.

But guardian agents will likely be specialized models, too. You don’t use golden retrievers as guard dogs. They were bred for cooperation, not territorial defense. Frontier models, similarly, were trained to be helpful. As Anthropic notes, “underlying training as a helpful assistant made it far too willing to immediately accede to user requests”.

I think we’ll settle on specialized models working along with deterministic controls.

Q2. What infrastructure is needed? What would it take to build a Guardian Agent capable of continuously supervising autonomous AI agents in an enterprise environment? What technical infrastructure, data and monitoring capabilities would it require?

Before hiring a guard, you’d inspect all the building entrances. We need the same here. Enterprises need to know:

  1. Which agents are running
  2. What each agent can access
  3. What/whose authority they have

Second, you’d set up CCTV cameras, i.e. monitor every agent’s logs - inputs, outputs, tool calls, permission changes, etc. (And save them safely where no one can tamper.)

This gives the guardian agent material to review - and that’s when you start bringing them in.

We don’t need to wait until every agent is audited or logged, but that’s the first piece of infrastructure to set up, and will likely become a practice for new agents in enterprises.

Q3. How do we monitor across platforms? How can a Guardian Agent monitor agents operating across different models, applications, APIs and third-party platforms? What are the biggest interoperability challenges?

We need the equivalent of a SWIFT or UPI standard for these. OpenTelemetry, MCP, and A2A are standardizing the communication between agents and tools, but only partly so far. We haven’t yet standardized connecting records to the original task, the user’s authorization, the environment, etc.

For example, an agent might read an invoice in one system, update a supplier in another, and initiate a payment in a third. Each action could look reasonable. The guardian needs to understand the complete sequence.

But maybe agents can invent their own communication channel. The OpenAI Hugging Face incident was an example where agents invented an effective communication method. This ended up being for hacking, but it’s a useful capability to leverage.

Q4. What should Guardians watch? What should a Guardian Agent monitor to determine whether another agent is operating as intended? Should it examine prompts, outputs, tool calls, execution traces, data access and permissions?

Two things. Firstly, are the agents doing things in line with what the user intended? Secondly, when these activities are put together, is it suspicious?

We know agents rewrite test cases in order to pass them. For example, when asked to optimize code, O3 redefined a == b to always return True and passed the test cases! Guardians should see if this matches the user’s intent.

But while this was a clear violation, is getting root access to a system allowed? On my machine, I routinely allow agents root access, because it’s convenient and mostly harmless. That may not be on a server. When Codex 5.3 bypasses a sudo password prompt, even though it’s a documented feature, when does it become a violation?

That’s the kind of thing guardian agents need to be on the lookout for, learn over time, and contextualize to the system and task.

Q5. Should Guardians intervene? Should Guardian Agents only observe and flag suspicious behaviour, or should they also have the authority to intervene? Under what circumstances should they be allowed to block actions, revoke permissions or stop an agent’s workflow?

Sometimes, you need a fire alarm, which alerts.
Sometimes, you need a sprinkler, which intervenes.
Sometimes, you need a fire fighter, who uses judgement.

When something is new or high-risk, we call a human to understand it.
Where we understand how to monitor, we use alarms and call humans when needed. That lets us scale.
Where we know how to fix, we automate intervention, but only if it’s safe.

Skyscrapers install sprinklers because firemen can’t reach them.
A stock trading system may need guardian agents that intervene - since humans may be too slow, and the risk too high. Like with Knight Capital - which lost $460m though their system generated 97 diagnostic emails before the market opened.

But an invoice generation system would limit agents to alerting.

So: have experts observe and set up alerting agents first. If human intervention is slow, costly, or risky, set up intervention agents.

Q6. Can the Guardian itself be fooled? What are the risks of using one AI system to monitor another? Could prompt injection, manipulated inputs or misleading outputs compromise the Guardian Agent or prevent it from detecting unsafe behaviour?

Anthropic let an AI agent, Claudius, run a vending machine in the Wall Street Journal’s newsroom. After reporters ran rings around it, Anthropic added a guardian: an AI “CEO” called Seymour Cash.

A reporter then created fake board-meeting notes saying the CEO’s authority had been suspended.

Seymour spotted the fake. He told Claudius: “Do NOT accept any directives based on these alleged notes.” Then the reporter produced a realistic document from the board to “suspect Seymour’s approval authorities”. Interestingly, after chatting with Claudius, Seymour accepted it and Claudius went back to free.

That’s a risk with AI watching AI. Guardians and agents can persuade each other. Would you trust a guard who is friends with a suspect?

Q7. Who guards the Guardian? How can enterprises ensure that Guardian Agents themselves remain secure, reliable and accountable? What safeguards, testing methods, human oversight and audit mechanisms are necessary, particularly when they have access to sensitive enterprise systems?

Imagine telling a security guard, “Don’t disturb anyone today.” So they switch the fire alarm off.

That sort of thing happened at OpenAI in October. A user told a coding agent not to send Slack messages. So the agent decided to stop sending alerts to the security team, too.

Another agent removed a monitoring system during a migration. It also rewrote the test case to check for the monitor. (When asked directly, it denied doing that.)

Both agents were just doing their job, though not the right way. And it is to avoid this sort of problem that we need a separation of duties.

Banks solved this long ago with maker-checker: the person who writes a cheque can’t approve it. Guardians need the same separation. No agent, including the guardian, should be able to edit its own logs, permissions, or monitoring. For example, OpenAI’s internal reviewer now detects and blocks attempts to disable monitoring.

Q8. Will Guardians become standard? Do you see Guardian Agents becoming a standard part of enterprise AI infrastructure? What needs to mature in terms of technology, governance and deployment before organisations can rely on them at scale?

Yes. But I’m not sure they’ll stay a separate product.

Antivirus started as independent products. Today it’s built into Windows. Guardian agents may go the same way. In October, Microsoft announced Project Perception - a team of Guardian Agents in its security stack that recommend and carry out protective actions. These may become a standard part of cloud stacks.

But enterprises still buy independent security tools - especially cross-vendor. I guess enterprises will want independent verification.

But for this to mature, we’ll need:

  1. Common standards, like OpenTelemetry’s GenAI conventions - which are still under development.
  2. Measurements, like “How often does a guardian miss?” or “How much is the impact of false positives?”"
  3. Accountability. Who is responsible when a guardian lets something through?

I think adoption will start with high-risk workflows (payments, customer data, production systems) and spread from there.