BroadRouter
Magsimula

Paano magpatakbo ng sabay-sabay na coding agent sa flat-rate LLM API

Ng BroadNet Inference team · 5 minutong basa · Nailathala · Na-update

Bigyan ng sariling plan session ang bawat agent na sabay na nagtatrabaho. Isang request lang sa isang pagkakataon ang tinatakbo ng session, walang token meter, kaya apat na session ang kailangan ng orchestrator na may tatlong sub-agent. Limitahan ang mga request na sabay na tumatakbo sa sarili mong code para tumugma. Puwedeng maglaman ng ilang session ang isang key, at $60 kada buwan ang bawat session sa Full Moon.

Lumipat na ang mga agent framework mula sa iisang assistant papunta sa marami: orchestrator na nagpaplano, mga sub-agent na nagsusulat ng code, nire-review ito at nagpapatakbo ng test, at mga batch worker na nagpoproseso ng backlog. Sa per-token na API, dagdag sa bill ang bawat isa niyan. Sa flat-rate API, ito na ang tanong: ilan ang tumatawag sa model sa iisang sandali?

Ano ang sakop ng isang flat-rate session?

Nagbebenta ng session ang mga unlimited plan ng BroadNet. Isang request sa isang pagkakataon ang tinatakbo ng session, may unlimited na token ng DeepSeek V4.1 Flash at walang rolling window o lingguhang cap. Tugma iyan sa paraan ng pagtatrabaho ng isang agent: nagpapadala ito ng request, binabasa ang sagot, nagpapatakbo ng tool, at ipinapadala ang susunod na request.

Setup Sabay na request sa peak Session
Isang coding agent sa isang terminal 1 1
Orchestrator + 3 sub-agent 4 4
10 batch worker 10 10
2 developer, tig-1 agent 2 2 (bawat isa sa sariling account)

$60 kada buwan ang bawat Full Moon session. Puwedeng maglaman ng ilang session ang isang key, o puwede mong hatiin ang mga session ng isang plan sa mga key nito, halimbawa isang key kada server o kada proyekto, para ang mga agent lang sa likod ng na-leak o na-revoke na key ang titigil. Personal ang mga key at account: puwede mong isama ang plan sa sarili mong produkto, pero hindi mo puwedeng ibahagi o i-resell ang key. Buong patakaran ng session.

Ilang session ang kailangan ng sabay-sabay na agent?

Malaking oras ng agent ang hindi ginugugol sa pagtawag sa model: pagpapatakbo ng test, pagbabasa ng file, paghihintay sa build. Ang apat na sub-agent na tumatawag sa model nang 40% ng oras ay bihirang mangailangan nito nang sabay-sabay. Bago bumili ng apat na session:

  1. I-log ang oras ng simula at pagtatapos ng bawat model request na ginagawa ng framework mo, kada agent.
  2. Bilangin ang pinakamaraming request na nagsasabay sa bawat minuto.
  3. Bumili ng session para sa overlap na naaabot mo sa karamihan ng oras, hindi para sa pinakamataas na peak, at ipila ang iba sa sarili mong code (tingnan ang semaphore sa ibaba). Hindi sinasabi ng mga page ng BroadNet kung maghihintay o tatanggihan ang request na lampas sa limit, kaya huwag hayaang ipadala ito ng mga agent nang bulag.

Halimbawa, kung ipinapakita ng log mo na dalawang request ang sabay na tumatakbo sa karamihan ng oras at apat lang sa maiikling dagsa, puwedeng mas mura ang dalawang session at isang queue sa client side.

Kaya ng maikling script ang pagbibilang. Mula sa listahan ng (start, end) na oras sa segundo galing sa log mo:

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}

Kung ipinapakita ng resulta na isa o dalawang sabay na request ang karamihan ng oras, bumili ng dalawang session. Kung nasa apat ito nang ilang oras, bumili ng apat.

Ilang session ang kailangan ng bawat pattern ng agent?

Pattern Paano ito tumatawag sa model Patakaran sa laki
Orchestrator + worker Tumatawag ang planner, saka nagpa-fan out Mga worker na sabay tumatakbo, dagdag ang isa para sa planner kung patuloy itong nagtatrabaho
Pipeline (sulat → review → test) Isang stage sa isang pagkakataon kada task Isang session kada task na sabay na tumatakbo
Batch na backlog Maraming magkakaparehong job Isang session kada worker; mas maraming worker, mas mabilis matapos
Mga agent ng ilang developer Hiwa-hiwalay Isang session kada developer, bawat isa sa sariling account

Paano mo pipigilang magbanggaan ang sabay-sabay na agent?

Kalahati lang ng problema ang capacity ng model. Babawiin ng dalawang agent na nag-e-edit ng parehong file ang trabaho ng isa’t isa. Ang karaniwang solusyon ay isang git worktree kada agent: may sariling checkout at branch ang bawat isa mula sa parehong repository.

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

Pagkatapos, hatiin ang mga task ayon sa module, para bihirang humawak ang mga agent sa parehong file, at mag-merge sa pamamagitan ng hakbang ng review. Para sa pagpapatakbo sa kanila nang walang bantay, tingnan ang magdamagang run ng coding agent; para sa gastos sa token ng mga dagdag na agent, tingnan ang gastos ng multi-agent.

Kailan mas mainam ang pay-as-you-go para sa sabay-sabay na agent?

