Ihr Agent benötigt einen Computer, nicht einen Container — Einführung von @cloudflare/computer

Die leistungsfähigsten Agents haben eine einfache Gemeinsamkeit: Ihnen steht ein eigener Computer zur Verfügung.

Coding-Agents arbeiten nach diesem Prinzip. Sie erhalten ein Dateisystem, eine Shell, Tools, Pakete und die Möglichkeit, Code auszuführen. Sie untersuchen ihre Umgebung, nehmen Änderungen vor, testen ihre Arbeit und machen weiter. Der Computer gibt dem Modell eine vertraute Umgebung, um mit der Welt zu interagieren. Bei Cloudflare arbeiten wir intensiv daran, die richtigen grundlegenden Bausteine bereitzustellen, auf denen sich die leistungsfähigsten Agents aufbauen lassen.

Heute stellen wir eine Early Preview von @cloudflare/computer vor. Das Paket @cloudflare/computer stellt eine Agent-Runtime bereit, bei der die Plattform automatisch die Details und Abläufe dafür übernimmt, welcher Code in einem Isolate und welcher in einer Container-Sandbox ausgeführt wird. Jeder Agent erhält einen eigenen Computer, während die Runtime auf Effizienz und Skalierbarkeit optimiert.

Um den stetig steigenden Compute-Bedarf agentischer Systeme zu decken, reichen herkömmliche Containerlösungen aus unserer Sicht nicht mehr aus. 

Ein neuer Ansatz für die Entwicklung von Agents

In den vergangenen sechs Monaten haben wir eine allmähliche Weiterentwicklung dieses Ansatzes beobachtet. Zu Jahresbeginn war es noch üblich, einen Container zu starten und darin einen Agent auszuführen. In den letzten Monaten hat sich jedoch rasch ein neues Muster etabliert: Agent-Harnesses stellen über Tools eine isolierte Codeausführung bereit. Dadurch werden die Hände – also die Sandbox, in der die eigentliche Arbeit stattfindet – vom Gehirn, der Agent-Schleife, getrennt.

Unabhängig davon, wo der Harness ausgeführt wird, stellt es eine Herausforderung dar, jedem Agenten einen eigenen Container bereitzustellen. Über alle Clouds und Hyperscaler hinweg gibt es weltweit bei Weitem nicht genügend Rechenkapazität, damit jedes Unternehmen jedem Agenten seiner Nutzer eine eigene containerisierte Compute-Umgebung zur Verfügung stellen kann. Dieser Ansatz lässt sich nicht auf Hunderte Millionen und anschließend Milliarden gleichzeitig aktiver Agents skalieren. Genau deshalb herrscht in der Branche eine dringende, geradezu hektische Nachfrage nach CPU-Rechenleistung – nicht nur nach GPU-Compute.

Bei Cloudflare arbeiten wir schon seit Langem an diesem Problem und haben mit Isolates einen effizienteren Compute-Baustein entwickelt. Auf diesen damals unkonventionellen Ansatz setzten wir erstmals vor fast zehn Jahren, als wir Cloudflare Workers einführten. Knapp sechs Jahre später trafen wir dieselbe Entscheidung erneut mit der Einführung von Durable Objects. Wir haben auf Isolates gesetzt, weil sie sich horizontal praktisch unbegrenzt skalieren lassen. Sie werden innerhalb von Millisekunden gestartet und beendet. Sie können in den Ruhezustand wechseln, wenn ein Agent inaktiv ist, den eigenen Zustand des Agents speichern und sogar eigene Isolates starten, um nicht vertrauenswürdigen Code auszuführen. Isolates sind die beste Möglichkeit zur horizontalen Skalierung – und genau diese horizontale Skalierbarkeit benötigen Agents.

Im vergangenen Jahr haben wir Isolates die Möglichkeit gegeben, eigene Container-Sandboxes zu starten. Die Architektur von Cloudflare war von Anfang an darauf ausgelegt, den Agent-Harness im Isolate – innerhalb eines Durable Object – auszuführen und bei Bedarf einen angebundenen Container als Tool aufzurufen. So kommen rechenintensivere Compute-Bausteine nur dann zum Einsatz, wenn sie tatsächlich benötigt werden, was Performance und Kosten optimiert. Durable Objects lassen sich horizontal praktisch unbegrenzt skalieren, während der angebundene Container die vertikale Skalierung für beliebige Aufgaben ermöglicht. So entwickeln wir unsere Agents selbst – und wir sehen, dass auch Kunden auf diese Weise beeindruckende Anwendungen entwickeln

Wenn wir jedoch betrachten, dass für die Entwicklung von Agents mehrere zugrunde liegende Compute-Bausteine – Isolates und Container – erforderlich sind und unsere Kunden und Entwickler diese bislang selbst im Userspace kombinieren müssen, sind wir überzeugt, dass es besser geht. Wir können eine einfachere Abstraktion bereitstellen.

