En sandlåda för AI-agenter

A sandbox for AI agents

En kodagent gör som mest nytta när den får jobba självständigt: köra kommandon, installera paket, köra tester och pröva sig fram på egen hand. Men att släppa den lös på sin egen dator är ett snabbt sätt att ångra sig. Lösningen: ge agenten en egen dator.

The fastest way to make a coding agent useful is to give it autonomy: let it run commands, install packages, execute tests, iterate. The fastest way to regret it is to give it that autonomy on your own machine. So: give the agent a machine of its own.

Jag har byggt ett litet proof of concept som gör precis det — en Docker-sandlåda utvecklad för Claude Code, där agenten jobbar i en isolerad engångsmiljö med sina verktyg förinstallerade (PoC-imagen innehåller .NET, Azure CLI, Playwright, Node, Python och Go). Det här inlägget beskriver mönstret som det ser ut i PoC:n; den sandlåda jag faktiskt kör idag skiljer sig på några punkter, och jag pekar ut dem längs vägen. Upplägget vilar på tre idéer.

I've built a small proof of concept that does exactly that — a Docker sandbox developed for Claude Code, where the agent works in a disposable, isolated environment with its tools pre-installed (the PoC image ships .NET, Azure CLI, Playwright, Node, Python and Go). This post describes the pattern as the PoC lays it out; the sandbox I actually run today differs in a few places, and I'll point them out along the way. Three ideas carry the whole thing.

Isolering som standard

Isolation by default

Agenten jobbar inte på min dator, utan i en egen isolerad miljö med mitt projekt monterat. Allt den gör stannar i lådan. När uppgiften är klar slängs hela miljön med ett kommando — och har den ställt till något på vägen försvinner det med den.

The agent doesn't work on my computer; it works in an isolated environment of its own with my project mounted into it. Everything it does stays inside the box. When the task is done, one command throws the whole environment away — and whatever mess was made goes with it.

Nätverket är deny-all

The network is deny-all

Inifrån sandlådan finns nästan inget internet. All utgående trafik går genom en proxy där grundregeln är att blockera allt — bara en kort lista med undantag släpps igenom: GitHub, paketkällorna vi använder, Azure DevOps. Hur hårt man drar åt går att välja: PoC:n går så långt att npm-registret är stängt under körning och paketen bakas in i imagen redan när den byggs, så att agenten inte kan luras att hämta hem och köra godtycklig kod; sandlådan jag kör idag släpper i stället igenom de paketkällor vi litar på. Och skulle en promptinjektion någon gång få agenten att försöka läcka något, finns det väldigt få ställen att skicka det till.

From inside the sandbox, the internet mostly doesn't exist. Outbound traffic passes through a proxy with a deny-all policy and a short allowlist: GitHub, the package feeds we rely on, Azure DevOps. Everything else is blocked. How tightly you turn that dial is a choice: the PoC goes as far as shutting off the npm registry at runtime and baking the packages into the image at build time, so the agent can't be tricked into pulling down and running arbitrary code; the sandbox I run today keeps the registries we trust on the allowlist instead. And if a prompt injection ever talks the agent into leaking something, there are very few places left to send it.

Nycklarna sitter i proxyn

The keys live in the proxy

Så här ser mönstret ut i sin idealform, och så gör PoC:n: agenten får aldrig några inloggningsuppgifter. I stället injicerar en liten reverse proxy i sandlådan rätt Authorization-header mot rätt tjänst — en GitHub-token mot GitHubs API, en Azure DevOps-PAT mot Azure DevOps. Reglerna ligger i en vanlig JSON-fil, så en ny tjänst är en konfigurationsändring snarare än ny kod. Och eftersom proxyn sköter autentiseringen fungerar kortlivade SSO-tokens precis lika bra som långlivade personliga access tokens. Sandlådan jag kör idag tar en enklare väg — en token med snäva behörigheter — men målet är detsamma: agenten ska inte hålla i fler nycklar än uppgiften kräver.

This is the pattern's ideal, and how the PoC does it: the agent is never configured with credentials. A small reverse proxy inside the sandbox injects the right Authorization header for the right host — a GitHub token for the GitHub API, an Azure DevOps PAT for Azure DevOps. The rules are plain JSON, so adding a service is configuration rather than code, and short-lived SSO tokens work just as well as long-lived personal access tokens. The sandbox I run today takes a simpler route — a narrowly scoped token — but the goal is the same: the agent shouldn't hold more keys than the task needs.

Skyddsräckena hör hemma i miljön — inte i användarens vaksamhet.

Put the guardrails in the environment, not in the operator's vigilance.

Vad det här gör möjligt

What it allows

Fria tyglar utan blind tillit. Agenten kan köras i det läge där den faktiskt är produktiv — utan bekräftelsefråga före varje kommando — eftersom det värsta som kan hända drabbar en miljö som ändå ska slängas, inte din dator.

Full autonomy without full trust. The agent can run in the mode where it's actually productive — no confirmation prompt before every command — because the blast radius is a disposable, isolated environment with a closed network, not your laptop.

Arbete mot privat kod och interna system. Proxyupplägget gör att agenten kan jobba mot privata repon och Azure DevOps utan att någon behöver klistra in tokens i agentens konfiguration.

Work against private code and internal systems. The proxy pattern lets the agent talk to private repositories and Azure DevOps without anyone pasting tokens into its configuration.

Miljöer som vem som helst kan starta. Ett enda skript bygger imagen, startar sandlådan, slår på nätverksreglerna och drar igång proxyn. Det är den delen jag bryr mig mest om: när skyddsräckena sitter i miljön i stället för hos användaren blir det plötsligt rimligt att låta fler i en organisation köra agenter.

Environments anyone can start. One script builds the image, starts the sandbox, applies the network policy and launches the proxy. That's the part I care most about: when the guardrails live in the environment instead of in the operator's vigilance, letting more people in an organisation run agents stops being reckless.

Vart det här är på väg

Where this is heading

Det här är ett proof of concept utvecklat för Claude Code — men inget i mönstret är knutet till just den agenten. Samma recept fungerar för vilken agent som helst som går att köra i en terminal: isolera, filtrera, injicera. I kommande inlägg tänker jag gräva djupare i de enskilda delarna.

Uppföljarna finns nu på plats: del 1 om isolering, del 2 om nätverket och del 3 om nycklarna.

This is a proof of concept developed for Claude Code — but nothing in the pattern is specific to that agent. The same recipe works for any agent you can run in a terminal: isolate, allowlist, inject. In future posts I'll dig into the individual pieces.

The follow-ups are now up: part 1 on isolation, part 2 on the network and part 3 on the keys.