AI-agents krijgen hun eigen computers met Sandboxes
Bij de ontwikkeling en introductie van Cloudflare Sandboxes was het uitgangspunt eenvoudig: AI-agenten moeten code kunnen ontwikkelen en uitvoeren binnen een veilige omgeving. Als een agent zich gedraagt als een ontwikkelaar, gaat deze repositories klonen, code compileren in verschillende programmeertalen, ontwikkelservers draaien, enzovoort. Om dit effectief te kunnen doen, hebben ze vaak een volwaardige computer nodig, of een ander lichtgewicht systeem.
Uitdagingen virtuele machines en containers
Veel ontwikkelaars werken momenteel met virtuele machines of bestaande containeroplossingen, maar er zijn daarbij nog lastige uitdagingen op te lossen:
● Variëteit – Omdat elke sessie een eigen sandbox nodig heeft, moet je vaak snel veel sandboxes opstarten, maar je wilt niet betalen voor inactieve stand-by rekenkracht.
● Snel herstel van de status – Elke sessie moet snel starten en snel herstarten, waarbij de vorige status wordt hervat.
● Beveiliging – Agenten moeten op een veilige manier toegang hebben tot services, maar mogen niet worden vertrouwd met hun inloggegevens.
● Controle – Het moet eenvoudig zijn om de levenscyclus van de sandbox programmatisch te beheren, commando’s uit te voeren, bestanden te verwerken en meer.
● Ergonomie – Je moet een eenvoudige interface bieden waarmee zowel mensen als agenten gangbare handelingen kunnen uitvoeren.
Cloudflare heeft veel tijd besteed aan het oplossen van deze problemen, zodat haar klanten dat niet hoeven te doen. Sinds de eerste lancering is Sandboxes een nog betere oplossing gemaakt om agents op grote schaal uit te voeren. Daarbij hebben ze samengewerkt met partners als Figma, die agents in containers uitvoeren met Figma Make.
Toegevoegde functionaliteit
De Sandboxes en Cloudflare Containers zijn inmiddels algemeen beschikbaar, met onder andere onderstaande toegevoegde functionaliteit in Sandboxes:
● Met Secure Credential Injection kunnen geauthenticeerde gesprekken worden gevoerd zonder dat de agent ooit toegang heeft tot de inloggegevens.
● Met PTY-ondersteuning beschikken de gebruiker en agent over een echte terminal.
● Dankzij persistente code-interpreters kan een agent direct stateful Python-, JavaScript- en TypeScript-code uitvoeren.
● Achtergrondprocessen en live preview-URL’s bieden een eenvoudige manier om met ontwikkelservers te communiceren en lopende wijzigingen te controleren.
● Het bewaken van het bestandssysteem verbetert de iteratiesnelheid wanneer agents wijzigingen aanbrengen.
● Met snapshots is snel de codeersessie van een agent te herstellen.
● Hogere limieten en Active CPU Pricing stellen organisaties in staat om een groot aantal agents op grote schaal in te zetten zonder te betalen voor ongebruikte CPU-cycli.
Sandboxen 101
Een Cloudflare Sandbox is een permanente, geïsoleerde omgeving die draait op Cloudflare Containers. Je vraagt een sandbox aan op naam. Als deze actief is, krijg je hem. Zo niet, dan start hij. Als de sandbox inactief is, gaat hij automatisch in slaapstand en wordt hij weer actief zodra er een verzoek binnenkomt. Je kunt eenvoudig programmatisch met de sandbox communiceren met behulp van methoden zoals `exec` , `gitClone` , `writeFile` en meer.
import { getSandbox } from “@cloudflare/sandbox”;
export { Sandbox } from “@cloudflare/sandbox”;
export default {
async fetch(request: Request, env: Env) {
// Ask for a sandbox by name. It starts on demand.
const sandbox = getSandbox(env.Sandbox, “agent-session-47”);
// Clone a repository into it.
await sandbox.gitCheckout(“https://github.com/org/repo”, {
targetDir: “/workspace”,
depth: 1,
});
// Run the test suite. Stream output back in real time.
return sandbox.exec(“npm”, [“test”], { stream: true });
},
};
Zolang je dezelfde ID opgeeft, kunnen volgende verzoeken vanuit elke locatie ter wereld toegang krijgen tot dezelfde sandbox .
Beveiligde referentie-injectie
Een van de grootste uitdagingen bij agentgebaseerde workloads is de authenticatie. Er zijn vaak agents nodig om toegang te krijgen tot privéservices, maar je kunt ze niet volledig vertrouwen met onbewerkte inloggegevens.
Sandboxes lossen dit op door inloggegevens op netwerkniveau te injecteren met behulp van een programmeerbare uitgaande proxy. Dit betekent dat sandbox-agents nooit toegang hebben tot inloggegevens en dat je de authenticatielogica volledig naar eigen inzicht kunt aanpassen.
class OpenCodeInABox extends Sandbox {
static outboundByHost = {
“my-internal-vcs.dev”: (request, env, ctx) => {
const headersWithAuth = new Headers(request.headers);
headersWithAuth.set(“x-auth-token”, env.SECRET);
return fetch(request, { headers: headersWithAuth });
}
}}
Voor een diepgaande uitleg over hoe dit werkt – inclusief identiteitsbewuste credentialinjectie, dynamisch wijzigende regels en integratie met Workers-bindings – lees de aparte blog over Sandbox-authenticatie.
Echte terminal, geen simulatie
Vroege agentsystemen modelleerden shelltoegang vaak als een verzoek-antwoordcyclus: voer een commando uit, wacht op de uitvoer, plaats het transcript terug in de prompt en herhaal dit. Deze aanpak werkt, maar zo gebruiken ontwikkelaars een terminal in de praktijk niet.
Mensen starten iets, bekijken de output, onderbreken het proces, maken later weer verbinding en gaan verder. Agents profiteren van diezelfde feedbacklus. In februari is PTY-support uitgebracht. Een pseudo-terminalsessie in een sandbox, geproxyd via WebSocket, compatibel met xterm.js.
Roep gewoon sandbox.terminal aan om de backend te starten:
// Worker: upgrade a WebSocket connection into a live terminal session
export default {
async fetch(request: Request, env: Env) {
const url = new URL(request.url);
if (url.pathname === “/terminal”) {
const sandbox = getSandbox(env.Sandbox, “my-session”);
return sandbox.terminal(request, { cols: 80, rows: 24 });
}
return new Response(“Not found”, { status: 404 });
},
};
And use xterm addon to call it from the client:
// Browser: connect xterm.js to the sandbox shell
import { Terminal } from “xterm”;
import { SandboxAddon } from “@cloudflare/sandbox/xterm”;
const term = new Terminal();
const addon = new SandboxAddon({
getWebSocketUrl: ({ origin }) => `${origin}/terminal`,
});
term.loadAddon(addon);
term.open(document.getElementById(“terminal-container”)!);
addon.connect({ sandboxId: “my-session” });
Dit stelt agenten en ontwikkelaars in staat om een volledige PTY te gebruiken om hun sessies live te debuggen.
Elke terminalsessie krijgt een eigen, geïsoleerde shell, een eigen werkmap en een eigen omgeving. Open er zoveel als je nodig hebt, net zoals op je eigen computer. De uitvoer wordt aan de serverzijde gebufferd, dus als je opnieuw verbinding maakt, kun je alles wat je hebt gemist opnieuw afspelen.
Een code-interpreter die het onthoudt
Voor data-analyse, scripting en verkennende workflows leveren we ook een abstractielaag op een hoger niveau: een persistente code-uitvoeringscontext.
Het sleutelwoord is ‘persistent’. Veel implementaties van code-interpreters voeren elk codefragment afzonderlijk uit, waardoor de status tussen de aanroepen verdwijnt. Je kunt een variabele niet in de ene stap instellen en in de volgende stap uitlezen.
Met sandboxes kun je ‘contexten’ creëren die de status behouden. Variabelen en imports blijven behouden tussen aanroepen, net zoals in een Jupyter-notebook.
// Create a Python context. State persists for its lifetime.
const ctx = await sandbox.createCodeContext({ language: “python” });
// First execution: load data
await sandbox.runCode(`
import pandas as pd
df = pd.read_csv(‘/workspace/sales.csv’)
df[‘margin’] = (df[‘revenue’] – df[‘cost’]) / df[‘revenue’]
`, { context: ctx });
// Second execution: df is still there
const result = await sandbox.runCode(`
df.groupby(‘region’)[‘margin’].mean().sort_values(ascending=False)
`, { context: ctx, onStdout: (line) => console.log(line.text) });
// result contains matplotlib charts, structured json output, and Pandas tables in HTML
Start een server. Verkrijg een URL. Verstuur het.
Agenten zijn nuttiger wanneer ze iets kunnen bouwen en dat direct aan de gebruiker kunnen laten zien. Sandboxes ondersteunen achtergrondprocessen, gereedheidscontroles en preview-URL’s . Hierdoor kan een agent een ontwikkelserver starten en een live link delen zonder het gesprek te verlaten.
// Start a dev server as a background process
const server = await sandbox.startProcess(“npm run dev”, {
cwd: “/workspace”,
});
// Wait until the server is actually ready — don’t just sleep and hope
await server.waitForLog(/Local:.*localhost:(d+)/);
// Expose the running service with a public URL
const { url } = await sandbox.exposePort(3000);
// url is a live public URL the agent can share with the user
console.log(`Preview: ${url}`);
Met waitForPort () en waitForLog() kunnen agents taken sequentiëren op basis van echte signalen van het draaiende programma in plaats van te gokken. Dit is veel beter dan een veelgebruikt alternatief, dat meestal een variant is van sleep(2000) gevolgd door hopen.
Houd het bestandssysteem in de gaten en reageer direct
Moderne ontwikkelprocessen zijn ‘gebeurtenis-gestuurd’: sla een bestand op, voer de build opnieuw uit. Bewerk een configuratie, herstart de server. Wijzig een test, voer de testsuite opnieuw uit.
Cloudflare heeft sandbox.watch() in maart uitgebracht. Het retourneert een SSE-stream die wordt ondersteund door native inotify, het kernelmechanisme dat Linux gebruikt voor gebeurtenissen van het bestandssysteem.
import { parseSSEStream, type FileWatchSSEEvent } from ‘@cloudflare/sandbox’;
const stream = await sandbox.watch(‘/workspace/src’, {
recursive: true,
include: [‘*.ts’, ‘*.tsx’]
});
for await (const event of parseSSEStream<FileWatchSSEEvent>(stream)) {
if (event.type === ‘modify’ && event.path.endsWith(‘.ts’)) {
await sandbox.exec(‘npx tsc –noEmit’, { cwd: ‘/workspace’ });
}
}
Dit is een van die primitieve elementen die op subtiele wijze de mogelijkheden van agents verandert. Een agent die het bestandssysteem in realtime kan observeren, kan deelnemen aan dezelfde feedbackloops als een menselijke ontwikkelaar.
Snel wakker worden met snapshots
Stel je een (menselijke) ontwikkelaar voor die op zijn laptop werkt. Hij kloont een repository met `git clone` , voert `npm install` uit , schrijft code, dient een pull request in en sluit vervolgens zijn laptop in afwachting van de code review. Wanneer het tijd is om verder te werken, opent hij gewoon de laptop weer en gaat verder waar hij gebleven was.
Als een agent deze workflow wil repliceren op een eenvoudig containerplatform, loopt hij tegen een probleem aan. Hoe ga je snel verder waar je gebleven was? Je zou een sandbox kunnen laten draaien, maar dan betaal je voor ongebruikte rekenkracht. Je zou helemaal opnieuw kunnen beginnen met de containerimage, maar dan moet je wachten op een langdurig `git clone` en `npm install` proces.
Cloudflare’s antwoord zijn momentopnamen, die de komende weken zullen worden uitgerold.
Een snapshot bewaart de volledige schijfstatus van een container, de besturingssysteemconfiguratie, geïnstalleerde afhankelijkheden, gewijzigde bestanden, gegevensbestanden en meer. Hierdoor kun je de container later snel herstellen.
Je kunt een sandbox zo configureren dat deze automatisch een momentopname maakt wanneer deze in de slaapstand gaat.
class AgentDevEnvironment extends Sandbox {
sleepAfter = “5m”;
persistAcrossSessions = {type: “disk”}; // you can also specify individual directories
}
Als je bijvoorbeeld vier instanties van een agent parallel wilt uitvoeren, kun je eenvoudig vier sandboxen vanuit dezelfde status opstarten.
class AgentDevEnvironment extends Sandbox {}async forkDevEnvironment(baseId, numberOfForks) { const baseInstance = await getSandbox(baseId); const snapshotId = await baseInstance.snapshot(); const forks = Array.from({ length: numberOfForks }, async (_, i) => { const newInstance = await getSandbox(`${baseId}-fork-${i}`); return newInstance.start({ snapshot: snapshotId }); });
await Promise.all(forks);
}
Snapshots worden in R2 binnen de eigen account opgeslagen, wat zorgt voor duurzaamheid en locatieonafhankelijkheid. Het gelaagde cachesysteem van R2 maakt snelle herstelacties mogelijk in de gehele regio: Earth.
In toekomstige versies wordt ook de actuele geheugenstatus vastgelegd, waardoor actieve processen precies verder kunnen gaan waar ze gebleven waren. Een terminal en een editor worden dan opnieuw geopend in exact dezelfde staat als waarin ze zich bevonden toen ze voor het laatst werden afgesloten.
Als je de sessiestatus wilt herstellen voordat snapshots live gaan, kun je de huidige back-up- en herstelmethoden gebruiken. Deze methoden bewaren en herstellen ook mappen met behulp van R2, maar zijn niet zo performant als echte snapshots op VM-niveau. Ze kunnen echter nog steeds aanzienlijke snelheidsverbeteringen opleveren ten opzichte van het op een naïeve manier opnieuw creëren van de sessiestatus.
Hogere limieten en Active CPU-prijzen
Sinds de lancering is de beschikbare capaciteit gestaag uitgebreid. Gebruikers met een standaardabonnement kunnen nu 15.000 gelijktijdige instanties van het lite-type, 6.000 instanties van het basic-type en meer dan 1.000 gelijktijdige grotere instanties draaien.
Cloudflare heeft haar prijsmodel ook aangepast om het schaalbaarder te maken. Sandboxes brengen nu alleen kosten in rekening voor actief gebruikte CPU-cycli. Dit betekent dat je niet betaalt voor inactieve CPU terwijl de agent wacht op een reactie van een LLM.
Zo ziet een computer eruit
Negen maanden geleden leverde Cloudflare een sandbox die commando’s kon uitvoeren en toegang had tot een bestandssysteem. Wat ze nu hebben is wezenlijk anders. Een sandbox is tegenwoordig een volwaardige ontwikkelomgeving: een terminal waarmee je een browser kunt verbinden, een code-interpreter met een permanente status, achtergrondprocessen met live preview-URL’s, een bestandssysteem dat realtime wijzigingsgebeurtenissen genereert, uitgaande proxies voor veilige injectie van inloggegevens en een snapshotmechanisme dat zorgt voor een bijna onmiddellijke start.
Als je hierop voortbouwt, ontstaat er een bevredigend patroon: agents die echt technisch werk kunnen verrichten. Een repository klonen, installeren, de tests uitvoeren, de fouten lezen, de code bewerken, de tests opnieuw uitvoeren. De strakke feedbackloop die een menselijke engineer effectief maakt, krijgt de agent vanaf nu ook ter beschikking.
