Les frameworks d’agents sont passés d’un assistant unique à plusieurs : un orchestrateur qui planifie, des sous-agents qui écrivent du code, le relisent et lancent les tests, et des workers batch qui traitent un backlog. Sur une API facturée au token, chacun alourdit la facture. Sur une API au forfait, la question devient : combien de processus appellent le modèle au même moment ?
Que couvre une session de forfait ?
Les forfaits illimités de BroadNet vendent des sessions. Une session traite une requête à la fois, avec des tokens DeepSeek V4.1 Flash illimités, sans fenêtre glissante ni plafond hebdomadaire. Cela correspond au fonctionnement d’un agent : il envoie une requête, lit la réponse, exécute un outil et envoie la requête suivante.
| Configuration | Requêtes simultanées au pic | Sessions |
|---|---|---|
| Un agent de code dans un terminal | 1 | 1 |
| Orchestrateur + 3 sous-agents | 4 | 4 |
| 10 workers batch | 10 | 10 |
| 2 développeurs, 1 agent chacun | 2 | 2 (chacun sur son propre compte) |
Chaque session Full Moon coûte $60 par mois. Une clé peut regrouper plusieurs sessions, ou vous pouvez répartir les sessions d’un forfait entre ses clés, par exemple une clé par serveur ou par projet : une clé divulguée ou révoquée n’arrête alors que les agents qui l’utilisent. Les clés et les comptes sont personnels : vous pouvez intégrer un forfait dans votre propre produit, mais pas partager ni revendre la clé. Toutes les règles des sessions.
Combien de sessions faut-il pour des agents en parallèle ?
Les agents passent beaucoup de temps sans appeler le modèle : ils lancent des tests, lisent des fichiers, attendent un build. Quatre sous-agents qui appellent chacun le modèle 40 % du temps en ont rarement besoin tous en même temps. Avant d’acheter quatre sessions :
- Journalisez l’heure de début et de fin de chaque requête au modèle émise par votre framework, par agent.
- Comptez le nombre maximal de requêtes qui se chevauchent dans chaque minute.
- Achetez des sessions pour le chevauchement que vous atteignez la plupart du temps, pas pour le pic absolu, et mettez le reste en file d’attente dans votre propre code (voir le sémaphore plus bas). Les pages de BroadNet ne disent pas si une requête au-delà de la limite attend ou est refusée : ne laissez donc pas les agents l’envoyer à l’aveugle.
Par exemple, si vos logs montrent deux requêtes simultanées la plupart du temps et quatre seulement lors de brefs pics, deux sessions plus une file d’attente côté client peuvent être la configuration la moins chère.
Un court script fait le décompte. À partir d’une liste de temps (start, end) en secondes tirée de vos logs :
from collections import Counter
def overlap_histogram(requests):
events = sorted([(s, 1) for s, _ in requests] + [(e, -1) for _, e in requests])
in_flight, last_t, seconds_at = 0, None, Counter()
for t, delta in events:
if last_t is not None:
seconds_at[in_flight] += t - last_t
in_flight += delta
last_t = t
return dict(sorted(seconds_at.items())) # {requests in flight: seconds}
Si le résultat montre que l’essentiel du temps se passe à une ou deux requêtes simultanées, achetez deux sessions. S’il reste à quatre pendant des heures, achetez-en quatre.
Combien de sessions pour chaque schéma d’agents ?
| Schéma | Comment il appelle le modèle | Règle de dimensionnement |
|---|---|---|
| Orchestrateur + workers | Le planificateur appelle, puis répartit | Les workers qui tournent ensemble, plus une pour le planificateur s’il continue à travailler |
| Pipeline (écrire → relire → tester) | Une étape à la fois par tâche | Une session par tâche exécutée en parallèle |
| Backlog en batch | Beaucoup de jobs identiques | Une session par worker ; plus de workers finissent plus tôt |
| Agents de plusieurs développeurs | Indépendants | Une session par développeur, chacun sur son propre compte |
Comment éviter que des agents parallèles se gênent ?
La capacité du modèle n’est que la moitié du problème. Deux agents qui modifient le même fichier défont mutuellement leur travail. La solution habituelle est un worktree git par agent : chacun reçoit son propre checkout et sa propre branche à partir du même dépôt.
git worktree add ../agent-auth -b agent/auth
git worktree add ../agent-billing -b agent/billing
Répartissez ensuite les tâches par module, pour que les agents touchent rarement les mêmes fichiers, et fusionnez via une étape de revue. Pour les faire tourner sans surveillance, voir exécutions nocturnes d’agents de code ; pour ce que coûtent les agents supplémentaires en tokens, voir le coût des systèmes multi-agents.
Quand le paiement à l’usage est-il préférable pour des agents en parallèle ?
Une clé en paiement à l’usage autorise 4 requêtes simultanées et 30 requêtes par minute. Cela convient à une répartition courte et irrégulière : une étape de revue qui lance quatre vérificateurs pendant vingt secondes, puis se tait. La charge régulière convient aux sessions, la charge en pics à la facturation au token. Beaucoup de configurations combinent les deux : des sessions de forfait pour les agents de longue durée et une clé en paiement à l’usage pour les pics et pour d’autres modèles comme GLM 5.3.
Quand une clé en paiement à l’usage atteint sa limite de débit ou sa limite de simultanéité, elle renvoie un 429. Attendez avec backoff et relancez ; voir codes d’erreur et quand relancer. Le calculateur de limites de débit montre jusqu’où une limite donnée tient pour votre profil de requêtes.
Comment brancher les agents sur le forfait ?
La plupart des frameworks d’agents acceptent une URL de base compatible OpenAI. Pointez chaque agent vers https://inference.broadnet.ai/v1 avec le modèle broadnet/deepseek-v4.1-flash et donnez une clé à chacun :
export OPENAI_BASE_URL="https://inference.broadnet.ai/v1"
export OPENAI_API_KEY="$BROADNET_PLAN_KEY"
Pour un seul agent de code en terminal, le guide Aider donne les réglages exacts ; Cline et OpenCode ont leurs propres guides. Pour votre propre orchestrateur, le guide du SDK Python d’OpenAI montre la configuration du client. Dans votre code, limitez les requêtes simultanées au nombre de sessions pour qu’elles patientent de votre côté, là où vous pouvez le voir :
import asyncio
SESSIONS = 4
gate = asyncio.Semaphore(SESSIONS)
async def ask(client, messages):
async with gate:
return await client.chat.completions.create(
model="broadnet/deepseek-v4.1-flash", messages=messages, max_tokens=4000)
Qu’est-ce qui coince avec des agents en parallèle ?
- Démarrer tous les agents d’un coup. Une rafale de premiers appels simultanés dépasse immédiatement vos sessions. Échelonnez les démarrages de quelques secondes.
- Tempêtes de retries. Si tous les agents relancent au même moment, ils entrent de nouveau en collision. Ajoutez du jitter au backoff.
- Un
max_tokenstrop bas. DeepSeek V4.1 Flash raisonne avant de répondre ; une petite limite peut renvoyer une réponse vide. Pourquoi. - Partager une clé entre plusieurs personnes. Les clés sont personnelles. Donnez à chaque développeur son propre compte.
Quelle quantité de contexte chaque agent peut-il utiliser ?
Chaque requête peut contenir jusqu’à 1 048 576 tokens sur DeepSeek V4.1 Flash. Un sous-agent peut lire tout le module sur lequel il travaille plutôt qu’un résumé élagué, et sur un forfait, un long prompt ne coûte rien de plus. Quand une fenêtre de 1M de tokens est utile.
Comment tester la configuration à moindre coût ?
Achetez une heure Meteor ($1) par session dont vous pensez avoir besoin, et faites tourner votre vrai workflow d’agents. Si les agents s’attendent trop souvent, ajoutez une session. Si l’une reste inactive, retirez-la. Passez ensuite à Full Moon ou à des sessions Orbit d’une semaine ($15 chacune).
La place de BroadNet Inference
Les sessions de forfait conviennent à des agents réguliers, en parallèle, sur un seul modèle, car la facture dépend du nombre d’agents qui tournent en même temps, pas de ce qu’ils lisent. Si vos agents ont besoin de plusieurs modèles différents, ou n’appellent le modèle que par courtes rafales, une clé en paiement à l’usage ou un routeur peut coûter moins cher. Comparez d’abord avec le calcul du seuil de rentabilité.
