Novita Agent Runtime : Infrastructure d'agents IA compatible AgentCore

La création d’agents IA est de plus en plus simple. Leur déploiement à grande échelle reste un défi majeur. Les infrastructures traditionnelles comme les conteneurs, les machines virtuelles et les fonctions serverless ont été conçues pour des applications web classiques. Elles ne répondent pas aux besoins spécifiques des charges de travail des agents IA.

Novita Agent Runtime comble ce manque en fournissant une infrastructure serverless spécialement conçue pour le déploiement d’agents IA. Construit sur le bac à sable d’agents de Novita, il prend en charge les workflows LangGraph, les systèmes multi-agents Microsoft AutoGen et les implémentations personnalisées. Déployez vos agents existants en production avec des modifications de code minimales et zéro gestion d’infrastructure.

Le fossé d’infrastructure qui freine les agents IA

Les applications traditionnelles suivent un modèle prévisible : recevoir une requête, la traiter, renvoyer une réponse. L’ensemble du cycle de vie s’achève en millisecondes ou en secondes, chaque requête étant traitée indépendamment.

Les agents IA fonctionnent différemment. Ils maintiennent un état de raisonnement entre les interactions, exécutent des workflows longs, appellent des services externes avec une latence imprévisible et nécessitent une isolation forte pour des utilisateurs concurrents manipulant des données sensibles.

Les infrastructures existantes ne correspondent pas bien à ces besoins :

Fonctionnalité	Agent Sandbox	Conteneur	Serverless	Machine virtuelle
Temps de démarrage	<200ms (MicroVM)	Secondes	1s	30+ secondes
Isolation de sécurité	Forte (MicroVM)	Faible (noyau partagé)	Forte	Forte
Persistance de l’état	Suspendre/reprendre instantané	Pris en charge	Sans état	Récupération d’instantané lente
Durée d’exécution maximale	Heures	Illimitée	Limite généralement de 15 min	Illimitée
Expérience développeur	APIs optimisées pour les agents	APIs génériques	APIs au niveau fonction	APIs au niveau infrastructure

Novita Agent Sandbox associe un temps de démarrage en millisecondes, l’isolation MicroVM, une exécution avec état et des APIs natives pour les agents. Novita Agent Runtime, construit sur Agent Sandbox, vous permet de déployer des agents existants sur cette infrastructure avec des modifications de code minimales.

Novita Agent Runtime : Conçu spécifiquement pour les agents IA

Novita Agent Runtime est un toolkit de déploiement serverless léger, indépendant des frameworks, construit sur une architecture compatible AgentCore. Il vous permet de déployer des agents IA existants en production de manière sûre et efficace, sans nécessiter d’expertise DevOps approfondie ni de gestion d’infrastructure.

Le toolkit prend en charge à la fois les interactions en temps réel et les charges de travail de longue durée, des interfaces conversationnelles nécessitant des temps de réponse inférieurs à la seconde aux tâches de raisonnement complexes pouvant prendre plusieurs heures à s’exécuter.

Novita Agent Runtime inclut un SDK et des outils CLI. Le SDK fournit des APIs basées sur des décorateurs pour exposer votre agent en tant que service HTTP standard et des méthodes pour invoquer des agents par programmation. La CLI permet une configuration et un déploiement en un clic vers l’écosystème Novita Agent Sandbox.

Fonctionnalités clés de Novita Agent Runtime

Indépendant des frameworks. Novita Agent Runtime fonctionne avec LangGraph, Microsoft AutoGen, Google ADK, OpenAI Agents SDK, CrewAI et les implémentations personnalisées. Utilisez votre framework préféré sans verrouillage d’infrastructure.

Indépendant des modèles. Le runtime fonctionne indépendamment de votre choix de modèle. Il est compatible avec Novita AI, Anthropic Claude, Google Gemini, OpenAI et tout autre fournisseur.

Démarrages à froid en moins de 200ms. La technologie de virtualisation légère permet d’atteindre des vitesses de démarrage quasi équivalentes à celles des conteneurs, avec une isolation de l’environnement au niveau matériel. Même les premières requêtes reçoivent des réponses en moins d’une seconde.

Isolation complète des sessions. Chaque session utilisateur s’exécute dans un microVM dédié avec des ressources CPU, mémoire et système de fichiers isolées. Après la fin de la session, l’ensemble du microVM est arrêté et la mémoire est nettoyée.

Exécution sur plusieurs heures. La plateforme prend en charge les charges de travail de longue durée s’étalant sur plusieurs heures, permettant un raisonnement complexe des agents, des workflows asynchrones et la collaboration multi-agents.

Facturation à la consommation. Ne payez que ce que vous utilisez. Passez du prototype à la production sans payer pour une capacité inutilisée ou vous soucier de la planification des ressources.

Du code au cloud en trois étapes

