Monthly Bill for a 10-Agent Research Runner, Line by Line

Where does the budget actually go when a multi-agent research runner is deployed at steady state? The LLM bill does not dominate on its own, despite what buyers approving the project tend to expect. Proxy bandwidth, SERP calls, vector storage, observability traces, and the orchestration overhead of agents re-reading each other's context add up to the same order of magnitude as the model spend, and sometimes more.

This is a line-item model for a ten-agent research runner handling a technology, finance, or healthcare workload at steady state: around 20,000 agent tasks a month, mixed between SEC EDGAR extraction, competitor monitoring, citation checking, and freeform market research. The point is not a single invoice total. It is which three or four levers actually move the number when finance pushes back.

The Workload Being Priced

Assume ten specialized agents, each handling roughly 2,000 tasks per month. A task is one bounded research unit: pull a filing and summarize it, verify a claim against three sources, map a competitor's pricing page across regions. Average retrieval depth is six to twelve web fetches per task plus two to four SERP calls, with results committed to a GitHub repo for versioning.

Token consumption is where most cost models underprice reality. Agentic workflows consume 5 to 30 times more tokens per task than standard chat interactions, with multi-agent architectures compounding costs an additional 3 to 10 times beyond initial projections. The compounding comes from agents re-consuming each other's context, which is why input tokens, not output, drive the bill. A study of code-review-heavy multi-agent systems found input tokens make up 53.9% of total usage, a roughly 2:1 input-to-output ratio reflecting a significant communication tax as agents re-consume context.

Variance is the second underpriced reality. An empirical study of eight frontier LLMs on SWE-bench Verified found runs on the same task can differ by up to 30 times in total token usage. A monthly bill built on the median will understate the 90th-percentile month.

The Line Items, Priced

The bill below assumes BYOK across providers, mid-tier proxy mix, a managed vector database, and one of the mainstream observability tools. Numbers are mid-case for 20,000 tasks per month.

Line Item	Mid-Case Monthly	Primary Driver	Variance Range
LLM tokens (BYOK, mixed routing)	$8,400	Per-agent model choice	4× to 10×
Proxy bandwidth (residential + DC mix)	$3,200	Fetch payload size	2× to 4×
SERP API calls (~60K/mo)	$450	Vendor tier	Up to 80×
Vector DB (storage + queries)	$280	Chunk count per task	1.5× to 2×
Embeddings generation	$180	Re-embedding cadence	1× to 3×
Observability / tracing	$320	Trace retention tier	2× to 5×
Egress + GitHub App infra	$160	Commit frequency	1× to 2×
Orchestration compute (runner host)	$420	Concurrency ceiling	1.5× to 3×
Mid-case total	$13,410

Three things to notice before arguing with any individual row. First, the LLM line is only about a third of the total once routing is sane. Second, SERP and proxy bandwidth together rival the model spend. Third, the orchestration overhead — observability, GitHub API quota headroom, egress — is not rounding error. It is the row most procurement reviewers miss.

LLM Tokens Are a Routing Problem, Not a Model Problem

At 20,000 tasks a month, model choice per agent decides whether the LLM row lands at $4K or $35K. A benchmark of 500 agent runs across five tasks in April 2026 found median cost per task ranged from $0.026 for GPT-5-mini to $0.241 for Claude Sonnet 4.5, a 9.3× spread for workloads that looked identical from outside the agent. Token usage was consistent across models; the price was not.

Two levers compress this row materially. The first is per-agent routing: cheap models for extraction and classification, premium models for synthesis and citation reasoning. The routing math across GPT-5, Claude, and Gemini is covered separately; the point for this bill is that uniform model selection is the single largest controllable variance.

The second lever is prompt caching. A comprehensive evaluation of prompt caching across OpenAI, Anthropic, and Google on DeepResearch Bench, spanning 500 agent sessions with 10,000-token system prompts, found statistically significant cost reductions on every model tested, with savings ranging from 41% to 80% across providers. For a research runner where the same agent definitions and tool schemas get re-sent on every call, caching is the difference between a $12K and a $4K LLM month.

Proxy Bandwidth and SERP Calls Are the Hidden Half

