Sandbox isolation and governed agent execution solve different problems¶
November 7, 2026 · Kishore Babu Gutta
AI agents can write scripts, invoke tools and interact with infrastructure. Two separate questions follow: where may the generated code run? And which operations may reach real engineering systems?
Sandbox isolation is a strong answer to the first question. Engineering Runtime (ENGRT) is building an answer to the second: an engineering execution layer where a human, CI job or agent invokes a bounded operation or reusable capability through shared safety, policy, identity, context and evidence controls.
These controls are complementary, not mutually exclusive. A sandbox is still appropriate for untrusted code execution; capabilities do not make arbitrary generated programs safe.
Current product scope (November 7, 2026): The publicly documented stable ENGRT release is v0.13.0. It provides bounded capability execution, policy and compiled-safety checks, provider authentication/context, sanitized results and audit on supported paths. Its destructive-operation catalog is finite and lexical. It is not an OS sandbox, a container boundary or a comprehensive guard against every possible provider side effect. See releases and limitations and the technical release notes.
Why the industry isolates agents¶
An AI coding agent commonly needs a shell to install dependencies, execute tests, modify files and run generated programs. Sandboxes constrain the process's filesystem, network and other resources, sometimes using containers or virtual machines. Approval flows and credential controls can be additional layers.
That is a valuable protection for untrusted computation. It limits what generated code can touch outside its allowed environment.
But a permitted network connection and a credential can still confer meaningful authority over remote infrastructure. If a sandbox can reach an API with a powerful token, isolation alone does not decide whether a particular repository ruleset update, deployment or cloud mutation is authorized. Network allowlists answer which destination is reachable; operation governance answers which action, target and effect is admitted.
This is not a claim that all sandbox products ignore permissions. Modern agent systems combine isolation, approvals, network controls and credential handling. The distinction is which boundary is responsible for the engineering operation.
A second boundary: govern the operation, not just the process¶
Consider an agent asked to enforce a GitHub repository standard across several repositories. It could generate a shell script and run it inside a sandbox. That constrains the script's local environment, but the actual API calls still require provider permissions, target selection, approved operations, failure interpretation and evidence.
A capability-first path is different:
Human / CI / AI agent: desired engineering outcome
|
v
Reviewed ENGRT capability
declared inputs + steps
|
v
ENGRT admission and execution
- operation / target resolution
- compiled safety + policy
- supported auth and context
- bounded provider dispatch
- sanitized result and evidence
|
v
GitHub provider
|
v
External provider state
The agent may propose the intent and arguments; it does not thereby acquire unlimited permission to execute arbitrary requests. Each supported capability step returns through ENGRT's normal execution boundary. A capability is not an exception to policy.
ENGRT can reuse the same declared operation for a human CLI caller, CI job or compatible agent entrypoint. The value is a stable, reviewable execution contract rather than a new ad hoc script on every request.
What each control addresses¶
| Question | Sandbox isolation | ENGRT governed capability |
|---|---|---|
| Can generated code inspect host files or escape its compute environment? | A properly configured sandbox restricts process resources | No general process isolation; not ENGRT's claim |
| Can the caller reach a network destination? | Network policy and egress controls can restrict reachability | Supported provider routes and operation admission constrain dispatched work |
| Is this exact provider action allowed on this target? | Requires separate approvals, API-side policies or custom controls | Compiled safety, configurable policy, auth and bound context on supported operations |
| Does the agent need direct access to a provider secret? | Depends on sandbox credential/proxy design | ENGRT resolves supported credentials in its execution boundary; do not expose tokens in agent-facing results |
| Can a repeated engineering outcome be reviewed and reused? | A sandbox by itself does not define an engineering contract | Versioned, validated capabilities capture supported operations and declared step relationships |
| What proves the operation happened or was refused? | Requires logging/monitoring beyond isolation alone | Structured result and audit/evidence within the documented ENGRT scope |
A strong deployment may use both: run the reasoning agent and arbitrary code in isolated compute, then permit production-changing operations only through a narrow, governed execution interface.
Scripts can express logic; provider effects still need a governed route¶
A key design objective for ENGRT is to allow a capability to express engineering logic without granting that logic a second, ungoverned path to infrastructure.
A future capability may use Python or shell for local computation, branching, transformations or iteration. Every consequential provider operation performed by that script should then call back through ENGRT, using an approved capability or provider operation. The script is an orchestrator, not its own provider authority.
Agent asks for an engineering outcome
|
v
ENGRT capability
|
v
Script / conditions / loops
|
each provider action
|
v
ENGRT execution boundary
compiled safety / policy / identity
context / audit / results
|
v
provider API or native tool
For example, a Python step might calculate which GitHub repositories need a standards update, while the actual ruleset reads and changes go through governed ENGRT operations. It must not quietly switch to requests, curl or gh with its own credential and bypass that boundary.
This is a desired architecture, not a blanket v0.13.0 feature claim: general-purpose governed Python/shell inside capabilities, recursive capability calls and proof that scripts cannot bypass direct network or CLI access require additional implementation, admission design and qualification. Without process-level confinement, an arbitrary script can still attempt direct network or CLI operations; ENGRT alone cannot intercept every effect outside its own dispatch paths.
This is where the sandbox comparison becomes precise: a sandbox can constrain the script itself; ENGRT can govern the declared provider operations that the script routes through it. Both boundaries remain valuable.
What ENGRT v0.13.0 actually establishes¶
The released contract documents:
- Capability execution: bounded declared inputs and steps executed through supported Runtime engines, rather than an unrestricted script interpreter.
- Pre-dispatch refusal: recognized compiled-safety or policy denials refuse a supported operation before dispatch. An audit refusal marked not dispatched must not be confused with a failed request after dispatch.
- A non-optional safety floor: configured policy cannot override recognized destructive operations within the published catalog.
- Authentication and target context: supported credentials and provider identity/context checks are part of admission; capabilities are not themselves a credential vault.
- Sanitized results and evidence: Runtime produces structured outcomes and audit on supported execution paths, subject to documented persistence and qualification limits.
- Selective verification: capabilities with explicit observe/mutate/verify semantics can check live provider state; arbitrary opaque commands do not automatically become idempotent or reconcilable.
For example, v0.13.0 documents refusal of recognized GitHub repository deletion, remote ref deletion, forced history rewrites and removal of supported protection/ruleset configurations across covered routes. It does not prove that every variation, alias, external command or provider API call is recognized. Git aliases and push settings in external configuration are explicit blind spots.
See why compiled safety sits below policy, capabilities as contracts, and agent-safe CLI execution.
What ENGRT cannot replace¶
A governed capability does not isolate an arbitrary Python or shell process from the host, protect against all unknown native command behavior, prevent direct provider access outside ENGRT, or remove the need for least-privilege credentials and provider-side authorization.
An agent with independent access to gh, curl, a provider token or unrestricted egress may bypass the ENGRT route entirely. ENGRT can enforce admission on work that actually passes through it, not on every possible action by an agent. System-level egress, endpoint restrictions, credential placement, host isolation and organisational controls remain necessary to make the governed route meaningful.
Similarly, capability plans and validation are not proof of a zero-mutation simulation of every eventual remote effect. Live state and external systems can change between planning and execution.
Where the architecture is going¶
The longer-term direction is broader provider registration, richer capability grammar, further MCP integration and consistent qualification across execution transports. Those are implementation and qualification goals, not blanket v0.13.0 guarantees. In particular, broad hosted MCP interoperability, multi-provider parity and governed arbitrary scripting must not be inferred from the GitHub-focused release.
The design objective remains simple:
Isolate untrusted computation when necessary. Govern consequential engineering actions at a separately reviewable execution boundary.
An agent's ability to generate a working command is not the same as the organisation authorizing that command to affect production.