Pinapayagan ng pay-as-you-go na key ang 4 request na sabay na tumatakbo at 30 request kada minuto. Bagay iyan sa maikli at biglaang fan-out: isang hakbang ng review na naglalabas ng apat na checker nang dalawampung segundo, saka tumatahimik. Bagay sa session ang tuloy-tuloy na load, at bagay sa per-token na billing ang biglaang load. Marami ang gumagamit ng pareho: plan session para sa mga agent na matagal tumatakbo at pay-as-you-go na key para sa mga dagsa at sa ibang model gaya ng GLM 5.3.

Kapag naabot ng pay-as-you-go na key ang rate limit o concurrency limit nito, nagbabalik ito ng 429. Mag-back off at mag-retry; tingnan ang mga error code at kailan dapat mag-retry. Ipinapakita ng rate limit calculator kung gaano kalayo ang aabutin ng isang limit para sa pattern ng request mo.

Paano ikonekta ang mga agent sa plan?

Tumatanggap ng OpenAI-compatible na base URL ang karamihan ng agent framework. Ituro ang bawat agent sa https://inference.broadnet.ai/v1 na may model na broadnet/deepseek-v4.1-flash at bigyan ng key ang bawat isa:

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

Para sa isang coding agent sa terminal, nasa guide para sa Aider ang eksaktong setting; may sariling guide ang Cline at OpenCode. Para sa sarili mong orchestrator, ipinapakita ng guide sa OpenAI Python SDK ang setup ng client. Sa sarili mong code, limitahan ang sabay na request ayon sa bilang ng session para pumila sila sa panig mo, kung saan nakikita mo ito:

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)

Ano ang kadalasang nagkakamali sa sabay-sabay na agent?

  • Sabay-sabay na pagsisimula ng lahat ng agent. Lalampas agad sa mga session mo ang dagsa ng sabay-sabay na unang tawag. Pag-agwatin ang simula nang ilang segundo.
  • Retry storm. Kung sabay-sabay na nagre-retry ang bawat agent, magbabanggaan ulit sila. Magdagdag ng jitter sa backoff.
  • Masyadong maliit na max_tokens. Nagre-reason muna ang DeepSeek V4.1 Flash bago sumagot; puwedeng walang laman ang sagot kapag maliit ang limit. Bakit.
  • Iisang key para sa ilang tao. Personal ang mga key. Bigyan ng sariling account ang bawat developer.

Gaano karaming context ang magagamit ng bawat agent?

Puwedeng magdala ng hanggang 1,048,576 token ang bawat request sa DeepSeek V4.1 Flash. Mababasa ng sub-agent ang buong module na tinatrabaho nito sa halip na pinaikling buod, at sa plan, walang dagdag na gastos ang mahabang prompt. Kailan nakakatulong ang 1M-token na window.

Paano subukan ang setup nang mura?

Bumili ng isang oras na Meteor ($1) kada session na sa tingin mo ay kailangan mo, at patakbuhin ang totoong agent workflow mo. Kung masyadong madalas naghihintayan ang mga agent, magdagdag ng session. Kung may nakatengga, alisin ito. Saka lumipat sa Full Moon o sa isang linggong Orbit session ($15 bawat isa).

Saan pumapasok ang BroadNet Inference

Bagay ang plan session sa tuloy-tuloy at sabay-sabay na agent sa iisang model, dahil nakadepende ang bill sa kung ilan ang sabay na tumatakbo, hindi sa kung gaano karami ang binabasa nila. Kung kailangan ng mga agent mo ng ilang magkakaibang model, o tumatawag lang sila sa model sa maiikling dagsa, puwedeng mas mura ang pay-as-you-go na key o isang router. Ikumpara muna sa math ng break-even.

Mga tanong

Ano ang mangyayari kung sabay na gumamit ng iisang session ang dalawang agent?

Isang request lang sa isang pagkakataon ang tinatakbo ng session, at hindi sinasabi ng mga page ng BroadNet kung maghihintay ang pangalawang request o tatanggihan ito ng 429. Huwag umasa sa alinman: limitahan sa sarili mong code ang sabay na request ayon sa bilang ng session mo, i-retry ang 429 nang may backoff, at magdagdag ng session kung masyadong matagal maghintay ang mga agent.

Ilang coding agent ang puwede kong patakbuhin nang sabay?

Kasing dami ng session mo para sa mga request na nagsasabay. Isang request sa isang pagkakataon ang tinatakbo ng bawat plan session, kaya apat na session ang kailangan ng apat na agent na sabay na tumatawag sa model. Puwedeng maghati sa mas kaunting session ang mga agent na kadalasang nagpapatakbo ng tools kung pinapila ng code mo ang mga tawag nila sa model.

Paano ko pipigilan ang sabay-sabay na agent na mag-edit ng parehong file?

Bigyan ang bawat agent ng sariling git worktree at branch, at hatiin ang trabaho ayon sa file o module. Mag-merge sa pamamagitan ng normal na pull request o huling hakbang ng review.

Puwede ko bang pagsamahin ang plan at pay-as-you-go?

Oo. Magkahiwalay ang plan key at pay-as-you-go na key. Karaniwang pattern ang plan session para sa mga tuloy-tuloy na agent at pay-as-you-go na key para sa paminsan-minsang dagsa o ibang model.

Kailangan bang nasa magkakahiwalay na key ang mga session?

Hindi. Puwedeng maglaman ng ilang session ang isang key, o puwede mo silang hatiin sa mga key, halimbawa isang key kada server o kada proyekto.

Mas mahal ba ang sabay-sabay na agent sa flat-rate plan?

Ayon lang sa bilang ng session. Hindi mine-meter ang token sa plan, kaya ang bill ay bilang ng session na pinarami sa presyo ng plan, kahit gaano karami ang binabasa o isinusulat ng bawat agent.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity