---
title: "Agentes de código em paralelo numa API de LLM de preço fixo"
description: "Subagentes, orquestradores e workers em lote no DeepSeek V4.1 Flash ilimitado: quantas sessões você precisa, como dividir entre chaves e como limitar a concorrência."
url: https://broadrouter.com/pt/blog/run-parallel-coding-agents-flat-rate/
lang: pt-BR
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/run-parallel-coding-agents-flat-rate/) (atualizado em 2026-11-16).

# Como rodar agentes de código em paralelo numa API de LLM de preço fixo

Pela equipe da BroadNet Inference · 5 min de leitura · Publicado em 2026-11-14 · Atualizado em 2026-11-16

Dê a cada agente que trabalha ao mesmo tempo a sua própria sessão do plano. Uma sessão roda uma requisição por vez, sem medidor de tokens, então um orquestrador com três subagentes precisa de quatro sessões. Limite as requisições em andamento no seu próprio código de acordo. Uma chave pode ter várias sessões, e cada sessão Full Moon custa $60 por mês.

## Pontos principais

-   Uma sessão do plano equivale a uma requisição em andamento. Conte os agentes que chamam o modelo no mesmo instante, não o total de agentes.
-   Um orquestrador mais três subagentes rodando juntos precisa de quatro sessões.
-   Chaves de pagamento por uso permitem 4 requisições em andamento e 30 por minuto, o que serve mais para picos do que para carga constante.
-   Agentes passam boa parte do tempo rodando ferramentas, então meça a sobreposição real antes de comprar sessões.
-   Dê a cada agente a sua própria git worktree para que as edições em paralelo não colidam.
-   Teste com uma hora Meteor de $1 por sessão antes de comprar um mês.

**Nesta página**

1.  O que uma sessão de preço fixo cobre?
2.  Quantas sessões os agentes em paralelo precisam?
3.  Quantas sessões cada padrão de agentes precisa?
4.  Como evitar que agentes em paralelo atrapalhem uns aos outros?
5.  Quando o pagamento por uso é melhor para agentes em paralelo?
6.  Como ligar os agentes ao plano?
7.  O que dá errado com agentes em paralelo?
8.  Quanto contexto cada agente pode usar?
9.  Como testar a configuração gastando pouco?
10.  Onde a BroadNet Inference se encaixa

