Multi-tenancy is the question a security review asks first, so here is the answer in detail rather than in principle.
Today, the unit of isolation is the sandbox: one sandbox belongs to one person, and nothing runs in it that its owner did not put there.
The sandbox is the boundary
A sandbox is not a shared container with your neighbours in it. It is a machine of its own, with its own filesystem, its own processes and its own credentials. Two sandboxes cannot read each other’s files, cannot see each other’s processes, and cannot reach each other over the network.
One sandbox, one owner. A sandbox belongs to whoever created it. Sharing one means sharing credentials, which means losing the boundary that made it useful — so we do not offer sharing.
Nothing is inherited. When a sandbox is destroyed or reclaimed, its storage goes with it. The next sandbox is provisioned from an image and a snapshot, never from somebody else’s leftovers.
Credentials
Every user gets their own set of credentials for everything the platform touches on their behalf: source control, object storage, the sandbox runtime, model providers. No credential is shared between users, and no credential is ever reused across users even when the underlying service is shared.
Credentials are scoped to that user’s own resources where the provider supports it — a storage prefix, a repository, a namespace. Where a provider does not support scoping, the platform brokers access through its own service account and applies the boundary in the application layer; this is called out in the data handling document for the specific provider.
Limits
| Limit | Scope | Enforcement |
|---|---|---|
| Concurrent sandboxes | User | Checked at creation |
| Sandbox creation rate | User | Rate limited per hour |
| Sandbox lifetime | Sandbox | Idle reclamation |
| Disk | Sandbox | Allocated at creation, fixed for the sandbox’s life |
| Storage | User | Prefixed and quota-checked |
| API rate limit | Token | Per endpoint class |
Limit checks happen before work starts, not after. A user who has hit the creation rate is told before anything is provisioned rather than after it is running.
Storage
Object storage is namespaced by user, and every object key is prefixed with the user id. Access to a prefix requires that user’s own credentials; there is no code path that reads another user’s prefix.
A sandbox’s storage is owned by that sandbox and destroyed with it. There is no shared volume between sandboxes.
Secrets
Secrets you put in a sandbox are yours. The platform does not inject them, does not read them, and does not write them anywhere except inside the sandbox. If your agent needs a credential, you put it in the sandbox yourself.
Where the platform does handle a secret of its own — the credentials issued for a sandbox’s SSH access — it is stored encrypted and can be re-issued but not read back. A credential that was issued is not retrievable later; it can only be rotated.
The runtime
A sandbox runs untrusted code. That is the whole point of it, and it is where the isolation work matters most.
- Its own filesystem. Nothing outside the sandbox is mounted into it.
- Its own network namespace. No route to another sandbox, and no route to the control plane’s internal segment.
- No host access. No host filesystem, no host network, no metadata service.
- Egress rules. The outbound destinations are restricted, and a connection outside the allowlist is blocked and recorded.
- Explicit secret injection. Secrets enter the process as environment variables or mounted files, are scoped to the sandbox, and are never written to its log.
The exact isolation mechanism — a hardware-isolated virtual machine, or a container with a restricted kernel surface — and what precisely it does and does not share with the host, is documented here in full when the sandbox ships, rather than summarised now and corrected later. We would rather show you the boundary than describe it.
Network boundaries
internet
│
┌───────┴────────┐
│ edge / CDN │ static content, TLS termination, WAF
└───────┬────────┘
│
┌───────┴────────┐
│ control plane │ single service, user-scoped queries
└───────┬────────┘
│
┌───────┴────────┐
│ sandbox hosts │ one host, many sandboxes, no lateral routes
└───────┬────────┘
│
┌───────┴────────┐
│ sandboxes │ one owner each, egress allowlist
└────────────────┘
Lateral movement between users is not prevented by policy inside the application; it is prevented by the absence of a network path. A sandbox has no route to the control plane’s internal segment and no route to another sandbox.
What a user can see
A user can see their own sandboxes, their usage and their audit trail. They cannot see any other user’s existence, usage pattern, or data.
What we cannot claim
We do not claim the absence of vulnerabilities. Isolation is a design property we test and reason about; it is not a proof, and software with a shell is software with a shell.
What we can claim is that a compromise of one sandbox does not, by design, provide a path into another user’s data — and that sandboxes are the part of the system where untrusted code executes, so they are the part that gets the most attention.