Deshalb starten wir dieses Experiment mit @cloudflare/computer als Open-Source-Bibliothek. Gemeinsam mit unseren Kunden, die die Grenzen des skalierbaren Betriebs von Agents ausloten, möchten wir Erfahrungen sammeln.

Ein gemeinsames Dateisystem über Isolations- und Containergrenzen hinweg

Das Paket @cloudflare/computer basiert auf einer einfachen Überlegung: Was wäre, wenn wir einem Agenten ein vorbereitetes, deklarativ definiertes Dateisystem bereitstellen, das alles enthält, was für die jeweilige Aufgabe erforderlich ist, sowie eine Auswahl an Ausführungsumgebungen, die mit diesen Dateien arbeiten können – jeweils mit eigenen Vor- und Nachteilen hinsichtlich Geschwindigkeit, Leistungsumfang und Kosten?

Es zeigt sich, dass Agents heute erstaunlich gut darin sind, die passende Umgebung für die jeweilige Aufgabe auszuwählen. Eine Aufgabe, bei der lediglich Dateien bearbeitet, Daten verarbeitet oder ein Git-Repository verwaltet werden müssen, kann in einem Isolate ausgeführt werden. Ein Befehl, der Linux, npm oder eine native Binärdatei erfordert, kann hingegen in einem Container laufen. Beide Umgebungen arbeiten mit denselben Dateien, die mit dem Quelldateisystem synchron gehalten werden.

Das Paket @cloudflare/computer stellt ein persistentes Dateisystem bereit, das Sie mit Git-Repositories, Storage-Buckets oder beliebigen anderen Dateien verwenden können. Es bietet Tools, mit denen Sie Dateien über den Code Mode (Code-Modus) oder mithilfe von Bash-Befehlen lesen, schreiben und bearbeiten können. Sämtliche Vorgänge werden kontrolliert, protokolliert und überwacht. Dadurch erhalten Sie eine granulare Kontrolle darüber, welche Änderungen der Agent vornehmen darf, sowie eine klare Nachvollziehbarkeit aller ausgeführten Aktionen.

Wie Sie es nutzen können

Eine Instanz eines @cloudflare/computer-Workspaces kann in jedem Durable Object erstellt werden und stellt dort ein virtuelles Dateisystem sowie eine Ausführungsumgebung bereit.

Es wird über npm installiert:

npm install @cloudflare/computer

Der primäre Anwendungsfall besteht darin, dieses Dateisystem und die Werkzeuge einem Agenten bereitzustellen. Hier ist beispielsweise, wie Sie den Arbeitsbereich auf einem von @cloudflare/think betriebenen Agenten einrichten, der zur Priorisierung von Fehlermeldungen gedacht ist.

import { Think } from "@cloudflare/think";
import { Workspace, type DurableObjectStorageLike } from "@cloudflare/computer";
import { createWorkersAI } from "workers-ai-provider";

export class Agent extends Think {
  override workspaceBash = false;

  override workspace = new Workspace({
    storage: this.ctx.storage,
    useThink: true, // soon will not be needed
  });

  override getModel() {
    return createWorkersAI({ binding: this.env.AI })("@cf/zai-org/glm-5.2");
  }

  override getSystemPrompt() {
    return `
You are a bug triage agent.

Use the project in /workspace/repo to reproduce the bug, inspect the
code, make a focused fix when it is safe, and run verification. In your
final answer, include what you changed, which commands you ran, and
whether verification passed.`;
  }
}

Das Paket @cloudflare/computer stellt mehrere Ausführungs-Backends bereit, Sie können aber auch eigene implementieren. Im folgenden Beispiel binden wir einen Cloudflare Container an.

import { Think } from "@cloudflare/think";
import { Workspace, WorkspaceProxy } from "@cloudflare/computer";
import {
  CloudflareContainerBackend,
  withWorkspaceContainer,
} from "@cloudflare/computer/backends/container";

export { WorkspaceProxy };

export class Agent extends withWorkspaceContainer(Think) {
  override workspaceBash = false;

  override workspace = new Workspace({
    storage: this.ctx.storage,
    useThink: true, // soon will not be needed
    backends: [
      new CloudflareContainerBackend({
        container: () => this,
        workspace: {
          binding: "Agent",
          id: this.ctx.id.toString(),
        },
      }),
    ],
  });

  /* Example code truncated for readability... */
}

Stellen Sie die Datei-, Git- und Shell-Tools neben produktspezifischen Tools bereit, um auf gemeldete Probleme zu reagieren.

import { createAITools } from "@cloudflare/computer/tools";
import type { ToolSet } from "ai";
import { replyToIssue } from "./tools/github";

export class Agent extends withWorkspaceContainer(Think) {
  override workspaceBash = false;

  /* Example code truncated for readability... */

