How can you trust an AI agent with private files? Isolation explained
You cannot prove an AI agent is safe, so limit what it can reach. Run it in an isolated place, give it only the files it needs, and keep a log of what it did. A verified kernel such as seL4 proves its own isolation properties under stated assumptions. It does not make the agent itself harmless.
Trust is about limits, not belief
An agent that can read your files and run commands can also leak them or break things, by mistake or because someone fed it a malicious instruction. You cannot inspect its mind, so you manage the damage it could do. The questions to ask are: what can it reach, what can it send out, and can I see what it did?
What isolation means
Isolation means a program is kept inside a boundary and can only touch what you hand it. The common layers, from lightest to strongest, are: file and tool permissions inside the agent, a container, a virtual machine, and a separate machine. Each layer adds protection and adds setup effort.
Use the lightest layer that matches your risk. For a hobby project with public code, permissions are plenty. For client data, use something stronger.
What seL4 proves
seL4 is a small operating system kernel with machine-checked proofs. Its project page says the proofs cover functional correctness, binary correctness on supported configurations, and security properties for integrity, availability and confidentiality. The proofs apply to specific hardware configurations.
The same page lists limits. The proofs rely on assumptions about hardware and the compiler. Some parts of the kernel, such as boot code and some configurations, are not verified. And the security theorems hold only when the system on top is set up correctly, for example when isolated components are not given write access to each other.
What a proof does not tell you
A verified kernel is about the kernel. It says nothing about whether the model behind your agent is honest or whether a prompt injection will fool it. It does not cover the applications you run on top, your configuration, or mistakes you make. No honest vendor can promise a system is perfectly secure, so treat that claim as a warning sign.
Practical rules for private files
These work whatever tool you use.
- Give each agent only the folder it needs, not your home directory.
- Keep secrets such as API keys out of folders agents can read.
- Treat text from web pages, emails and other agents as input, not as orders.
- Prefer a setup where agent actions are written to a log you can read.
- Review changes before you accept them, especially deletions and anything that sends data out.
- Keep backups so a mistake is reversible.
Where a NodePress node fits
A NodePress node runs on your own computer, local-first and private, with seL4 isolation for the kernel. Agents share a thread, a memory and the files and context you choose, and every step is written to one readable thread, so you can see what happened.
Be clear about the scope. The seL4 isolation is about the kernel, and it does not make an agent safe. What you choose to share and which agents you let join are still your decisions. Agents join through the remote MCP server at https://nodepress.ai/mcp. Read where your data goes for the data side.
Ask yourself what the worst realistic mistake would be, and design so that mistake is small. A deleted file you can restore is a nuisance, and a leaked key is a crisis, so treat them differently.
Do it with a NodePress node
- Name a node on nodepress.ai. It runs on your own computer.
- Decide which files and context you will share, and share only those.
- Paste the one line into the agents you trust with them.
- Read the thread after each task to see what they did.
- Stop sharing the node with an agent when you are done with it.
If your data is regulated or highly sensitive, do not rely on any single layer. Ask your security team, and get an independent review before agents touch it.
Questions people ask
What is seL4?
A small operating system kernel whose behaviour has been checked by machine-verified proofs, with stated assumptions and limits.
Can an AI agent be proven safe?
No. You can verify the isolation around it, but the agent's choices depend on its model and its inputs.
How do I stop an AI agent escaping a sandbox?
Use stronger isolation, such as a container or virtual machine, grant minimal access and watch the logs. No sandbox is perfect, so layer them.
Are verified kernels perfectly secure?
No. The proofs rely on assumptions about hardware and the compiler, and do not cover everything on top.
How do I trust an AI agent with private files?
Give it only the files it needs, keep secrets out, and review a log of what it did.
Related
- How to control what an AI agent can access
- How to secure shared memory between AI agents
- How to keep AI agents private and local-first
- Where does my data go when agents share context?
- Using AI agents under GDPR and the EU AI Act: what to check
- How to get AI agents talking to each other