---
title: "Agents de code en parallèle sur une API LLM au forfait"
description: "Sous-agents, orchestrateurs et workers batch sur DeepSeek V4.1 Flash illimité : combien de sessions, comment les répartir entre clés, limiter le chevauchement."
url: https://broadrouter.com/fr/blog/run-parallel-coding-agents-flat-rate/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/run-parallel-coding-agents-flat-rate/) (mis à jour le 2026-11-16).

# Lancer des agents de code en parallèle sur une API LLM au forfait

Par l’équipe BroadNet Inference · 5 min de lecture · Publié 2026-11-14 · Mis à jour 2026-11-16

Donnez à chaque agent qui travaille en même temps sa propre session de forfait. Une session traite une requête à la fois, sans compteur de tokens : un orchestrateur avec trois sous-agents a donc besoin de quatre sessions. Limitez en conséquence les requêtes simultanées dans votre propre code. Une clé peut regrouper plusieurs sessions, et chaque session Full Moon coûte $60 par mois.

## À retenir

-   Une session de forfait correspond à une requête en cours. Comptez les agents qui appellent le modèle au même moment, pas le total des agents.
-   Un orchestrateur plus trois sous-agents qui tournent ensemble ont besoin de quatre sessions.
-   Les clés en paiement à l’usage autorisent 4 requêtes simultanées et 30 par minute, ce qui convient mieux aux pics qu’à une charge régulière.
-   Les agents passent beaucoup de temps à exécuter des outils : mesurez le chevauchement réel avant d’acheter des sessions.
-   Donnez à chaque agent son propre worktree git pour que les modifications parallèles n’entrent pas en collision.
-   Testez avec une heure Meteor à $1 par session avant d’acheter un mois.

**Sur cette page**

