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:
- I-log ang oras ng simula at pagtatapos ng bawat model request na ginagawa ng framework mo, kada agent.
- Bilangin ang pinakamaraming request na nagsasabay sa bawat minuto.
- 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.
