AI Engineer World's Fair 2026

Unlock Agent Autonomy: The Runtime for AI-Native Systems

Tushar Jain· EVP of Engineering, Docker22:50

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.

Slide titled “My agent posted this. I didn't ask it to.” beside a comment headed “Daily Digest Complete.”Open full source frame
An agent posts a repository digest without being asked.

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.

1:131:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

1:13 · section reference included

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?

Slide reading “Old security assumptions break down with agents,” with crossed-out “can it” pointing to highlighted “should it.”Open full source frame
Agent security shifts from “can it” to “should it.”
2:302:40
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:30 · section reference included

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.

4:134:25
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:13 · section reference included

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.

6:146:30
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:14 · section reference included

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 investigationProposed response
Read Slack conversations about the incidentGrant narrowly scoped access
Obtain unexplained email accessDeny 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.

8:048:13
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:04 · section reference included

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.

9:5410:05
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:54 · section reference included

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.

11:5712:09
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:57 · section reference included

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:

TaskService accessHandoff
Review the PRGitHub; Anthropic for inferenceProduce a summary
Publish the summaryNotion MCP; no GitHubWrite 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.

13:2713:35
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

13:27 · section reference included

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.

15:5716:08
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:57 · section reference included

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:

  1. The main agent encounters its network restriction and asks an intent-based runtime tool to perform the needed action.
  2. The runtime judges GitHub access consistent with the user’s PR-review request.
  3. It creates a scoped sub-sandbox with GitHub access, leaving the parent’s permissions unchanged.
  4. 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.

User request — unchanged
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

Before: Before delegation
Do a quick overview of this PR.
After: After the review returns · Unchanged
Do a quick overview of this PR.

Main sandbox access

Before: Before delegation
Anthropic/Claude allowed; GitHub blocked
After: After the review returns · Unchanged
Anthropic/Claude allowed; GitHub blocked

Delegated review sandbox

Before: Before delegation
Not present
After: After the review returns · Added
Created for the PR review with GitHub access

Review result available to the parent

Before: Before delegation
Not present
After: After the review returns · Added
PR overview returned by the delegated subtask
The task gains a scoped execution environment; the parent does not gain GitHub access.
Split terminal view with a completed review response on the left and delegation log entries on the right.Open full source frame
A review response appears beside delegation logs.

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.

19:3519:50
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

19:35 · section reference included

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.

21:3821:51
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

21:38 · section reference included

Resources

From the talk

Updates since the talk

Transcript download
Full transcript

Loading transcript…