  override getTools(): ToolSet {
    return {
      ...createAITools({
        workspace: this.workspace,
        shell: {
          defaultBackend: "container",
          backends: {
            container: {
              description:
                "Cloudflare Container with a full Linux userland: " +
                "npm, node, package managers, test runners, and real " +
                "binaries on $PATH. Use it when a task needs more than " +
                "file manipulation.",
            },
          },
        },
      }),
      replyToIssue,
    };
  }
}

Das Modell kann während der Agent-Schleife Werkzeuge verwenden, aber Sie können auch die Workspace-API direkt nutzen, um beispielsweise die Umgebung vorzubereiten, bevor Sie dem Agenten einen Prompt übergeben

export class Agent extends withWorkspaceContainer(Think) {
  override workspaceBash = false;

  /* Example code truncated for readability... */

  async startTriage(report: { title: string; body: string; repoUrl: string }) {
    await this.workspace.fs.mkdir("/workspace", { recursive: true });
    await this.workspace.fs.writeFile(
      "/workspace/BUG_REPORT.md",
      `# ${report.title}\n\n${report.body}\n`,
    );

    await this.workspace.git.clone({
      url: report.repoUrl,
      dir: "/workspace/repo",
    });

    return this.submitMessages([
      {
        id: crypto.randomUUID(),
        role: "user",
        parts: [
          {
            type: "text",
            text: [
              `Triage this bug: ${report.title}`,
              "The bug report is in /workspace/BUG_REPORT.md.",
              "The repository is checked out at /workspace/repo.",
            ].join("\n"),
          },
        ],
      },
    ]);
  }
}

Im Workspace-Repository finden Sie weitere Beispiele für den Einsatz der unterschiedlichen Backends und Tools – darunter auch eine Schritt-für-Schritt-Anleitung, die den Aufbau eines Agents von Grund auf erklärt.

So funktioniert’s

Das zentrale Element von @cloudflare/computer ist der Workspace: ein SQLite-basiertes virtuelles Dateisystem, das aus verschiedenen Quellen befüllt werden kann, darunter Cloud-Speicher und Versionsverwaltungssysteme.

Der Workspace kann um optionale Ausführungsumgebungen ergänzt werden, die Code direkt auf dem Dateisystem ausführen. Sämtliche Runtimes unterstützen dieselbe Schnittstelle exec(string, options). Aktuell sind zwei standardmäßig enthalten, eigene Implementierungen sind ebenfalls möglich:

• Eine Isolate-basierte Runtime-Umgebung nutzt just-bash, um Shell-Code in JavaScript zu übersetzen, und wird in einem dynamischen Worker ausgeführt. Das Dateisystem ist dabei direkt über Worker Bindings verfügbar.
• Eine Container-Runtime verwendet Cloudflare Containers, um eine vollständige Linux-Umgebung bereitzustellen. Hier wird das Dateisystem über einen Filesystem-in-Userspace-Mount (FUSE) eingebunden, sodass der Container auf die Dateien zugreifen kann und Änderungen anschließend zurücksynchronisiert werden.

Die Klasse Workspace stellt eine API zum direkten Arbeiten mit dem Dateisystem sowie einen mit node:fs-kompatiblen Wrapper bereit, sodass sie sich problemlos mit JavaScript-Bibliotheken von Drittanbietern verwenden lässt.

Für die Arbeit mit Agents stellen wir ein mit dem AI SDK kompatibles Toolkit bereit, das die gängigsten Tools umfasst: read, write, edit, ls und exec. Das Tool exec ist dabei etwas Besonderes, da es über mehrere Runtimes hinweg arbeitet und ein backend-Argument akzeptiert. Die Tool-Beschreibung hilft dem Agenten, für die jeweilige Aufgabe die richtige Runtime auszuwählen: entweder ein schnelles, kostengünstiges Worker-Backend oder den vollwertigen Container. In unseren Tests treffen Frontier-Modelle diese Entscheidung sehr zuverlässig und greifen nur dann auf Container zurück, wenn sie tatsächlich benötigt werden.

Was steht als Nächstes an?

Schon heute beobachten wir bei Cloudflare, dass Agents ausschließlich mit Isolates JavaScript-Anwendungen mithilfe moderner Toolchains entwickeln, testen und bereitstellen, für jeden unserer Kunden individuell zugeschnittene Dokumentationen erstellen und Webbrowser für die Ausführung komplexer Aufgaben nutzen.

Unser Ziel mit @cloudflare/computer ist es, Agents eine Runtime bereitzustellen, in der für weniger als zehn Prozent ihrer Aufgaben ein Container erforderlich ist und Coding-Aufgaben, die Bearbeitung von Audio- und Videodateien sowie die Erstellung von Dokumenten vollständig in Isolates erfolgen können. 

Probieren Sie die Early Preview noch heute aus – wir freuen uns auf Ihr Feedback.