AI Engineer World's Fair 2026

How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker

Jim Clark· Docker18:13

Loading slides…

Read the talk

How Many Credentials Should Your AI Agent Have? Zero.

Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 62 secondsOpen full source frame
Jim Clark introduces MCP gateways, sandboxes, and harnesses as a way to discuss AI safety.

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.

0:131:12

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.

Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 249 secondsOpen full source frame
A slide asks what information and tools a task needs, and what the agent can actually call.

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.

2:383:09

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.

Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 499 secondsOpen full source frame
A diagram shows a newsroom workflow split across researcher, fact-checker, and publishing sandboxes.

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

Open webBroad external information available to the researcher.
Researcher sandboxResearch — Web access and private local output; no corporate publishing MCP.
Fact-checker sandboxCheck — Reads research and uses the fact database; no general network access.
Fact databaseCheck — Reference information available to the checking stage.
Publishing sandboxPublish — Filtered research plus Notion MCP or Publisher MCP; no open-web browsing.
The open-web stage produces local research. A separate stage checks it before the publishing-capable stage receives it.
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.
5:516:21

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.

8:218:51

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.

Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 655 secondsOpen full source frame
A diagram shows MCP traffic from a sandbox passing through one gateway to connected services.

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.

9:5110:21

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.

Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 815 secondsOpen full source frame
A diagram labels the Cross App Access flow between an agent, an identity provider, and resource servers.

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

Harness, sandbox and gatewayIdentify the agent and the user it acts on behalf of.
Existing identity providerReceives identity claims and returns an authorization grant.
ID-JAGAuthorization grant for the agent actor.
Existing authorization serversSupport access to the enterprise services already in use.
The conceptual XAA flow reuses the company's identity provider and authorization servers.
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.
12:2012:50

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.
Selected presentation frame from How Many Credentials Should Your AI Agent Have? Zero. — Jim Clark, Docker at 944 secondsOpen full source frame
A diagram shows an orchestrator configuring a sandbox with selected capabilities.

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.

14:2314:53

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.

Transcript download
Full transcript

Loading transcript…