
Get security briefings from the Threat Research Team
New campaigns, attacker techniques, and detection guidance — straight to your inbox.
Falco Feeds extends the power of Falco by giving open source-focused companies access to expert-written rules that are continuously updated as new threats are discovered.

This post is written by guest author Matt Adams, VP and Head of AI Security for Sapiens, who will be participating with us in the Ground Truth London event on AI workload security.
If you work for an organisation and something goes wrong on your watch, you know you're accountable. You have an employment contract, and if you get something badly wrong, there are consequences. Most of us rarely think about that, but a lot of security depends on it. An acceptable use policy, for example, works largely because people know someone will ask questions if they ignore it.
An agent doesn't care about any of that. It has a goal, and it will do whatever it can, to the best of its ability, to reach it. Usually there's no malice involved. It simply has no stake in what happens once the task is done.
The question I keep putting to security leaders is what takes the place of accountability when an agent is doing the work?
Finding what's actually running
Accountability starts with knowing who, or what, is doing the work. A couple of years ago, in one heavily regulated organisation I worked in, that was largely taken care of for us. The web filters were strict enough that AI services weren't reachable unless they'd been explicitly allowed through. Nobody could get to them, so there was nothing to inventory.
Few organisations are in that position now, so the first job is to go and look for the processes that are running and the data that's leaving.
Some of what you're looking for won't look like software at all. In many of the organisations I've spoken to, someone has written a skill or a prompt that works well for a task and shared it with colleagues. Sometimes that goes through a review before it's published, sometimes it's a Markdown file sent over chat. A lot of what drives these tools is plain text, and that makes a problem much harder to spot than an unfamiliar executable would be. After all, a risky instruction file and someone's meeting notes can look much the same.
Boil it down, and you can't hold anything to account before you know it exists. A useful inventory also records who is behind each agent, because that person is where the accountability still sits. In my experience, security leaders most often underestimate how widely AI is already being used, which is why inventory must come first.
Watching from outside the agent
Once you know what's running, the harder question is how you keep it within bounds.
The models underneath these agents are probabilistic. However good they get, they can be fooled into doing things they shouldn’t, and they can make mistakes. Telling an agent in its prompt what it mustn't do helps, but that's a request it won’t always honour. A control has to be enforced somewhere the agent can't change.
Isolation is the strongest of those controls, but every restriction makes the agent less useful, and people will work around tools that can't do the job. The key is giving each agent the access its task needs and no more. Visibility then shows whether you've drawn that line in the right place, and if (or where) you can safely loosen the reins.
Then there's the record of what an agent did. If it comes only from the agent, or from the harness running it (the framework the agent operates inside), it's only as reliable as the thing you're trying to oversee. The agent's own account is still worth having, because it shows what the agent set out to do. It just can't be the only record, because it's least reliable at the moment you need it most.
So oversight needs two things outside the agent and its harness: a view of what actually happened on the system, and the ability to stop the agent and roll back when something looks wrong. Neither should depend on the agent cooperating.
It helps to think about agents the way security teams think about people with privileged access. Insider threat programmes have long relied on observed behaviour over self-reporting, and the same principle applies to agents. Watch what the agent did, not what it says it did.
Saying yes to more agents
Done well, this lets an organisation approve more agents. Most organisations I talk to want to allow a wider range of agents, connected to more data sources, doing useful work. What usually holds them back is the worry that nobody would notice if an agent went somewhere or did something it shouldn't. Good visibility and effective guardrails deal with that worry, and once they're in place you can go faster.
Take a coding agent that needs to read from a production database to debug an issue. Without controls, the safe answer is no. With a read-only role for that task, no access to anything else and a log of every query it runs, you can approve it.
Visibility also changes the role security plays. I don't think security should have the final yes or no on which AI tools an organisation uses. A security team will naturally optimize for good security outcomes, sometimes at the expense of what the business is trying to do. The decision belongs with the data and AI function, or with a Chief AI Officer if you have one. Where neither exists yet, it sits best with whoever owns the AI adoption programme, often the CIO or CTO.
Of course, security should be a clear voice at the table alongside the other stakeholders, and once a tool is approved, security still owns its guardrails.
That voice simply carries more weight when it comes with evidence. Having an independent view of what agents are actually doing lets security tell the business, with some confidence, how far it's safe to go. And that’s a more useful role for security than being the final gate.
Before approving your next agent
Nobody I've spoken to has a complete answer yet to what replaces accountability for an agent. The closest I've found is a record of what the agent actually did, tied to the person who set it running, that the agent itself can't alter. Before approving your next agent, I'd challenge you to answer these questions:
- Do you know which agents and tools are in use across your organisation, including the ones nobody approved?
- Who has the final say on the next agent, and what does security need to show them to inform that call?
- Could you stop an agent mid-action without relying on it to cooperate?
- If an agent did something it shouldn't tomorrow, could you reconstruct what happened without relying on its own account?
I'll be working through these questions with Richard Smith, Founder of Codification and Alessandro Lo Prete from Sysdig's Threat Research Team on the panel at Ground Truth: London on 9 December. If these questions are on your list too, come and join us.