Étape 1 : Intégrez le SDK. Ajoutez quelques lignes de code à votre implémentation d’agent existante en utilisant l’API basée sur des décorateurs du SDK. Le SDK gère automatiquement le routage des requêtes, le formatage des réponses et les contrôles de santé.

from novita_sandbox.agent_runtime import AgentRuntimeApp

app = AgentRuntimeApp()

@app.entrypoint
def my_agent(request: dict):
    # Agent business logic
    return {"result": "..."}

Étape 2 : Déployez en une seule commande. Utilisez la CLI pour configurer et déployer votre agent :

# Configure your agent
novita-sandbox-cli agent configure

# Deploy to cloud
novita-sandbox-cli agent launch

La CLI génère un Dockerfile et un fichier de configuration .novita-agent.yaml, construit votre modèle de bac à sable et le télécharge, puis génère un ID d’agent au format <agent_name>-<template_id>.

Étape 3 : Invoquez votre agent. Après le déploiement, invoquez votre agent via la CLI pour un test rapide :

# Quick test with CLI
novita-sandbox-cli agent invoke "Hello, Agent!"

Ou invoquez-le par programmation via le SDK :

import json
from novita_sandbox.agent_runtime import AgentRuntimeCliendevet

client = AgentRuntimeClient(api_key="your-api-key")

# Prepare request data (converted to a JSON string and encoded as bytes)
payload = json.dumps({"prompt": "Hello, Agent!"}).encode()

response = await client.invoke_agent_runtime(
    agentId="agent-xxxxx",
    payload=payload
)

Chaque invocation crée une instance de bac à sable isolée, exécute l’agent dans cet environnement sécurisé et renvoie le résultat.

Pour une procédure détaillée avec des exemples de code, consultez le Guide de démarrage rapide. Pour les instructions d’installation complètes, consultez le Guide d’installation.

Compatible avec tous les frameworks IA majeurs

Toutes les intégrations de frameworks suivent un modèle cohérent : initialisez AgentRuntimeApp, configurez votre framework, définissez un point d’entrée avec le décorateur et exécutez l’application. Le SDK fonctionne de manière transparente avec LangGraph, OpenAI Agents SDK, Microsoft AutoGen, Google ADK et les implémentations personnalisées.

from novita_sandbox.agent_runtime import AgentRuntimeApp

# 1. Create Agent Runtime application instance
app = AgentRuntimeApp()

# 2. Initialize your Agent framework

# 3. Define entry point with decorator
@app.entrypoint
def agent_invocation(request: dict) -> dict:
    """
    Args:
        request: Request data, typically contains fields like prompt
    Returns:
        Response data dictionary
    """
    prompt = request.get("prompt", "")
    
    # Call your Agent framework
    result = your_agent.run(prompt)
    
    return {"result": result}

# 4. Run the application
if __name__ == "__main__":
    app.run()

Pour des exemples d’intégration détaillés, consultez le Guide d’intégration des frameworks d’agents. Pour les fonctionnalités avancées, notamment les réponses en streaming, les conversations multi-tours et la gestion des variables d’environnement, reportez-vous à la documentation sur les fonctionnalités avancées.

Tarification transparente à la seconde

Novita Agent Runtime utilise une facturation à la consommation avec une granularité de facturation à la seconde.

CPU

vCPUs	Prix unitaire (par seconde)
1× CPU	0,00000784 $/s
2× CPU	0,00001568 $/s
3× CPU	0,00002352 $/s
4× CPU	0,00003136 $/s
5× CPU	0,0000392 $/s
6× CPU	0,00004704 $/s
7× CPU	0,00005488 $/s
8× CPU	0,00006272 $/s

Mémoire

Mémoire	Prix unitaire
Valeurs valides : multiples de 512 MiB, de 512 MiB à 8192 MiB (par GiB / s)	0,00000256 $/GiB/s
512 MiB	0,00000128 $/s
1 GiB	0,00000256 $/s
2 GiB	0,00000512 $/s

Stockage : Chaque compte inclut 60 Go de stockage gratuit. Le stockage supplémentaire est facturé à 0,000072 $/Go/h.

Commencez à créer des agents IA de production dès maintenant

Novita Agent Runtime élimine la complexité d’infrastructure qui ralentit traditionnellement le déploiement d’agents IA. Une infrastructure serverless spécialement conçue, avec des démarrages à froid en moins de 200ms, une isolation complète des sessions et une flexibilité de frameworks, permet aux équipes de développement de se concentrer sur la création de comportements d’agents intelligents plutôt que sur la gestion de l’infrastructure.

Démarrez dès aujourd’hui en installant le SDK et la CLI, puis déployez votre premier agent en quelques minutes. Pour une assistance supplémentaire, rejoignez la communauté Discord Novita AI ou contactez notre équipe commerciale.

À propos de Novita AI

Novita AI est une plateforme cloud IA qui offre aux développeurs un moyen simple de déployer des modèles IA via notre API simple, tout en fournissant un cloud GPU abordable et fiable pour la construction et la mise à l’échelle.