cd /news/ai-agents/introducing-tinfoil-bunkers · home › topics › ai-agents › article
[ARTICLE · art-172876] src=tinfoil.sh ↗ pub= topic=ai-agents verified=true sentiment=↑ positive

Introducing Tinfoil Bunkers

Tinfoil launched Tinfoil Bunkers, confidential always-on sandboxes for running AI agents and customized workflows inside per-Bunker secure enclaves with memory encryption and isolation handled by AMD and Intel microarchitecture, which Tinfoil says verifies end-to-end before a user connects. The product includes a built-in software library powered by Nix and a "Bunker's Perimeter" that keeps secrets out of reach of the workloads, addressing agents that run with full credential access such as `--dangerously-skip-permissions` or `--yolo`. Tinfoil positions Bunkers as an extension of the personal computer for agentic computing, citing OpenClaw's popularity and a cybersecurity climate in which cloud breaches are no longer limited to nation-state actors.

key takeaway

Tinfoil Bunkers run each agent workload in its own AMD/Intel secure enclave with memory encryption and a Perimeter that keeps credentials outside the sandbox, so agents get scoped access instead of full secret possession.

by read15 min views1 publishedNov 19, 2026
Introducing Tinfoil Bunkers
Image: Tinfoil (auto-discovered)

We’re excited to introduce Tinfoil Bunkers, a confidential home for running highly customized workflows such as AI agents, experiments, and interactive work, all with the same verifiable privacy and transparency guarantees offered to you by our other products. Bunkers are fortified sandboxes, designed to withstand rogue agents and external attackers.

Bunkers are a true extension of your personal computer #

Bunkers act as an extension of your personal computer, where you can put any files you store or run locally into a confidential cloud environment that’s isolated from your computer and always running. It’s a new approach for personal and agentic computing and we’re really excited to be pushing the frontier for privacy here.

Tinfoil Bunkers offer:

  • A home for your agents : Bunkers are always running, even when your computer is off, with an expansive built-in software library (powered by Nix!), and are built to keep your data for as long as you need.
  • Confidentiality : Bunkers are fully confidential and were built to withstand compromised infrastructure. Every Tinfoil Bunker runs in its own secure enclave, with memory encryption and isolation boundaries handled by AMD and Intel microarchitecture.Nobody, not Tinfoil or anyone else, can see inside a Bunker . Bunkers verify this end-to-end before you connect, like all confidential Tinfoil products.
  • Agent governance and credential isolation : While privacy from the host is great, a rogue agent or workload compromise can pose an even larger immediate risk. Agents today often run with full possession over their credentials, often without any guardrails (--dangerously-skip-permissions ,--yolo ). There are certain approaches, such as using other LLMs to monitor agent work, which have been the default answer until now, but they don’t give us a model to reason about what a Bunker can or cannot do. The Bunker’s Perimeter, in contrast to these approaches, lets you keep secrets out of reach of your Bunkers, and allows for peace of mind while giving your agents access.

Try bunkers now #

Stop reading this. Bunkers are best experienced firsthand. Try making one! Once it’s set up, add a connector. You can set a policy and give agents scoped access to your connector, and then verify that anything you didn’t authorize gets blocked.

Now that you’re back, or if you prefer to examine the architecture closely before you use Bunkers, we’ll continue along with considerations, the threat model, and an in-depth discussion of how we designed them to be as secure and user-friendly as possible. Secure and user-friendly are often thought of as opposites, but here there’s synergy: we think the best user experience requires not worrying about your agent doing bad things with your credentials.

Why we built Bunkers

OpenClaw was huge. It’s clear that personal intelligence is incredibly beneficial for people, but it’s also one of the most personal uses of AI that exists today. It’s an extension of you. Personal intelligence needs files, they need access, and they need a home, so it can help you. This can’t always be your computer.

On a more wary note, AI is becoming integrated in our lives. As tech knows more about us and acts on our behalf, private gardens for thought are becoming more scarce and isolated. We think that personal assistants are going to be as deeply embedded in human life as they did with smartphones. Unlike the smartphone revolution, by default this doesn’t come with privacy. Tinfoil started with offering the best available intelligence privately. Now as that intelligence is embodied it needs a place to act on your behalf.

Simultaneously, the recent eventful cybersecurity climate calls into question Cloud security. Cloud breaches were previously assumed to only be within reach of nation-state actors, but now anyone pointing a model at the right repository with the right prompt can just look inside. Confidential computing is unusually well equipped to defend against this: Since the entire execution context that a workload is running in is encrypted, a VM escape vulnerability or host compromise cannot expose any information about anyone’s workloads being run on the machine, taking Tinfoil and cloud providers out of the trust boundary. Tinfoil Containers makes this accessible to anyone trying to run an existing workload, and Bunkers are built on top of this.

Why might you use a bunker?

Bunkers are perfect when you want to run a workload in the Cloud but keep the privacy of your personal computer. Any time you think of using cloud VMs is also a reason to use a Bunker, but you get guaranteed privacy as well. That is, uninterrupted processing, more compute than you have on hand, somewhere to experiment with risky things, a place to run your agents, or to build a second brain - all without needing to keep your laptop open. The sky’s the limit here.

Threat model: setting a new standard for isolating workloads #

There are currently two kinds of attacks which concern bunker workloads: stopping an attacker from getting in, and preventing an agent from breaking out.

Stopping an attacker from getting in

All of our Trusted Computing Base (TCB) is fully reproducible and auditable, and we have spent a lot of time on minimizing the attack surface available for the host to perform on workloads.

In the previous blog post, Less is More, we detailed how we were able to eliminate 300MB of OVMF boot firmware for an extremely minimal, 300-line boot purpose-built for starting Confidential Virtual Machines (CVMs). Firmware is especially important because it is privileged code which determines the entire future state of the enclave, so an attack at that level would compromise the guarantees an attestation is supposed to make.

We use this new lighter firmware in our Bunker product, and it lets us make a new kind of argument that is very important for Bunkers: one bunker should never be able to impersonate another. All Bunker enclaves boot the same stable cvmimage release, but the measured image is parameterized at boot time with a config which differs from enclave to enclave. Since a user’s key is bound directly inside of the config, it is both impossible for anyone else to access it, and for anyone to maliciously impersonate it as one of the enclaves you control.

Attacks on container runtimes have become increasingly common in the past year. In light of this news, the industry has started turning to MicroVM solutions such as Firecracker or gVisor as a stronger security boundary. Despite improving kernel isolation, host escapes still happen, which lets sophisticated attackers gain host control and then breach every VM running on a system. By using CVMs, which can’t be accessed by the host, Bunkers gain this extra layer of security.

Infrastructure is becoming increasingly less trustworthy. Earlier this year, OpenAI reported that an RL environment was escaped, hacking into several organizations in pursuit of answers for an eval run. In more recent news, Fireworks reported a breach, leading to Cursor and other customers moving off the platform. We believe that all infrastructure will be a prevalent point of failure eventually, and the best solution is to build a cloud that requires as little trust as possible.

Stopping agents from breaking out

Agent authorization currently looks something like this:

We don’t think it’s fair to say a Bunker is truly private or trustworthy unless we’ve somehow solved this. The problem is that to meaningfully say what level of access a Bunker has, we can’t give it access to real credentials. If it has access to real credentials, any exfiltration of this leads to invisible malicious activity the user isn’t even aware of. Inspired by progress in workload authorization, we instead give the Bunker just a single credential, that is its identity. Then, in the event of a breach the Perimeter can revoke access, and that’s that.

