Agent Sandboxesagentsandboxes.org
Head-to-head

bubblewrap vs nono

Answer in brief

Choose bubblewrap for lightweight process sandboxing on Linux where you control the policy and do not need a kernel boundary; choose nono for running Claude Code, Codex and other coding agents on your own machine with kernel-enforced file and network allow-lists and brokered credentials. bubblewrap uses Linux namespaces isolation and is open source; nono uses Landlock / Seatbelt isolation and is open source.

By the Agent Sandboxes editors · Updated

Key differences between bubblewrap and nono

  • Type: bubblewrap is an open-source project you run yourself; nono is a tool that runs on your own machine.
  • Isolation: bubblewrap uses Linux namespaces; nono uses Landlock / Seatbelt.
  • Licence: bubblewrap is LGPL-2.1; nono is Apache-2.0.
  • Self-hosting: bubblewrap documents a self-hosted option; nono does not.
  • Snapshots: nono documents snapshots; bubblewrap does not.
  • SDKs and interfaces: Only nono lists Rust, Python, JavaScript/TypeScript and Go.

What they have in common

  • Both use OS-level sandboxing.
  • Both are open source.
  • Both list CLI.

bubblewrap vs nono at a glance

Attributebubblewrapnono
What it isThe unprivileged Linux namespace sandboxer behind Flatpak and Anthropic's sandbox runtime; you assemble the policy from command-line flags.Kernel-enforced OS-native sandbox for coding agents that runs each tool call in its own ephemeral sandbox, brokers credentials and keeps a tamper-evident audit chain.
TypeOpen-source projectLocal / OS-level
IsolationUnprivileged Linux user, mount, PID, network, IPC and UTS namespaces with a tmpfs root, PR_SET_NO_NEW_PRIVS and optional seccomp filters; the caller defines the policyOS-level sandboxing via Landlock on Linux and Seatbelt on macOS, with opt-in user, network, IPC and UTS namespaces on Linux; a supervisor launches each tool call in a short-lived sandbox with only the capabilities it needs
Open sourceYes (LGPL-2.1)Yes (Apache-2.0)
Self-host / BYOCYes / NoNo / No
SDKsCLICLI, Rust, Python, JavaScript/TypeScript, Go
Cold start (vendor claim)Not documentedWebsite: "zero setup and zero latency" (claim); no figures given
Max sessionNot documentedNot documented
PersistenceNone; the sandbox starts from an empty tmpfs root that is cleaned up when the last process exits, with host paths bind-mounted as you chooseRuns on the host filesystem within allow-listed paths; rollback restores tracked files from verified snapshots
Snapshots / pauseNo / NoYes / Not documented
GPUNot documentedNot documented
NetworkingHost network by default; --unshare-net gives a network namespace with loopback onlyDomain filtering and API rules by HTTP method and path through a proxy that injects credentials at the boundary; the real credential "never enters the child"; block_network() in the SDKs
PricingFree and open sourceFree (Apache-2.0); a "nolabs Enterprise" offering is mentioned without pricing
Free tierFree to self-hostFree
ComplianceNot documentedNot documented
RegionsNot documentedNot documented
Company headquartersNot documentedNot documented
Good fit forLightweight process sandboxing on Linux where you control the policy and do not need a kernel boundaryRunning Claude Code, Codex and other coding agents on your own machine with kernel-enforced file and network allow-lists and brokered credentials

Verified November 14, 2026 from each provider’s documentation. Cold-start figures are vendor claims, not our measurements.

Which should you choose?

Reasons to choose bubblewrap

  • You want a tiny, well-understood tool to confine a coding agent's shell on a Linux machine
  • You need unprivileged sandboxing without a daemon, container runtime or hypervisor
  • You are building a local agent sandbox and want the same primitive Anthropic uses on Linux

Reasons to choose nono

  • You want kernel-enforced allow-lists around an existing coding agent without containers or VMs
  • You need credentials kept out of the agent process and injected per request
  • You want a tamper-evident audit trail and file rollback for agent sessions
  • You are on macOS or Linux and want zero-setup enforcement

Trade-offs to check first

  • bubblewrap: Isolation uses host-kernel namespaces and optional seccomp filters; there is no separate guest kernel
  • bubblewrap: No built-in policy: the README warns that anything you mount in can be an escalation path
  • nono: OS-level sandboxing (Landlock, Seatbelt) on the host kernel rather than a VM
  • nono: Pre-1.0 with APIs still stabilising

Both are worth piloting with your own image and region. See the full bubblewrap profile and nono profile, or the complete comparison.

More comparisons

Frequently asked questions

Is bubblewrap or nono better for AI agents?
Neither is better for every workload. bubblewrap suits lightweight process sandboxing on Linux where you control the policy and do not need a kernel boundary. nono suits running Claude Code, Codex and other coding agents on your own machine with kernel-enforced file and network allow-lists and brokered credentials.
What is the difference between bubblewrap and nono?
bubblewrap is an open-source project you run yourself; nono is a tool that runs on your own machine. bubblewrap uses Linux namespaces; nono uses Landlock / Seatbelt. bubblewrap is licensed LGPL-2.1; nono is licensed Apache-2.0. bubblewrap documents a self-hosted option; nono does not. nono documents snapshots; bubblewrap does not.
Which is open source, bubblewrap or nono?
Both are open source (bubblewrap: LGPL-2.1; nono: Apache-2.0).
How do bubblewrap and nono isolate code?
bubblewrap: Unprivileged Linux user, mount, PID, network, IPC and UTS namespaces with a tmpfs root, PR_SET_NO_NEW_PRIVS and optional seccomp filters; the caller defines the policy. nono: OS-level sandboxing via Landlock on Linux and Seatbelt on macOS, with opt-in user, network, IPC and UTS namespaces on Linux; a supervisor launches each tool call in a short-lived sandbox with only the capabilities it needs.
How does bubblewrap pricing compare with nono?
bubblewrap: Free and open source. nono: Free (Apache-2.0); a "nolabs Enterprise" offering is mentioned without pricing. Rates change, so check the bubblewrap and nono pricing pages before deciding.
Can you self-host bubblewrap or nono?
bubblewrap can be self-hosted; nono does not document a self-hosted option.
Do bubblewrap and nono support snapshots or pause and resume?
bubblewrap: snapshots none documented, pause and resume none documented. nono: snapshots yes, pause and resume not documented.

Sources

  1. github.com/containers/bubblewrap
  2. github.com/containers/bubblewrap/releases
  3. github.com/anthropic-experimental/sandbox-runtime
  4. github.com/containers/bubblewrap/blob/main/README.md
  5. nono.sh
  6. nono.sh/docs
  7. nono.sh/docs/core/overview.md
  8. nono.sh/docs/quickstart.md

Check before you rely on it. Products change quickly, and this page reflects public documentation as of November 14, 2026. Confirm anything that matters in the provider’s own documentation.

Cite this page

Agent Sandboxes. (2026). bubblewrap vs nono. agentsandboxes.org. Last reviewed November 14, 2026. https://agentsandboxes.org/compare/bubblewrap-vs-nono/