So stellen Sie den Claude Agent SDK mit Novita Sandbox bereit und hosten ihn

Im Jahr 2026 hat die KI-Landschaft einen entscheidenden Wendepunkt erreicht: den Übergang von experimenteller Intelligenz zu industrialisierter Ausführung. Während die erste KI-Welle auf Konversation fokussiert war, wird die aktuelle Ära durch Agency definiert.

Mit der Veröffentlichung des Claude Agent SDK hat sich das Paradigma von zustandslosen APIs zu zustandsbehafteten, persistenten Laufzeitumgebungen verschoben. Entwickler:innen sind nicht mehr mit Agenten zufrieden, die nur Code generieren – sie verlangen Systeme, die autonom ausführen, debuggen und iterieren können. Im Gegensatz zu herkömmlichen LLMs, die nach jeder Anfrage „vergessen“, unterhält der Claude Agent SDK nun einen kontinuierlichen Reasoning-Loop, schreibt Code, debuggt in Echtzeit und verwaltet komplexe Dateisysteme.

Eine kritische Lücke bleibt jedoch: die Infrastruktur. Um von Demos zu einer produktionsreifen digitalen Belegschaft überzugehen, benötigen Agenten mehr als nur Intelligenz – sie brauchen sichere, skalierbare, leistungsstarke und kostengünstige Umgebungen, um ihre Arbeit zu verrichten.

Erfahren Sie, wie Sie Claude-Agenten in der Produktion mit Novita Sandbox bereitstellen und hosten – einer E2B-kompatiblen Cloud-Ausführungsumgebung, die diese Lücke mit kosteneffektiver, unternehmensgerechter Infrastruktur schließt.

💡 Bereit, mit der Entwicklung zu starten?
Novita bietet ein vollständiges, produktionsreifes Beispiel für den Claude Agent SDK mit interaktiver CLI, Tool-Implementierungen und Best Practices. Klonen Sie das Repository und führen Sie Ihren ersten Agenten innerhalb von Minuten aus.

Kernvorteile: Entwickelt für Anthropic

1. Echte „Zero-Refactoring“-Migration

Novita bietet einen vollständig kompatiblen Anthropic-API-Endpunkt. Ändern Sie einfach eine baseURL, um Ihren bestehenden, auf Claude basierenden Anwendungen echte Ausführungsfähigkeiten in der Praxis zu verleihen.

• Native Integration: Verwenden Sie @anthropic-ai/sdk direkt – keine neuen Frameworks, die Sie lernen müssen.
• Nahtloser Wechsel: Kompatibel mit allen Beta-Funktionen, einschließlich context-management und thinking-Modi.

import Anthropic from "@anthropic-ai/sdk";

// Just modify baseURL to switch seamlessly to Novita
const anthropic = new Anthropic({
  baseURL: "https://api.novita.ai/anthropic",
  apiKey: process.env.NOVITA_API_KEY,
});

// All Anthropic SDK usage remains unchanged
const response = await anthropic.messages.create({
  model: "zai-org/glm-4.7",
  max_tokens: 4096,
  messages: [{ role: "user", content: "Hello, World!" }],
});

2. Cloud-isoliertes „Sandbox-Labor“

Novita Sandbox bietet sofort startbare Linux-Umgebungen mit Dateisystemzugriff, Netzwerkkommunikation und Hintergrundprozessen:

• Sichere Isolierung: Jede Anfrage läuft in einer unabhängigen Sandbox, um Code-Kontaminierung zu verhindern.
• Full-Stack-Fähigkeiten: Integrierte Node.js-, Python- und Jupyter-Umgebungen mit dynamischer npm- und pip-Installationsunterstützung.
• Sofortige Vorschau: Ein-Klick-Freigabe von öffentlichen HTTPS-Ports – betrachten Sie generierte Seiten sofort.

import { Sandbox } from "novita-sandbox/code-interpreter";

// Create an isolated cloud environment in seconds
const sandbox = await Sandbox.create({ timeoutMs: 10 * 60 * 1000 });

// Write files
await sandbox.files.write("index.html", "<h1>Hello from Sandbox!</h1>");

// Start a background service and get a public URL
const handle = await sandbox.commands.run("npx http-server -p 3000", { background: true });
const publicUrl = `https://${sandbox.getHost(3000)}`;

console.log(`🌐 Preview URL: ${publicUrl}`);

3. Kontext-Selbstheilung und intelligente Wahrnehmung

Durch Nutzung der Tool-Use-Fähigkeiten von Claude können Agenten:

• Anpassen und Reparieren: Wenn Laufzeitfehler auftreten, sieht der Agent stderr und schreibt den Code automatisch neu.
• Speicher optimieren: In Kombination mit contextManagement-Strategien löscht das System automatisch alte Codeblöcke, um fokussiert zu bleiben.

// Enable the context-management Beta feature
// Reference: https://platform.claude.com/docs/en/build-with-claude/context-editing
const response = await anthropic.beta.messages.create({
  model: "zai-org/glm-4.7",
  max_tokens: 4096,
  betas: ["context-management-2025-06-27"],
  contextManagement: {
    edits: [
      {
        type: "clear_tool_uses_20250919",
        trigger: { type: "input_tokens", value: 10000 },  // Trigger cleanup when exceeding 10k tokens
        keep: { type: "tool_uses", value: 2 },            // Keep the last 2 tool calls
        clear_tool_inputs: true,                          // Also clear tool inputs
      },
    ],
  },
  tools: TOOLS,
  messages: conversationHistory,
});

Funktionsweise: Wenn der Konversationskontext den festgelegten Schwellenwert überschreitet, löscht die API automatisch frühere Tool-Aufrufergebnisse, während aktuelle kritische Informationen erhalten bleiben. Dadurch wird „Speicherverschmutzung“ verhindert, die die Agentenleistung beeinträchtigt.

Anwendungsfälle: Unendliche Möglichkeiten

Szenario	Was Novita Sandbox hinzufügt
Interaktives Web-Labor	Generieren Sie React/Tailwind-Seiten aus einem einzigen Satz; sofortige Vorschau.
Intelligente Datenanalyse	Führen Sie Python dynamisch aus, um Diagramme mit Pandas und Matplotlib zu generieren.
KI-gestütztes automatisiertes Testen	Führen Sie Testskripte in isolierten Umgebungen aus; erfassen und beheben Sie Fehler automatisch.
Personalisiertes IDE-Backend	Stellen Sie jedem Benutzer einen unabhängigen Cloud-Executor zur Verfügung – kein operativer Aufwand.
Selbstheilende Code-Workflows	Testen Sie generierten API-Code in einem geschlossenen Kreislauf, um sicherzustellen, dass er vor der Auslieferung korrekt läuft.

Schnellstart: Erstellen Sie einen interaktiven Agenten in drei Schritten

Keine komplexe Konfiguration erforderlich – Novita macht die Entwicklung einfach.

Schritt 1: Minimale Installation

npm install @anthropic-ai/sdk novita-sandbox dotenv open

Schritt 2: Intelligente API-Schlüssel-Integration

Das Projekt enthält eine interaktive Schlüsselführung. Auch ohne Umgebungsvariablen werden Sie beim Start vom Programm dazu aufgefordert:

// agent_en.ts internal logic
if (!agent.hasApiKey()) {
  const apiKey = await promptForApiKey(rl);
  agent.setApiKey(apiKey);
}

Schritt 3: Ein-Klick-Start der interaktiven CLI

Führen Sie npm run agent-en aus, um den interaktiven Modus zu starten. Geben Sie einfach Ihre Anforderungen ein, und Anthropic-kompatible Modelle übernehmen die Codegenerierung, das Ausführen von Diensten und das Öffnen des Browsers.

npm run agent-en

Code-Walkthrough der Kernkomponenten

📌 Tool-Definitionen: KI „physische Fähigkeiten“ verleihen

const TOOLS: Anthropic.Beta.Messages.BetaTool[] = [
  {
    name: "write_file",
    description: "Create or modify a file in the sandbox",
    input_schema: {
      type: "object",
      properties: {
        path: { type: "string", description: "File path, e.g., index.html" },
        content: { type: "string", description: "Complete file content" },
      },
      required: ["path", "content"],
    },
  },
  {
    name: "get_preview_url",
    description: "Start the web server and get the preview URL (returns the existing URL if the server is already running)",
    input_schema: { type: "object", properties: {} },
  },
];

📌 Agentischer Loop: Verarbeitung bis zur Aufgabenfertigstellung

