Where MAESTRO runs the code it writes
An agent that writes code has to run it, and running unreviewed code is the part of the job that deserves the most suspicion. Here is what the boundary is made of, and what it does not cover.
One microVM per mission
The executor does not run on the host. Each mission gets its own Firecracker microVM — a hardware-virtualised guest with its own kernel, started under Firecracker's jailer, which drops it into a chroot under a dedicated unprivileged user before the VM process begins. A copy of your project is attached as a separate block device and mounted inside the guest; the rest of the guest filesystem is a disposable image that is discarded when the mission ends.
Containers share a kernel with their host. Firecracker does not, which is why every sandboxing product in this category is built on it, and why MAESTRO is a hosted service rather than something you install: the isolation depends on KVM.
No provider key is ever inside the VM
The executor inside the sandbox needs to talk to a model provider. It is never given a key to do so. The real provider credentials live in one file on the host, readable by the proxy process and nothing else. The VM receives a per-mission token that is only valid through that proxy, only for that mission, and only for as long as the mission runs.
The practical consequence is that the worst case for a compromised sandbox is bounded by what one mission's token can do, rather than by what an account-wide API key can do. The same proxy is where per-mission and per-account spend ceilings are enforced, so a runaway loop is refused at the point of the call rather than discovered on an invoice.
No route to the open internet
The sandbox has no general network path outward. There is no address translation rule that would let it reach an arbitrary host, and the host's firewall denies traffic from the VM subnet to everything except three things on the host itself: the model proxy, a package proxy, and a DNS resolver.
Real work needs dependencies, so package installs are allowed — through an allowlisting proxy that accepts a fixed set of registry hostnames and refuses the rest. Name resolution is constrained in the same way: the VM does not use a public resolver, it uses one on the host that answers for the allowlisted registries and returns nothing for anything else. Attempts that fall outside the allowlist appear in the proxy log as refusals, which is how we know the control is doing something rather than merely being configured.
An allowlist decides which hosts a sandbox may reach. It does not inspect what is sent to a host that is on the list — a package registry is still a package registry. We describe this as a bound on reachability, not as a proof of containment, and we would rather say so here than let you infer something stronger.
Before anything is sent anywhere
The working tree is scanned for credentials during preflight, before the repository's content reaches a model provider or a sandbox. A hit stops the mission and names the findings. The same scanner runs again over the diff the executor produced, so a secret the change would have introduced is caught before the commit gate rather than after the push.
Reading and writing your files
Everything that opens a path inside a project tree goes through one audited layer that resolves beneath the project root and refuses to follow a symbolic link, so a link planted in a repository cannot decide which file gets read or written. Host-side git runs with symlink creation disabled, and any place that puts repository content on the host is followed by a scrub. Mission metadata is never written into your project — it lives outside the tree entirely, so a mission cannot accidentally commit its own bookkeeping.
Tenancy
Every query is scoped to the authenticated user. A request for a mission that belongs to someone else returns "not found", never "forbidden" — the difference matters, because "forbidden" confirms the mission exists. Stored API keys are encrypted at rest. Administrators bypass ownership and credit checks by design, which is also why live verification of those guards is done from a non-admin account: testing a guard as someone the guard does not apply to proves nothing.
What leaves, and where it goes
MAESTRO sends repository content to third-party model providers. That is what the research, planning, review and execution phases are made of, and no amount of sandboxing changes it. We do not describe the product as local, sovereign, or as something your code never leaves, because none of those would be true. What the architecture above actually buys is narrower and worth stating plainly: the code runs somewhere it cannot reach your other systems, the keys are not where the untrusted process is, and the spend is capped at the point of the call.
Which providers receive what, and on what legal basis, is set out on the privacy page.
The thirteen phases covers where the sandbox sits in a mission, and verification records covers what gets written down about it afterwards.