1.  Que couvre une session de forfait ?
2.  Combien de sessions faut-il pour des agents en parallèle ?
3.  Combien de sessions pour chaque schéma d’agents ?
4.  Comment éviter que des agents parallèles se gênent ?
5.  Quand le paiement à l’usage est-il préférable pour des agents en parallèle ?
6.  Comment brancher les agents sur le forfait ?
7.  Qu’est-ce qui coince avec des agents en parallèle ?
8.  Quelle quantité de contexte chaque agent peut-il utiliser ?
9.  Comment tester la configuration à moindre coût ?
10.  La place de BroadNet Inference

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](https://broadrouter.com/fr/glossary/flat-rate-llm-plan/), 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](https://broadrouter.com/fr/models/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](https://broadrouter.com/fr/guides/unlimited-llm-api-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 :

1.  Journalisez l’heure de début et de fin de chaque requête au modèle émise par votre framework, par agent.
2.  Comptez le nombre maximal de requêtes qui se chevauchent dans chaque minute.
3.  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 :

```python
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](https://git-scm.com/docs/git-worktree) par agent : chacun reçoit son propre checkout et sa propre branche à partir du même dépôt.

```bash
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](https://broadrouter.com/fr/blog/overnight-coding-agent-runs/) ; pour ce que coûtent les agents supplémentaires en tokens, voir [le coût des systèmes multi-agents](https://broadrouter.com/fr/blog/multi-agent-cost/).

## Quand le paiement à l’usage est-il préférable pour des agents en parallèle ?

Une clé en [paiement à l’usage](https://broadrouter.com/fr/glossary/pay-as-you-go/) 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](https://broadrouter.com/fr/models/glm-5.3/).

Quand une clé en paiement à l’usage atteint sa [limite de débit](https://broadrouter.com/fr/glossary/rate-limit/) ou sa limite de [simultanéité](https://broadrouter.com/fr/glossary/concurrency/), elle renvoie un 429. Attendez avec backoff et relancez ; voir [codes d’erreur et quand relancer](https://broadrouter.com/fr/guides/errors-and-retries/). Le [calculateur de limites de débit](https://broadrouter.com/tools/llm-rate-limit-calculator/) 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 :

```bash
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](https://broadrouter.com/fr/guides/aider-unlimited-deepseek/) donne les réglages exacts ; [Cline](https://broadrouter.com/fr/guides/cline-openai-compatible/) et [OpenCode](https://broadrouter.com/fr/guides/opencode-custom-provider/) ont leurs propres guides. Pour votre propre orchestrateur, le [guide du SDK Python d’OpenAI](https://broadrouter.com/fr/guides/openai-python-sdk/) 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 :

```python
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_tokens` trop bas.** DeepSeek V4.1 Flash raisonne avant de répondre ; une petite limite peut renvoyer une réponse vide. [Pourquoi](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **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](https://broadrouter.com/fr/blog/million-token-context-window-guide/).

## 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é](https://broadrouter.com/fr/blog/flat-rate-vs-pay-per-token-llm-api/).

Outils gratuits sur ce sujet (en anglais)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

[Token](https://broadrouter.com/fr/glossary/token/)

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[Sous-agent (subagent)](https://broadrouter.com/fr/glossary/subagent/)

Un sous-agent est un agent distinct que l’agent principal lance pour traiter une tâche ciblée. Il s’exécute avec sa propre fenêtre de contexte, son prompt système et ses accès aux outils, fait le travail et ne renvoie qu’un résultat ou un résumé à l’agent principal, ce qui garde la conversation principale légère.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Agent de code IA (AI coding agent)](https://broadrouter.com/fr/glossary/coding-agent/)

Un agent de code IA est un outil logiciel dans lequel un modèle de langage travaille en boucle sur une base de code : il lit des fichiers, les modifie, lance des commandes comme les tests, lit la sortie et décide de l’étape suivante jusqu’à ce que la tâche soit terminée ou qu’une limite soit atteinte.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

[Système multi-agents (multi-agent system)](https://broadrouter.com/fr/glossary/multi-agent-system/)

Un système multi-agents est une application LLM dans laquelle plusieurs agents, chacun avec son prompt, ses outils et son contexte, traitent les parties d’une même tâche. Un schéma courant est orchestrateur-workers : un agent principal planifie, lance des agents workers en parallèle et combine leurs résultats.

## Questions fréquentes

### Que se passe-t-il si deux agents utilisent une session en même temps ?

Une session traite une requête à la fois, et les pages de BroadNet ne disent pas si une deuxième requête attend ou est refusée avec un 429. Ne comptez sur aucun des deux : limitez dans votre code les requêtes simultanées au nombre de sessions, relancez les 429 avec backoff, et ajoutez une session si les agents attendent trop.

### Combien d’agents de code puis-je faire tourner en parallèle ?

Autant que vous avez de sessions pour les requêtes qui se chevauchent. Chaque session de forfait traite une requête à la fois : quatre agents qui appellent le modèle au même moment ont besoin de quatre sessions. Des agents qui exécutent surtout des outils peuvent se partager moins de sessions si votre code met leurs appels au modèle en file d’attente.

### Comment empêcher des agents parallèles de modifier les mêmes fichiers ?

Donnez à chaque agent son propre worktree git et sa propre branche, et répartissez le travail par fichier ou par module. Fusionnez via des pull requests classiques ou une étape de revue finale.

### Puis-je combiner un forfait et le paiement à l’usage ?

Oui. Les clés de forfait et les clés en paiement à l’usage sont distinctes. Un schéma courant : des sessions de forfait pour les agents à charge régulière et une clé en paiement à l’usage pour les pics occasionnels ou d’autres modèles.

### Les sessions doivent-elles être sur des clés séparées ?

Non. Une clé peut regrouper plusieurs sessions, ou vous pouvez les répartir entre plusieurs clés, par exemple une clé par serveur ou par projet.

### Des agents en parallèle coûtent-ils plus cher avec un forfait ?

Seulement en nombre de sessions. Les tokens ne sont pas comptés sur un forfait : la facture est le nombre de sessions multiplié par le prix du forfait, quoi que chaque agent lise ou écrive.

## À lire ensuite

-   [Ce que « illimité » veut vraiment dire dans un forfait d’API LLM](https://broadrouter.com/fr/blog/what-unlimited-llm-api-really-means/)
-   [API LLM : forfait ou paiement au token ? Le calcul de rentabilité](https://broadrouter.com/fr/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Quand une fenêtre de contexte de 1M de tokens vaut le coup (ou pas)](https://broadrouter.com/fr/blog/million-token-context-window-guide/)
-   [Coût d’une exécution d’agent de code IA : étapes, contexte, cache](https://broadrouter.com/fr/blog/ai-coding-agent-run-cost/)
-   [Claude Code et modèles ouverts : proxys, endpoints natifs, limites](https://broadrouter.com/fr/blog/claude-code-with-openai-compatible-models/)
-   [Guide : Comment fonctionnent les forfaits API LLM illimités pour agents](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/)
-   [Guide : Faire tourner Aider sur DeepSeek V4.1 Flash en illimité](https://broadrouter.com/fr/guides/aider-unlimited-deepseek/)
-   [Guide : Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [Guide : Utiliser Cline avec BroadNet Inference (fournisseur OpenAI Compatible)](https://broadrouter.com/fr/guides/cline-openai-compatible/)
-   [Guide : Ajouter BroadNet Inference à opencode comme fournisseur personnalisé](https://broadrouter.com/fr/guides/opencode-custom-provider/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

[Commencer](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-run-parallel-coding-agents-flat-rate&utm_content=page-cta) ·

**Sources**

-   [Forfaits et FAQ des forfaits de BroadNet Inference (vérifiés le 2026-11-16) (en anglais)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-run-parallel-coding-agents-flat-rate&utm_content=sources)
-   [Référence de l’API de BroadNet Inference, limites (vérifiée le 2026-11-16) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-run-parallel-coding-agents-flat-rate&utm_content=sources)
-   [Documentation de Git, git-worktree (vérifiée le 2026-11-16)](https://git-scm.com/docs/git-worktree)