async chat(userMessage: string): Promise<void> {
  // Refresh sandbox timeout on each user input
  await this.refreshSandboxTimeout();
  
  this.messages.push({ role: "user", content: userMessage });

  // Agentic Loop—continue processing until no tool calls remain
  let continueLoop = true;
  while (continueLoop) {
    const { response, assistantContent } = await this.streamResponse();
    this.messages.push({ role: "assistant", content: assistantContent });

    // Process tool calls
    const { hasToolUse, toolResults } = await this.processToolCalls(assistantContent);

    if (hasToolUse && toolResults.length > 0) {
      this.messages.push({ role: "user", content: toolResults });
      continueLoop = true;  // Tool calls exist; continue loop
    } else {
      continueLoop = false; // No tool calls; end
    }

    if (response.stop_reason === "end_turn") {
      continueLoop = false;
    }
  }
}

📌 Dienst-Selbstheilung: Intelligente Erkennung und automatischer Neustart

private async handleGetPreviewUrl(): Promise<string> {
  // Verify whether the process is actually alive
  if (this.previewUrl && this.serverHandle) {
    const processAlive = await this.checkServerProcessAlive();
    if (!processAlive) {
      console.log(`⚠️ Server process has exited; restarting...`);
      this.serverHandle = null;
      this.previewUrl = null;
    }
  }

  // Start a new server
  this.serverHandle = await this.sandbox.commands.run(
    `npx -y http-server . -p ${CONFIG.serverPort} -c-1`,
    { background: true }
  );

  // Get the public URL and run a health check
  const host = this.sandbox.getHost(CONFIG.serverPort);
  this.previewUrl = `https://${host}`;
  
  await waitForServer(this.previewUrl, maxRetries, intervalMs);
  await openBrowser(this.previewUrl);
  
  return `Preview URL: ${this.previewUrl}`;
}

Entdecken Sie das vollständige Beispiel

Novita bietet ein voll funktionsfähiges Beispiel für den Claude Agent SDK mit produktionsreifen Codemustern. Das Beispiel demonstriert:

• Interaktive CLI-Oberfläche mit Streaming-Antworten
• Vollständige Tool-Implementierungen (Dateioperationen, Codeausführung, Webserver-Verwaltung)
• Kontextverwaltung mit automatischer Bereinigung
• Fehlerbehandlung und Wiederholungslogik
• Dienstzustandsprüfungen mit automatischem Neustart
• Mehrrunden-Konversation mit persistentem Zustand

GitHub-Repository: Novita-CollabHub/examples/claude-agent

Schnellstart mit dem Beispiel:

# Clone the repository
git clone https://github.com/novitalabs/Novita-CollabHub.git
cd Novita-CollabHub/examples/claude-agent

# Install dependencies
npm install

# Set your API key
export NOVITA_API_KEY=your_api_key_here

# Run the interactive agent
npm run agent-en

Demo einer Mehrrunden-Konversation

Hier ist ein vollständiges Beispiel für eine Mehrrunden-Konversation, das zeigt, wie der Agent eine Seite iterativ basierend auf Benutzerfeedback verbessert:

Runde 1: Erstelle eine To-Do-Listen-App

Benutzereingabe: Erstelle eine To-Do-Listen-App

Runde 2: Wechsle zum Stardew-Valley-Stil

Benutzereingabe: Wechsle zum Stardew-Valley-Stil

Runde 3: Füge weitere Funktionen hinzu

Benutzereingabe: Füge weitere Funktionen hinzu

Fazit

Die Bereitstellung des Claude Agent SDK in der Produktion erfordert Infrastruktur, die traditionelle Cloud-Plattformen nicht bereitstellen können. Novita Sandbox bietet eine produktionsreife Infrastruktur, die sich nahtlos in den Claude Agent SDK integriert und Ihren Agenten die „Hände“ gibt, die sie brauchen, um in der realen Welt zu arbeiten, indem sie Folgendes bietet:

• E2B-kompatible Cloud-Ausführungsumgebung für nahtlose Integration mit bestehenden Tools
• Nativ Anthropic-kompatibler Endpunkt ohne Refactoring-Aufwand – ändern Sie einfach die baseURL
• Sichere Container-Isolierung für die Ausführung von nicht vertrauenswürdigem Code
• Sofortige Bereitstellung mit vorkonfigurierten Laufzeitumgebungen
• Öffentliche URL-Freigabe für generierte Webanwendungen
• Hintergrundprozessverwaltung für langlebige Dienste

Beginnen Sie noch heute mit der Erstellung von zustandsbehafteten KI-Agenten:

• Novita Sandbox Dokumentation
• Vollständiges Agent-SDK-Beispiel

Novita AI ist eine führende KI-Cloud-Plattform, die Entwickler:innen einfach zu verwendende APIs sowie kostengünstige, zuverlässige GPU-Infrastruktur zum Erstellen und Skalieren von KI-Anwendungen bietet.