AI Engineer World's Fair 2026
How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker
Loading slides…
Read the talk
How Many Credentials Should Your AI Agent Have? Zero.
Jim Clark explains how task-specific sandboxes, a shared MCP gateway and existing enterprise identity systems can let agents work longer while limiting what each stage can reach.
From a talk by Jim Clark
At a glance
Ideas worth remembering
Design each sandbox around the current task's information and tools. The complete workflow can have more capabilities than any individual stage.
Separate open-web research from publishing power, and separate ordinary coding from credential-backed signing operations.
A single MCP gateway endpoint centralizes capability configuration and makes the harness easier to replace.
Zero credentials in the agent's sandbox is the design goal; XAA provides a described route from agent identity to existing enterprise authorization.
Orchestrators should choose the harness, MCP capabilities, network rules and working resources for each task, rather than expose the entire workflow's tool collection.
Longer runs change what supervision can do
An agent that works for an hour changes the safety problem. Sitting at a laptop approving every action defeats much of the value of handing it a substantial task. Jim Clark, principal software engineer at Docker, starts from that tension: needing little supervision is a sign that a task is well designed, but leaving an agent alone also raises the question of what it might do.
MCP gateways enter the discussion as a way to control that exposure. The explanation separates three things that often travel together: the harness that runs the agent, the tools and context it receives through MCP, and the sandbox where it performs work. The useful safety question is what that particular task needs access to while it runs.
The harness runs the loop; its capabilities determine the reach
At the level needed for this discussion, a harness takes context and produces tool calls. That is a simplification, but it helps explain why replacing one harness with another should be routine. Harnesses evolve quickly, and their interaction styles make them worth switching. Without information or tools, however, the loop has little useful work to do.
MCP supplies ways to bring in context and invoke tools. Those additions make the agent useful, and they also determine what an incorrect action can affect. Before building the environment, ask two practical questions: what information does this task require, and what tools must it use? Giving it only those resources limits the blast radius of a mistake.
A sandbox is the place where the agent works. Early coding-agent setups might effectively expose an entire laptop: the repository, local tools and everything else available there. A smaller sandbox narrows that environment to the task. Clark's emphasis is on controlling the tools and context flowing into the harness; the simplicity of the harness loop alone does not establish that those inputs and capabilities are safe.
A newsroom separates open research from publishing
The newsroom example develops that separation into a complete workflow. Research goes out into the world, fact-checking examines what comes back, and a final stage writes or publishes the story. The workflow needs all of those abilities, but each role receives a different environment.
- Researcher: Broad web access lets it gather information. It lacks the MCP tools that could publish to the corporate site, and writes its findings to private local storage, such as a temporary directory.
- Fact-checker: A separate sandbox reads those findings and checks them against a fact database through its allowed MCP capabilities. The example gives it no general network access.
- Publishing stage: A final sandbox receives filtered research and a Notion MCP or Publisher MCP. It has no need to browse the open web.
Follow the research through those handoffs. First, material collected from the internet becomes a local research artifact. Next, the fact-checker reads and filters it using the fact database. Only then does the publishing stage receive the filtered material together with a publishing tool. The observable change is in both the input and the available action: the stage that sees arbitrary web content cannot publish, while the stage that can publish receives the output of the checking step.
Where do information and publishing power meet? The diagram traces the handoffs rather than treating the whole newsroom as one agent with one tool list. Across the workflow, internet access, fact-checking and publishing all exist. Inside any individual stage, the intended combination is narrower. This is a separation design, not a guarantee that filtered research is harmless: its protection still depends on what the checking step passes onward.
Research moves forward; capabilities stay with their roles
Read the diagram as text
- Open web. Broad external information available to the researcher.
- Researcher sandbox. Research — Web access and private local output; no corporate publishing MCP.
- Fact-checker sandbox. Check — Reads research and uses the fact database; no general network access.
- Fact database. Check — Reference information available to the checking stage.
- Publishing sandbox. Publish — Filtered research plus Notion MCP or Publisher MCP; no open-web browsing.
- Open web → Researcher sandbox: Gather information.
- Researcher sandbox → Fact-checker sandbox: Local research artifact.
- Fact database → Fact-checker sandbox: Check findings.
- Fact-checker sandbox → Publishing sandbox: Filtered research.
An hour of coding does not require an hour of signing access
The second example applies the same reasoning to time rather than organizational roles. Clark describes sending a coding agent on long tasks and wanting it to commit along the way. In his illustrative hour-long run, Git signing might be needed for only two minutes. Leaving signing keys available throughout the hour would give the coding phase a capability it rarely needs.
Making a commit calls for a much smaller set of resources: the Git commit tree, the ability to create the commit and signing access. Other capabilities can be left out of that stage. Conversely, a task that is not making a commit should not have signing keys in its sandbox. The task's intent becomes a specification for its capabilities: coding and signing are different operations even when they belong to one larger job.
One MCP endpoint makes policy independent of the harness
Docker's gateway design puts a harness and a single MCP gateway endpoint into the sandbox. Resources and tool calls pass through that endpoint. Clark sketches an internal hostname to convey the arrangement; the important property is that the harness has one route for MCP traffic.
The gateway provides a control point for which tools, resources and prompts each sandbox receives. Sandbox configuration determines the allowed capabilities, while the harness connects to the common endpoint. That separates two decisions that otherwise get tangled together: which agent interface to run, and which MCP capabilities the task may use.
The practical benefit is less per-harness configuration. Switching between Codex and Claude Code need not mean rebuilding the same MCP setup in each one's format. The harness becomes a parameter of the sandbox alongside its MCP selection and network rules. As Clark puts it, “Bob's your uncle.” The simplicity comes from moving the shared configuration to one control point.
Credential handling belongs at that control point too. The headline's answer—zero credentials in the sandbox—is Clark's design maxim. Read together with the signing example, it distinguishes needing a credential-backed operation from keeping the credential available to the agent. Removing credentials reduces what a mistaken agent can expose, although permitted tools can still perform consequential actions.
Cross App Access connects agent identity to existing SSO
Cross App Access (XAA) extends the credential discussion to enterprise services. Clark describes Docker, Anthropic and Okta partnering on this approach. Companies already have identity providers, SSO and OAuth-backed services such as Notion, Atlassian, GitHub and Slack. The missing connection is allowing an agent to act through that existing identity setup.
The described exchange starts by identifying the agent and the person on whose behalf it acts. Identity claims are exchanged with the existing identity provider, which returns an authorization grant called an ID-JAG. That grant supports access through the authorization servers the company already uses. This is the conceptual flow presented in the talk; it does not specify token storage, lifetimes or the complete exchange protocol.
How does existing SSO become useful to an agent? The diagram makes the identity provider an explicit participant between the agent's identity and service authorization. The intended administrative benefit is centralized control over what agents may do with existing resource servers, instead of repeatedly asking users to approve separate consent screens.
Agent identity feeds existing service authorization
Read the diagram as text
- Harness, sandbox and gateway. Identify the agent and the user it acts on behalf of.
- Existing identity provider. Receives identity claims and returns an authorization grant.
- ID-JAG. Authorization grant for the agent actor.
- Existing authorization servers. Support access to the enterprise services already in use.
- Harness, sandbox and gateway → Existing identity provider: Exchange identity claims.
- Existing identity provider → ID-JAG: Return authorization grant.
- ID-JAG → Existing authorization servers: Authorize the agent actor.
The orchestrator builds an environment for each task
Progressive disclosure applies to capabilities as well as instructions. A workflow might use fifty different MCPs over its lifetime; that does not mean every sandbox needs all fifty. Exposing only the tools and resources needed at the current stage also keeps the agent's context smaller. The aim is to leave room for problem-solving inside an environment that expresses the task's intent.
That gives the orchestrator a concrete job: inspect the task, decide what it needs and construct the sandbox before assigning the work. Its choices include several separate dimensions:
- Harness: Select the agent implementation that will run the task.
- MCP capabilities: Select the tools and resources that this stage may use.
- Network rules: Decide whether it needs a specific service such as
api.github.com, broad web browsing or no general network access. - Working resources: Provide the relevant files and worktrees.
The resulting loop has less access than the workflow as a whole. Role separation supplies the organization; containers supply separate places to work; progressive disclosure supplies capabilities as they become necessary. The sandbox is where those decisions become the environment the agent actually receives.
The closing practical step is the sbx CLI. Clark presents brew install sbx as the way to try the tool discussed in the recording and points to further demonstrations of cloud sandboxes and orchestrators. For implementation, the supplied Docker Sandboxes documentation covers local and Docker-managed cloud environments, including MCP configuration and security topics. The CLI reference provides the command reference for creating and managing those environments.
Resources
From the talk
Start with local or cloud sandbox setup, then explore the documented MCP, architecture and security topics relevant to task-specific agent environments.
Command reference for the sandbox CLI offered as the practical next step at the end of the talk.
Full transcript
Loading transcript…