The web extraction layer is where most buyers underestimate steady-state cost. At 20,000 tasks with six to twelve fetches each, the runner issues roughly 150,000 to 240,000 outbound requests a month, split across residential, datacenter, and mobile IP pools depending on target difficulty. Residential bandwidth is typically billed per GB, and heavy JavaScript targets inflate payload size well past the HTML the agent actually needs.

SERP pricing is the most volatile row on the bill. Google SERP API pricing varies by more than 80× for the same workload: Serper runs $1.00 down to $0.30 per 1,000 queries on prepaid packs, while SerpApi lists $25 per 1,000 at entry tier and $5.90 per 1,000 at volume; at 1 million queries per month, Zyte costs around $430 while SerpApi runs about $25,000. A ten-agent runner will not hit a million queries, but at 60,000 SERP calls a month the vendor choice still swings the row from under $20 to several hundred dollars.

Two operational notes matter here. Signing a proxy contract without reading the SLA clauses that actually matter tends to produce surprise bills around month three, when success-rate guarantees stop applying to the specific target classes the runner relies on. And bandwidth-based billing penalizes agents that fetch full pages when a targeted selector would do; shrinking fetched payloads is often a 30 to 50 percent reduction on this row alone.

Vector Storage, Observability, and the Rows Finance Will Ask About

Vector storage is modest for this workload. Twenty thousand tasks a month with retrieved context averaging 20 chunks each lands around 400,000 new vectors monthly. At 1536-dimension embeddings and typical managed-DB pricing, storage plus query cost sits in the low hundreds. Embedding generation is usually cheaper than the retrieval queries themselves.

Observability is a row buyers often skip in planning and regret in month two. LangSmith's Developer tier is free up to 5,000 base traces per month, with Plus at $39 per seat per month including 10,000 traces plus pay-as-you-go overages, while Helicone Pro runs $79/month and Team $799/month with SOC-2 and HIPAA. A ten-agent runner at 20,000 tasks generates well over 100,000 traces monthly once tool calls and sub-agent spans are counted, which pushes most teams onto a paid tier with overage.

GitHub API quota is the orchestration row no one models until it breaks a run. GitHub's REST API caps authenticated requests at 5,000 per hour per user, with unauthenticated requests limited to just 60 per hour per IP; GitHub App installations on Enterprise Cloud organizations receive a higher ceiling of 15,000 requests per hour. A runner that commits versioned results after every task will saturate the user token within a few agents running in parallel. The fix is a GitHub App, which costs engineering time, not dollars, but belongs on the line-item list because it is a precondition for the runner to actually hit its throughput target.

Which Levers Actually Change the Invoice

A finance partner reviewing this bill will ask the same question regardless of total: what controls the number. There are four levers, and they are not equally powerful.

• Per-agent model routing. The largest single controllable variance. Running every agent on a flagship model is the fastest way to a six-figure monthly bill at this task volume.
• Prompt caching discipline. Stable system prompts, stable tool schemas, cache headers set correctly. Documented savings fall in a 41 to 80 percent band on the LLM row.
• Proxy and SERP vendor selection. An 80× price range exists for essentially the same output. Negotiating prepaid tiers and matching IP class to target difficulty is where the extraction row is won or lost.
• Fetch payload shrinkage. Selector-based extraction over full-page rendering reduces residential bandwidth meaningfully and shortens the input token tail downstream.

Vector storage, observability tier, and egress are real line items, but they are not where a procurement conversation should spend its time. They sum to a predictable floor; the four levers above are where the invoice variance lives.

How The Numbers Evolve Over A Year

Steady state is not a flat line. The first three months of a runner's life are dominated by schema churn, re-crawls, and prompt iteration, which inflates both token and bandwidth rows. The levers above only start to compound once agent definitions stabilize and caching hit rates climb above roughly 60 percent.

What To Hand Finance

A defensible monthly cost model for a ten-agent research runner is not one number. It is a mid-case total, a 90th-percentile ceiling that accounts for the 30× single-task variance observed in agentic workloads, and a short list of the levers that move the distance between them. The infrastructure under the model, including proxies, SERP, vector DB, observability, and GitHub quota, is roughly as expensive as the model itself and roughly as controllable, provided it is itemized rather than lumped into a single "infra" row.

The build-versus-buy framing and the platform pricing page cover the procurement side of this decision. For a technical walkthrough of how the pipeline fits together before signing anything, the how-it-works breakdown is the shortest path to a model finance will accept.