Os frameworks de agentes passaram de um assistente para muitos: um orquestrador que planeja, subagentes que escrevem código, revisam e rodam testes, e workers em lote que processam um backlog. Numa API por token, cada um desses aumenta a conta. Numa [API de preço fixo](https://broadrouter.com/pt/glossary/flat-rate-llm-plan/), a pergunta passa a ser: **quantas coisas estão chamando o modelo no mesmo instante?**

## O que uma sessão de preço fixo cobre?

Os planos ilimitados da BroadNet vendem **sessões**. Uma sessão roda uma requisição por vez, com tokens ilimitados do [DeepSeek V4.1 Flash](https://broadrouter.com/pt/models/deepseek-v4.1-flash/) e sem janela móvel nem teto semanal. Isso bate com o jeito como um agente trabalha: envia uma requisição, lê a resposta, roda uma ferramenta e envia a requisição seguinte.

| Configuração | Requisições em andamento no pico | Sessões |
| --- | --- | --- |
| Um agente de código num terminal | 1 | 1 |
| Orquestrador + 3 subagentes | 4 | 4 |
| 10 workers em lote | 10 | 10 |
| 2 desenvolvedores, 1 agente cada | 2 | 2 (cada um na própria conta) |

Cada sessão Full Moon custa $60 por mês. Uma chave pode ter várias sessões, ou você pode dividir as sessões de um plano entre as chaves dele, por exemplo uma chave por servidor ou por projeto, para que uma chave vazada ou revogada pare só os agentes que dependem dela. Chaves e contas são pessoais: você pode integrar um plano no seu próprio produto, mas não pode compartilhar nem revender a chave. [Regras completas das sessões](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/).

## Quantas sessões os agentes em paralelo precisam?

Os agentes passam muito tempo **sem** chamar o modelo: rodando testes, lendo arquivos, esperando um build. Quatro subagentes que chamam o modelo 40% do tempo cada raramente precisam dele todos de uma vez. Antes de comprar quatro sessões:

1.  Registre o horário de início e de fim de cada requisição ao modelo que o seu framework faz, por agente.
2.  Conte o máximo de requisições que se sobrepõem em cada minuto.
3.  Compre sessões para a sobreposição que você atinge na maior parte do tempo, não para o pico absoluto, e enfileire o resto no seu próprio código (veja o semáforo mais abaixo). As páginas da BroadNet não dizem se uma requisição acima do limite espera ou é recusada, então não deixe os agentes enviarem às cegas.

Por exemplo, se os seus logs mostram duas requisições em andamento quase sempre e quatro só em picos curtos, duas sessões mais uma fila no cliente podem ser a configuração mais barata.

Um script curto faz a contagem. A partir de uma lista de tempos `(start, end)` em segundos tirados dos seus 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}
```

Se o resultado mostrar a maior parte do tempo com uma ou duas requisições em andamento, compre duas sessões. Se ficar em quatro por horas, compre quatro.

## Quantas sessões cada padrão de agentes precisa?

| Padrão | Como chama o modelo | Regra de dimensionamento |
| --- | --- | --- |
| Orquestrador + workers | O planejador chama e depois distribui o trabalho | Os workers que rodam juntos, mais uma para o planejador se ele continuar trabalhando |
| Pipeline (escrever → revisar → testar) | Uma etapa por vez por tarefa | Uma sessão por tarefa rodando em paralelo |
| Backlog em lote | Muitos jobs idênticos | Uma sessão por worker; mais workers terminam antes |
| Agentes de vários desenvolvedores | Independentes | Uma sessão por desenvolvedor, cada um na própria conta |

## Como evitar que agentes em paralelo atrapalhem uns aos outros?

A capacidade do modelo é só metade do problema. Dois agentes editando o mesmo arquivo desfazem o trabalho um do outro. A solução habitual é uma [git worktree](https://git-scm.com/docs/git-worktree) por agente: cada um ganha o próprio checkout e o próprio branch do mesmo repositório.

```bash
git worktree add ../agent-auth -b agent/auth
git worktree add ../agent-billing -b agent/billing
```

Depois divida as tarefas por módulo, para que os agentes raramente mexam nos mesmos arquivos, e faça o merge com uma etapa de revisão. Para rodá-los sem supervisão, veja [execuções noturnas de agentes de código](https://broadrouter.com/pt/blog/overnight-coding-agent-runs/); para o que os agentes extras custam em tokens, veja [o custo de sistemas multiagente](https://broadrouter.com/pt/blog/multi-agent-cost/).

## Quando o pagamento por uso é melhor para agentes em paralelo?

Uma chave de [pagamento por uso](https://broadrouter.com/pt/glossary/pay-as-you-go/) permite 4 requisições em andamento e 30 requisições por minuto. Isso serve para distribuições curtas e com picos: uma etapa de revisão que dispara quatro verificadores por vinte segundos e depois fica quieta. Carga constante combina com sessões, e carga em picos combina com cobrança por token. Muitas configurações usam as duas: sessões do plano para os agentes de longa duração e uma chave de pagamento por uso para picos e para outros modelos, como o [GLM 5.3](https://broadrouter.com/pt/models/glm-5.3/).

Quando uma chave de pagamento por uso atinge o [rate limit](https://broadrouter.com/pt/glossary/rate-limit/) ou o limite de [concorrência](https://broadrouter.com/pt/glossary/concurrency/), ela devolve 429. Espere e tente de novo; veja [códigos de erro e quando repetir](https://broadrouter.com/pt/guides/errors-and-retries/). A [calculadora de rate limit](https://broadrouter.com/tools/llm-rate-limit-calculator/) mostra até onde um limite rende para o seu padrão de requisições.

## Como ligar os agentes ao plano?

A maioria dos frameworks de agentes aceita uma base URL compatível com a OpenAI. Aponte cada agente para `https://inference.broadnet.ai/v1` com o modelo `broadnet/deepseek-v4.1-flash` e dê uma chave a cada um:

```bash
export OPENAI_BASE_URL="https://inference.broadnet.ai/v1"
export OPENAI_API_KEY="$BROADNET_PLAN_KEY"
```

Para um agente de código de terminal, o [guia do Aider](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/) traz as configurações exatas; o [Cline](https://broadrouter.com/pt/guides/cline-openai-compatible/) e o [OpenCode](https://broadrouter.com/pt/guides/opencode-custom-provider/) têm guias próprios. Para o seu próprio orquestrador, o [guia do SDK Python da OpenAI](https://broadrouter.com/pt/guides/openai-python-sdk/) mostra a configuração do cliente. No seu código, limite as requisições em andamento ao número de sessões, para que elas fiquem na fila do seu lado, onde você consegue ver:

```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)
```

## O que dá errado com agentes em paralelo?

-   **Iniciar todos os agentes de uma vez.** Uma rajada de primeiras chamadas simultâneas passa das suas sessões na hora. Escalone os inícios em alguns segundos.
-   **Tempestades de retries.** Se todos os agentes tentam de novo no mesmo instante, eles colidem de novo. Adicione jitter ao backoff.
-   **`max_tokens` pequeno demais.** O DeepSeek V4.1 Flash raciocina antes de responder; um limite pequeno pode devolver uma resposta vazia. [Por quê](https://broadrouter.com/pt/guides/reasoning-tokens-empty-response/).
-   **Compartilhar uma chave entre pessoas.** As chaves são pessoais. Dê a cada desenvolvedor a própria conta.

## Quanto contexto cada agente pode usar?

Cada requisição pode levar até 1.048.576 tokens no DeepSeek V4.1 Flash. Um subagente pode ler o módulo inteiro em que está trabalhando em vez de um resumo cortado, e num plano um prompt longo não custa a mais. [Quando uma janela de 1M de tokens ajuda](https://broadrouter.com/pt/blog/million-token-context-window-guide/).

## Como testar a configuração gastando pouco?

Compre uma hora Meteor ($1) para cada sessão que você acha que precisa e rode o seu fluxo real de agentes. Se os agentes esperarem uns pelos outros com frequência, adicione uma sessão. Se uma ficar ociosa, tire. Depois passe para Full Moon ou para sessões Orbit semanais ($15 cada).

## Onde a BroadNet Inference se encaixa

Sessões do plano servem para agentes constantes e em paralelo num único modelo, porque a conta depende de quantos rodam ao mesmo tempo, não de quanto eles leem. Se os seus agentes precisam de vários modelos diferentes, ou só chamam o modelo em rajadas curtas, uma chave de pagamento por uso ou um roteador pode custar menos. Compare antes com [a conta do ponto de equilíbrio](https://broadrouter.com/pt/blog/flat-rate-vs-pay-per-token-llm-api/).

Ferramentas gratuitas sobre o tema (em inglês)

-   [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.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

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

Um token é a unidade de texto que um modelo de linguagem lê e escreve: uma palavra, parte de uma palavra, um sinal de pontuação ou uma sequência de bytes gerada pelo tokenizador do modelo. As APIs de LLM contam, limitam e normalmente cobram o uso em tokens.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[Rate limit (limite de taxa)](https://broadrouter.com/pt/glossary/rate-limit/)

Um rate limit é um teto que uma API impõe a quanto um cliente pode usá-la em um intervalo de tempo, como requisições por minuto ou tokens por minuto. As requisições acima do limite são recusadas, normalmente com HTTP 429 Too Many Requests, até que o uso volte a ficar abaixo dele.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Subagente (subagent)](https://broadrouter.com/pt/glossary/subagent/)

Um subagente é um agente separado que um agente principal inicia para cuidar de uma tarefa específica. Ele roda com a própria janela de contexto, o próprio system prompt e acesso próprio a ferramentas, faz o trabalho e devolve ao agente principal só um resultado ou resumo, o que mantém a conversa principal pequena.

[Agente de programação com IA (AI coding agent)](https://broadrouter.com/pt/glossary/coding-agent/)

Um agente de programação com IA é uma ferramenta de software em que um modelo de linguagem trabalha numa codebase em ciclo: lê arquivos, edita, roda comandos como os testes, lê a saída e decide o próximo passo até a tarefa terminar ou um limite ser atingido.

[Base URL (URL base)](https://broadrouter.com/pt/glossary/base-url/)

A base URL é o endereço raiz fixo de uma API, como https://api.example.com/v1, que um cliente coloca antes de cada caminho de endpoint, como /chat/completions. Nos SDKs compatíveis com a OpenAI, trocar a base URL, junto com a chave de API e o ID do modelo, aponta o mesmo código para outro provedor.

[Plano de LLM com preço fixo (flat-rate)](https://broadrouter.com/pt/glossary/flat-rate-llm-plan/)

Um plano de LLM com preço fixo cobra um valor fixo por um período, como um mês, pelo acesso à API de um modelo de linguagem, em vez de cobrar por token. Esses planos costumam limitar outra coisa, como simultaneidade, velocidade, modelos ou janelas de uso, então os limites importam tanto quanto o preço.

## Perguntas frequentes

### O que acontece se dois agentes usarem uma sessão ao mesmo tempo?

Uma sessão roda uma requisição por vez, e as páginas da BroadNet não dizem se uma segunda requisição espera ou é recusada com um 429. Não conte com nenhum dos dois: limite no seu código as requisições em andamento ao número de sessões, repita os 429 com backoff e adicione uma sessão se os agentes esperarem demais.

### Quantos agentes de código posso rodar em paralelo?

Tantos quantas forem as sessões para as requisições que se sobrepõem. Cada sessão do plano roda uma requisição por vez, então quatro agentes chamando o modelo no mesmo instante precisam de quatro sessões. Agentes que passam a maior parte do tempo rodando ferramentas podem dividir menos sessões, se o seu código enfileirar as chamadas ao modelo.

### Como evito que agentes em paralelo editem os mesmos arquivos?

Dê a cada agente a sua própria git worktree e o seu próprio branch, e divida o trabalho por arquivo ou módulo. Faça o merge com pull requests normais ou com uma etapa final de revisão.

### Posso combinar um plano com pagamento por uso?

Sim. As chaves de plano e as de pagamento por uso são separadas. Um padrão comum é usar sessões do plano para os agentes constantes e uma chave de pagamento por uso para picos ocasionais ou outros modelos.

### As sessões precisam ficar em chaves separadas?

Não. Uma chave pode ter várias sessões, ou você pode dividi-las entre chaves, por exemplo uma chave por servidor ou por projeto.

### Agentes em paralelo custam mais num plano de preço fixo?

Só pelo número de sessões. Num plano os tokens não são medidos, então a conta é o número de sessões vezes o preço do plano, não importa o que cada agente leia ou escreva.

## Continue lendo

-   [O que "ilimitado" significa de verdade em um plano de API de LLM](https://broadrouter.com/pt/blog/what-unlimited-llm-api-really-means/)
-   [API de LLM com preço fixo ou por token: a conta do ponto de equilíbrio](https://broadrouter.com/pt/blog/flat-rate-vs-pay-per-token-llm-api/)
-   [Quando vale a pena uma janela de contexto de 1M de tokens (ou não)](https://broadrouter.com/pt/blog/million-token-context-window-guide/)
-   [Custo de uma execução de agente de código: passos, contexto e cache](https://broadrouter.com/pt/blog/ai-coding-agent-run-cost/)
-   [Claude Code com modelos abertos: proxies, endpoints nativos e limites](https://broadrouter.com/pt/blog/claude-code-with-openai-compatible-models/)
-   [Guia: Como funcionam os planos de API de LLM ilimitada para agentes](https://broadrouter.com/pt/guides/unlimited-llm-api-sessions/)
-   [Guia: Rode o Aider no DeepSeek V4.1 Flash ilimitado](https://broadrouter.com/pt/guides/aider-unlimited-deepseek/)
-   [Guia: Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)
-   [Guia: Use o Cline com a BroadNet Inference (provedor OpenAI Compatible)](https://broadrouter.com/pt/guides/cline-openai-compatible/)
-   [Guia: Adicionar a BroadNet Inference ao opencode como provedor personalizado](https://broadrouter.com/pt/guides/opencode-custom-provider/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

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

**Fontes**

-   [Planos da BroadNet Inference e FAQ dos planos (conferido em 2026-11-16) (em inglês)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-run-parallel-coding-agents-flat-rate&utm_content=sources)
-   [Referência da API da BroadNet Inference, limites (conferido em 2026-11-16) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-run-parallel-coding-agents-flat-rate&utm_content=sources)
-   [Documentação do Git, git-worktree (conferido em 2026-11-16)](https://git-scm.com/docs/git-worktree)
