En 2026, le paysage de l’IA a atteint un tournant décisif : la transition de l’intelligence expérimentale à l’exécution industrialisée. Alors que la première vague de l’IA était axée sur la conversation, l’ère actuelle est définie par l’autonomie des agents.
Avec la sortie du SDK Claude Agent, le paradigme est passé d’API sans état à des environnements d’exécution persistants et avec état. Les développeurs ne se contentent plus d’agents qui se contentent de générer du code : ils exigent des systèmes capables d’exécuter, de déboguer et d’itérer de manière autonome. Contrairement aux LLM traditionnels qui « oublient » après chaque requête, le SDK Claude Agent maintient désormais une boucle de raisonnement continue, écrivant du code, déboguant en temps réel et gérant des systèmes de fichiers complexes.
Cependant, un manque critique subsiste : l’infrastructure. Pour passer d’une démo à une main-d’œuvre numérique de qualité production, les agents ont besoin de plus que d’intelligence : ils ont besoin d’environnements sécurisés, évolutifs, hautes performances et abordables pour effectuer leur travail.
Apprenez à déployer et héberger des agents Claude en production à l’aide de Novita Sandbox, un environnement d’exécution cloud compatible E2B qui comble ce manque grâce à une infrastructure économique de qualité entreprise.
💡 Prêt à commencer à développer ?
Novita propose un exemple complet et prêt pour la production du SDK Claude Agent, avec une CLI interactive, des implémentations d’outils et les meilleures pratiques. Clonez le dépôt et exécutez votre premier agent en quelques minutes.
Avantages clés : conçu pour Anthropic
1. Migration véritable « sans refactorisation »
Novita propose un point de terminaison d’API Anthropic entièrement compatible. Modifiez simplement un baseURL pour doter vos applications Claude existantes de capacités d’exécution dans le monde réel.
- Intégration native : Utilisez directement
@anthropic-ai/sdk— pas de nouveaux frameworks à apprendre. - Basculement transparent : Compatible avec toutes les fonctionnalités bêta, y compris les modes
context-managementetthinking.
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. « Laboratoire sandbox » isolé dans le cloud
Novita Sandbox propose des environnements Linux à lancement instantané avec accès au système de fichiers, communication réseau et processus en arrière-plan :
- Isolation sécurisée : Chaque requête s’exécute dans un sandbox indépendant, empêchant la contamination du code.
- Capacités full-stack : Environnements Node.js, Python et Jupyter intégrés avec prise en charge de l’installation dynamique de
npmetpip. - Aperçu instantané : Exposition en un clic du port HTTPS public — visualisez immédiatement les pages générées.
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. Auto-guérison du contexte et conscience intelligente
En s’appuyant sur les capacités d’utilisation d’outils de Claude, les agents peuvent :
- Adapter et réparer : Lorsque des erreurs d’exécution surviennent, l’agent voit le
stderret réécrit automatiquement le code. - Optimiser la mémoire : Combiné aux stratégies
contextManagement, le système efface automatiquement les anciens blocs de code pour rester concentré.
// 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,
});
Comment ça marche : Lorsque le contexte de conversation dépasse le seuil défini, l’API efface automatiquement les résultats des appels d’outils précédents tout en préservant les informations critiques récentes. Cela évite la « pollution de la mémoire » qui dégrade les performances de l’agent.
Cas d’usage : des possibilités infinies
| Scénario | Ce qu’ajoute Novita Sandbox |
|---|---|
| Laboratoire web interactif | Générez des pages React/Tailwind à partir d’une seule phrase ; aperçu instantané. |
| Analyse de données intelligente | Exécutez dynamiquement du Python pour générer des graphiques avec Pandas et Matplotlib. |
| Tests automatisés par IA | Exécutez des scripts de test dans des environnements isolés ; capturez et corrigez automatiquement les bugs. |
| Backend IDE personnalisé | Fournissez à chaque utilisateur un exécuteur cloud indépendant — sans surcharge opérationnelle. |
| Flux de travail de code auto-cicatrisant | Testez le code d’API généré en boucle fermée, en vous assurant qu’il s’exécute correctement avant la livraison. |
Démarrage rapide : créez un agent interactif en trois étapes
Aucune configuration complexe nécessaire — Novita simplifie le développement.
Étape 1 : Installation minimale
npm install @anthropic-ai/sdk novita-sandbox dotenv open
Étape 2 : Intégration intelligente de la clé API
Le projet inclut une guidance interactive pour la clé. Même sans variables d’environnement, le programme vous invite à la saisir au démarrage :
// agent_en.ts internal logic
if (!agent.hasApiKey()) {
const apiKey = await promptForApiKey(rl);
agent.setApiKey(apiKey);
}
Étape 3 : Lancement en un clic de la CLI interactive
Exécutez npm run agent-en pour passer en mode interactif. Saisissez simplement vos exigences, et les modèles compatibles Anthropic se chargeront de générer du code, d’exécuter des services et d’ouvrir le navigateur.
npm run agent-en
Présentation détaillée du code principal
📌 Définitions des outils : donner à l’IA des « capacités physiques »
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: {} },
},
];
📌 Boucle agentique : traiter jusqu’à la fin de la tâche
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;
}
}
}
📌 Auto-guérison des services : détection intelligente et redémarrage automatique
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}`;
}
Explorez l’exemple complet
Novita propose un exemple entièrement fonctionnel du SDK Claude Agent avec des modèles de code prêts pour la production. L’exemple démontre :
- Interface CLI interactive avec des réponses en streaming
- Implémentations d’outils complètes (opérations sur fichiers, exécution de code, gestion de serveur web)
- Gestion du contexte avec nettoyage automatique
- Gestion des erreurs et logique de nouvelle tentative
- Vérifications de l’état des services avec redémarrage automatique
- Conversation multi-tours avec état persistant
Dépôt GitHub : Novita-CollabHub/examples/claude-agent
Démarrage rapide avec l’exemple :
# 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
Démo de dialogue multi-tours
Voici un exemple complet de dialogue multi-tours montrant comment l’agent affine itérativement une page en fonction des retours de l’utilisateur :
Tour 1 : Créer une application de liste de tâches
Entrée utilisateur : Créer une application de liste de tâches
Tour 2 : Passer au style Stardew Valley
Entrée utilisateur : Passer au style Stardew Valley
Tour 3 : Ajouter plus de fonctionnalités
Entrée utilisateur : Ajouter plus de fonctionnalités
Conclusion
Déployer le SDK Claude Agent en production nécessite une infrastructure que les plateformes cloud traditionnelles n’ont pas été conçues pour fournir. Novita Sandbox propose une infrastructure prête pour la production qui s’intègre parfaitement au SDK Claude Agent, donnant à vos agents les « mains » dont ils ont besoin pour travailler dans le monde réel en offrant :
- Environnement d’exécution cloud compatible E2B pour une intégration transparente avec les outils existants
- Point de terminaison compatible Anthropic natif ne nécessitant aucune refactorisation — il suffit de modifier le baseURL
- Isolation sécurisée des conteneurs pour l’exécution de code non fiable
- Provisionnement instantané avec des environnements d’exécution préconfigurés
- Exposition d’URL publique pour les applications web générées
- Gestion des processus en arrière-plan pour les services de longue durée
Commencez à développer des agents IA avec état dès aujourd’hui :
Novita AI est une plateforme cloud IA leader qui fournit aux développeurs des API faciles à utiliser et une infrastructure GPU abordable et fiable pour créer et mettre à l’échelle des applications IA.