Wherever a credential is expected, we instead provide a fake one for the AI or software to use, and then the Perimeter substitutes it on the way out through the network. This has more nuance to it than it seems: authorization works differently on different websites, and we want to avoid fatal mistakes like, for instance, an agent emailing its fake password value, and then the Perimeter dumbly substituting in the real one once it’s sent out.

To handle edge cases like this, Bunker ships with an expansive set of presets describing various services you might want to connect to, where credentials are expected to exist, and what the general behavior of a platform looks like. If a credential is attempted to be used in an unexpected place, it instantly gets rejected.

This is better than the naive case, where generally it’s a user’s job to configure their services correctly. The Perimeter supports 100+ common APIs and MCP servers out of the box, and you can proxy common protocols such as SSH, IMAP, and Postgres out of the box. These service connections also contain knowledge of how each service works, which allows users to generally set policies like only allowing read only access, or blocking all payments.

However, access control is inherently a layered problem. Beyond substituting credentials or restricting endpoints, eventually application-level details enter the picture. Take for example the problem of giving SSH access to a bunker: withholding the SSH keys from the agent is easy, however, it doesn’t help if the machine it connects to contains the production database password. What we really want is to give the agent the ability to SSH into a host while restricting its set of actions.

The perimeters architecture is designed to make solving these kinds of specific problems possible. At its core it handles a small conceptual problem: connectors responsible for proxying requests collect a set of facts, and then run it through a central policy engine using Rego, a datalog-inspired language built for writing policies in a rich way, before performing any action. Access control and proxying can be implemented at arbitrarily low level or high level, with the structure remaining the same.

We think this gives a model for capturing actions at enough granularity so that users can reason about Bunker behavior effectively.

Passkeys

You’ll notice that when using Bunkers that you never have to provide an SSH key. Instead, we use passkeys, in an approach similar to what we currently do for Tinfoil Chat. To manage or create a Bunker, we redirect you to an open-source web application known as Tinfoil Terminal, that hosts the Perimeter on terminal.tinfoil.sh. That is the only domain where keys are unlocked, and we intentionally enforce this split to minimize what you have to trust. In that environment, we generate new SSH keys, and encrypt them under your PRF passkey (which can be something like a system-level key, or a Yubikey). You can then sign in (using your PRF passkey) to the Tinfoil CLI on your local computer allowing for seamless access to your Bunkers across entry points without complex key management.

If you prefer to bring your own SSH keys, the dashboard allows you to choose a CLI-only mode. This makes it impossible to access through the Tinfoil Terminal website, but keeps the private key completely under custody of your ssh-agent.

Complete isolation #

We’re pursuing complete isolation with Bunkers. Many coding harnesses use process isolation: on your computer the environment that does the execution is a separate, isolated process. The problem is that on a typical personal computer, the boundaries between programs are quite fuzzy and thus permissions are often made both too broad and unhelpful. The north star for desktop security, Qubes OS, had to rethink the whole desktop experience assuming untrustworthy applications from the start, and it turns out doing so has interesting UX implications, such as splitting clipboards between the host and the guest, or even disabling fullscreen! While it's still possible to get all of this right, a lot of personal computing defaults to “fail open” behavior.

The other issue with process or container isolation is it inherits the trust assumption that the kernel it’s running on is secure, which is itself becoming less of a useful security boundary with how often new vulnerabilities are discovered with the latest frontier models. Hence, to make a security argument strong enough to withstand rogue agents, we put the Perimeter in a separate CVM than the Bunker, and the Bunkers network is completely restricted, from the outside, to only go through the Perimeter. This has a fun consequence: everytime you SSH into the Bunker you’re actually tunneling through the Perimeter because it literally cannot be reached outside of the Perimeter.

