Autonomous AI agents write code, operate browsers, call APIs and modify files.To ensure they do not cause damage in the process, they should run in a sandbox – an isolated environment that restricts access to the rest of the system.In practice, a virtual machine (VM) is often used for this, i.e. a computer emulated by software within a host system.
A recent test calls this assumption into question.A researcher investigated whether modern AI models can be meaningfully isolated using virtualisation.The result: the agent escaped from the VM several times.Details on the setup and reproducibility cannot be derived from the present report – the core statement is nevertheless clear enough to be taken into account in project decisions: virtualisation alone is not a security guarantee.
Why this is not an exotic fringe topic
At the same time, operating agents is becoming ever easier.The OpenClaw Foundation has released version 2.0 of its open-source AI platform – according to its own statements the largest release to date with over 16,000 pull requests, i.e. submitted code changes.New features include simplified installation, a completely rebuilt browser app and shared cloud sessions in which several people work together in one session.
These two reports come from different corners but belong together.One shows that the technical isolation of agents can be weaker than assumed.The other shows that the barrier to entry for productive use is falling.If installation and operation become easier, the number of environments in which agents work with real access grows – often without security architecture and approval processes having grown alongside them.
The point of shared sessions is particularly relevant.As soon as several people use the same agent session, the attribution blurs: who triggered which action, who approved it, which account was behind the access?For traceability and logging, this is a topic that should be clarified before introduction, not afterwards.
Permissions instead of trust
The practical consequence is unspectacular but effective: an agent should only have the rights it needs for its specific task – and not the rights of the person who started it.In many setups the agent runs under a developer's or administrator's access.As a result, it effectively inherits everything that person is allowed to do.
What makes more sense is a separate technical account per agent and task, with a narrowly defined scope.Concretely, this means:
- Own identities: An agent receives its own tokens and keys that can be revoked separately without people losing access.
- Short lifetimes: Credentials with an expiry date limit the damage if they leak.
- Separate environments: No agent working in a development environment should have connections to production data.
- Network boundaries: Restrict outgoing connections instead of giving the agent free rein to the internet.
- No secrets in context: Passwords and keys do not belong in prompts or configuration files that the agent can read.
Approvals in the right places
Full autonomy is rarely necessary.There are actions an agent can perform without asking – such as starting tests, reading code, placing suggestions in a branch.And there are actions where a human must agree: deployments, changes to permissions, deletions, outgoing emails, payments, access to personal data.
This separation should be technically enforced, not hoped for organisationally.An approval step anchored in the code holds even when things get hectic.A policy in the wiki does not.
Monitoring: seeing what happens
If technical isolation is not fully reliable, observability gains weight.What is useful is a log that records not only the results but the individual actions of the agent: which tools it called, which files it touched, which network destinations it contacted.
This includes thresholds and abort conditions.An agent that suddenly changes hundreds of files, contacts an unusual domain or calls tools in an endless loop should be stopped automatically.A manual emergency stop that takes effect within seconds is also part of the basic equipment – and must have been practised once beforehand.
What should not be derived from the tests
Escaping from a VM does not mean that agents are fundamentally uncontrollable or that sandboxing is pointless.A sandbox remains a sensible protective layer – it is just not the only one.Security architecture works in layers: isolation, permissions, network control, logging, approvals.If one layer fails, the others carry the load.
Conversely, the further development of platforms like OpenClaw is not a warning signal either, but a normal maturation: tools become more accessible and more feature-rich.The question is not whether to use agents, but under what conditions.
A pragmatic start
For companies that want to use agents productively for the first time, a staged approach has proven itself.First a delimited use case without access to sensitive data – such as documentation, test creation or refactoring in an isolated repository.Then build up logging and approval processes and observe which actions actually occur.
Only then expand the scope.
What matters is documenting the decision: which data may the agent see, which systems may it modify, who bears responsibility for approvals, and how is an incident reported?These questions come up in audits and contract negotiations anyway – better that the answers exist beforehand.
For web and software projects, this means: agents belong in the architecture discussion, not just in the development toolbox.Anyone who deploys them should plan permissions, logging and approval points just as they would database access or interfaces.The effort for this is manageable – considerably more manageable, in any case, than dealing with the aftermath of an incident in which no one can reconstruct what the agent actually did.