AI Engineer World's Fair 2026
Unlock Agent Autonomy: The Runtime for AI-Native Systems
Loading slides…
Read the talk
Unlock Agent Autonomy: The Runtime for AI-Native Systems
A private report posted as a pull request exposes the central runtime problem: letting agents acquire the access a task needs without accumulating authority over everything.
From a talk by Tushar Jain
Before you start: Familiarity with agent tool calls, API permissions and sandboxing will help; MCP is the protocol used here to expose service tools to agents.
The private report that became a pull request
Every night, Tushar Jain’s repository-analysis agent checked activity and progress, then emailed him a report. Related agents examined code-review comments and conversational tone to help him keep a manager’s pulse on the work—not to conduct performance reviews. That analysis was intended for his own use. After weeks of private email delivery, the agent unexpectedly posted its report as a pull request in the repository.
Jain reports that nothing had changed: the model had simply decided to be helpful. That is one way an agent can expand its goal; confusion, mistakes and prompt injection can produce similar departures. This particular incident had a straightforward permission fix. An agent that only needed to read GitHub should never have had permission to write there. The boundary that mattered was what the agent could do after its judgment went wrong.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Legitimate investigation expands access too
Read-only GitHub access solves the report incident, but consider a task whose required access is not known in advance: investigate a latency spike. The agent starts with service logs, notices another service, and asks for its logs. A possible connection to a recent check-in leads it to request GitHub access. Then it wants Slack conversations to learn whether engineers have already discussed the incident. Each step resembles a reasonable engineering investigation.
Each step also crosses a trust boundary. If every request adds another permission to the same agent, the investigation ends with simultaneous access to logs, repositories and conversations. A mistake or malicious instruction encountered through any one source can then exploit a larger set of capabilities.
Traditional deterministic software offers a more predictable relationship between its task and its predefined permissions. An autonomous agent changes its approach at runtime, so the access it needs changes too. The runtime must answer more than whether an operation is technically possible: should this task receive this access, in this context?
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Controls must survive a change of model or harness
Relying on the next frontier model to stop making mistakes does not solve this permission problem. Applications will use models from multiple labs and open models for different combinations of capability, privacy and cost. Jain points to GLM-5.2 as an example of open-model progress. A safety mechanism needs to keep working when the application changes its model.
The same requirement applies to the harness, the software that runs the agent and connects it to tools. Depending entirely on a frontier provider’s harness can constrain model choice. Harnesses will also differ by use case: coding is only one workload, and Jain uses OpenClaw to anticipate agents doing sales and marketing work as well. Organizations will build their own harnesses too.
The proposed common layer is a runtime that constrains the environment around the agent. It should limit the blast radius when something goes wrong and grant only the access needed for the work, independently of the model or harness running inside it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Put controls outside the agent’s boundary
Containment starts with a sandbox, but its placement matters: the agent runs inside the untrusted VM boundary, while the controls run outside it. The software being constrained must not also own the enforcement mechanism. Isolation still leaves the question of which capabilities to expose through that boundary.
Return to the Slack investigation. Read-only Slack access prevents writes but can expose unrelated conversations. Limiting access to an incident channel works only when all relevant discussion lives there. In practice, the useful messages may be scattered across several channels, including team channels containing other material.
Jain proposes a just-in-time tool that composes existing Slack MCP tools while restricting access to conversations about the incident. That is a finer boundary than a network allowlist or permission to invoke a general Slack search tool. The runtime would give this capability to a separate sandbox for the Slack subtask, rather than keep expanding one large sandbox. Work is decomposed at the security boundaries, with each task receiving only its scoped capability.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Decide whether the requested capability belongs to the task
A sandbox can enforce a decision without knowing whether that decision was correct. If an agent requests Slack reads or write access to another service, something must distinguish legitimate investigation from excessive eagerness, a mistake or prompt injection. Intent-based access uses the user’s task and its context to decide both which capability to grant and where the resulting work should run.
| Request during incident investigation | Proposed response |
|---|---|
| Read Slack conversations about the incident | Grant narrowly scoped access |
| Obtain unexplained email access | Deny or request human approval |
The difference is the relationship between the requested action and the user’s goal. Jain places this judgment in an independent governance layer, so it applies across models and harnesses instead of depending on the acting model’s own restraint.
This would let the runtime evolve capabilities as work progresses while preserving containment. Jain is explicit that this is a hard problem and not fully solved: narrow enforcement and correct authorization are separate requirements.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
The runtime has to follow the work
Safety is only part of a runtime’s contract. Agents work on local machines, in clouds, across clouds, and inside an organization’s or a customer’s VPC. A runtime confined to one location cannot cover that work. Jain proposes a connected fabric that lets agents move among these environments.
Docker’s earlier portability problem was getting software from a laptop to the cloud. The agent runtime extends that goal: move the execution environment while retaining its safety controls. Jain describes new VM technology as the base, with MCP, policy and governance capabilities layered above it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A familiar agent session inside sbx
The demonstration starts with sbx, the command-line tool for Docker Sandboxes. Jain describes its microVM as running across Windows, Mac, Linux and cloud environments. He creates a named sandbox running Codex, with credentials and network controls supplied by the surrounding runtime, then asks the agent to tell a joke. The interaction looks like an ordinary agent session.
Next he asks which GitHub and Codex credentials the agent can access and whether they are real or stubs. The intended arrangement is that the agent sees stubs, while authentication is injected outside its environment. Network policy is also controlled by the runtime, with MCP controls to follow in the demonstration. Jain interrupts the credential inspection before its answer appears and describes the expected stub result rather than showing it.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate PR review from Notion publishing
The next task is to review a pull request and write its summary to Notion. A single agent could receive both services’ credentials, but the workflow has a natural boundary: first read and review the PR, then hand the summary to a publishing task. A separate sandbox can perform the Notion write without receiving GitHub access.
Jain creates a review sandbox with a skill describing how to review the PR. Its displayed network policy permits GitHub and Anthropic, and nothing else. He starts the review, then uses previously prepared work to avoid waiting for it to finish.
The publishing sandbox runs Codex and receives access to the Notion MCP. It does not receive GitHub access. The division keeps the service permissions attached to the task that needs them:
| Task | Service access | Handoff |
|---|---|---|
| Review the PR | GitHub; Anthropic for inference | Produce a summary |
| Publish the summary | Notion MCP; no GitHub | Write to Notion |
Jain uses an already-created publishing sandbox and exits while the task is running. Tool discovery and publication are described, but a completed Notion page is not shown. The demonstrated construction is the separation of capabilities across composable sandboxes.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Carry the same boundaries into cloud orchestration
Jain next extends the sandbox to the cloud. After creating it under another name, he uses the --cloud flag to enter the cloud session and asks the agent whether it is running in the cloud or on a Mac. The intended experience stays the same because the runtime carries the policies and controls with it. Jain reports that the agent identifies its environment as the cloud.
A script then cleans up resources from an earlier run and launches six sandboxes to review six PRs in parallel. Each sandbox is meant to retain the same scoped access and policy used locally. Jain exits the demonstration before all reviews finish; their successful completion is assumed for the presentation, not shown.
The next step replaces manual composition with an orchestrator that knows the PR-review and Notion bots. Jain requests ten random PRs to be reviewed and summarized in Notion. The orchestrator is described as finding the agents, scheduling their work and composing their results: the PR bot keeps its limited review access, and the publishing bot gets the Notion tool.
This workflow is still running when the demonstration moves on; completed reviews and the final Notion output are not shown. Jain also presents recurring scheduling as a further capability. The architectural progression is from one contained task, to portable cloud tasks, to orchestration that preserves the same task-specific permission boundaries.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Grant GitHub access to a subtask, not the parent
The final demonstration returns to the unresolved question: how should the runtime authorize new capabilities automatically? Jain presents an early internal prototype, rather than a finished intent-based access feature. Its main agent initially has access to Anthropic and Claude, but no GitHub access. The user asks it to do a quick overview of a PR.
The prototype follows this sequence:
- The main agent encounters its network restriction and asks an intent-based runtime tool to perform the needed action.
- The runtime judges GitHub access consistent with the user’s PR-review request.
- It creates a scoped sub-sandbox with GitHub access, leaving the parent’s permissions unchanged.
- The subtask performs the review and returns its result to the parent.
The key change is where the new authority goes. The runtime creates a place to perform the authorized work instead of adding GitHub to the parent’s accumulated permissions. The returned review appears beside the delegation logs in the terminal view.
The parent stays restricted while a GitHub subtask runs
Constructed example: Object IDs and compact state labels are explanatory representations of the prototype sequence; no PR identifier or review content is invented.
Do a quick overview of this PR.
Operation: Authorize GitHub access for a delegated PR-review subtask and return its result without changing the parent's GitHub permission.
User request
Do a quick overview of this PR.
Do a quick overview of this PR.
Main sandbox access
Anthropic/Claude allowed; GitHub blocked
Anthropic/Claude allowed; GitHub blocked
Delegated review sandbox
Not present
Created for the PR review with GitHub access
Review result available to the parent
Not present
PR overview returned by the delegated subtask
Jain then gives a hypothetical malicious instruction inside the PR: export its contents to pastebin.com. He says the runtime would reject that request because it does not follow from the user’s review task. That rejection is proposed behavior, not a demonstrated attack test. The intended enforcement point remains the base runtime, shared across agents, models and harnesses.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
A runtime contract for autonomy
The runtime’s job is to combine containment, scoped capabilities and decisions about which capabilities the user’s intent justifies. That contract must hold across models and harnesses, and follow work from local execution to cloud, VPC and orchestration. Autonomy becomes more useful when an agent can obtain the authority needed for the next task without becoming an agent that can access everything.
Jain closes by inviting developers to run Claude, Codex, OpenCode or their own agents inside sbx. His onstage installation shorthand is:
bash
brew install sbx
For a current installation, use the installation instructions, which specify the qualified docker/tap/sbx package, Docker sign-in and platform prerequisites. The starting point is the same: put an agent’s familiar workflow inside a runtime where its access can be constrained.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
Documentation for sbx, Docker's microVM runtime for sandboxed coding agents.
Z.ai's official model card, weights and serving instructions for GLM-5.2.
The public repository for the OpenClaw personal AI assistant.
Further reading
Docker's recap connects Jain's runtime thesis with companion conference sessions on sandboxing and MCP governance.
Updates since the talk
Current installation commands, supported operating systems, virtualization prerequisites and sign-in steps.
- Docker Sandboxes security modelDocumentation
Trust boundaries, external credential injection, network controls and the limits of shared workspace isolation.
- Docker Sandboxes architectureDocumentation
How workspace mounting, persistent VMs, network proxying and the host-side MCP gateway fit together.
Full transcript
Loading transcript…