That wasn’t all the isolation though! We kept isolating, to fix a problem that is unavoidable for most multi-tenant applications: Noisy neighbor leakage and observing microarchitecture-level behavioral side channels. Even if two VMs on a host are separate, giving one arbitrary code execution puts a real stress test on how much information can be recovered from carrying out long term observation on the machine. Since the Perimeter is its own CVM, we can harden against this: we put all Perimeters in a completely different physical set of hosts from any other workload that’s running. Even in the worst case of Bunkers being able to side channel other Bunkers, no secrets can ever be stolen, because they live in an entirely separate environment.

This also means that the Perimeter’s log of what happens in the Bunker is very hard to tamper with or change. Taking care of these factors gives us the confidence to have agents explore and try out things in the Bunker.

Sandbox building blocks #

Containers

We offer hosted Containers so our customers can run their own models or other workloads privately. To make Bunkers work on top of Containers, we’ve added some new features:

  • Firmware and private configs : It’s now possible to dynamically configure a workload at launch-time, letting you set variables dynamically which are measured and then attest to it.
  • Persistent volumes : Most Tinfoil workloads, such as inference or training environments, are stateless. Now we’ve added encrypted volumes for persistent state.
  • Network isolation : You can now isolate a workload from the rest of the internet, and map containers to stable LAN IPs.

Persistence

For confidential production workloads, statelessness is the gold standard of hardening measures. The fewer interactions a VM has with a host, the easier it is to reason about and reduce TCB. When given the option, a product or protocol should be redesigned around this principle. However, for persistent work and files you need an encrypted disk. We had to think a lot about reducing the attack surface and mitigating threats such as side channels, since this was the first time we offer a solution for persistent workloads. A common footgun in confidential settings is using the modern default disk encryption standard for Linux (LUKS). However, LUKS embeds a lot of metadata on the algorithm and parameters of the cryptography being used into the disk format, and this metadata can be changed by the host while the data is at rest. Instead, we just use dm-crypt and dm-integrity directly, and initialize them with fixed values. In general, any host-controlled source of configuration parameters is intrinsically untrustworthy in confidential settings.

As for side channels, RedHat discussed in an article and a recent talk that side channels correlating a history of disk ciphertexts over a deterministic IV and known block layouts can reveal plaintexts in cases such as database writes and repeated accesses in object storage. Fortunately, dm-crypt allows us to mitigate this by using a randomized IV mode (as opposed to plain mode) for AES-XTS at the cost of some performance and disk overhead.

Our setup reuses well-audited linux security components while allowing for high throughput disk writes.

It’s important to note that access pattern correlation is not covered under this model, as they apply just as equally to CVM RAM. Protections against this can be implemented at an application level on top of a volume with performance depending on your workload. As an example of one such implementation and a detailed study of the tradeoffs, see Opal, a private memory system for personal AI built on Tinfoil.

A feature-rich workspace

We built Bunkers to be simple and drop-in-able for users. To provide a good workspace experience we leverage Nix, plus a clever trick Replit came up with a few years ago known as Supercolliding Nix stores. Nix provides hermetic and reproducible packaging across builds, which allows a small workspace package store to live on top of a larger external store with no risk of conflicting versions and builds. In Replit's case, the store can be as large as 2TB!

With Tinfoil, this means Bunkers are built as thin images that mount over a large immutable store, and most common development software available in Nix is ready to go instantly for users or agents.

Future

We plan to continue iterating on making Bunkers fully-featured and easy to use, including by adding and maintaining connectors to the Perimeter. We hope to bring a drop-in personal desktop extension for your agents that gives you the peace of mind of knowing your credentials are safe, even when out of sight.

Furthermore, during the process of creating Bunkers we mapped out lots of useful primitives for these problems. We’re excited to make these building blocks available for our customers to easily build their own secure bunker-like offerings. As agents are more useful, we want to see more private solutions that maintain personal human agency.

Subscribe for Updates

RSS Feed Stay up to date with our latest blog posts and announcements.

── more in #ai-agents 4 stories · sorted by recency
── more on @tinfoil 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/introducing-tinfoil-…] indexed:0 read:15min 2026-11-19 · —