Every team running agents at scale eventually finds the same line item at the top of the bill and the same knob next to it: the Batch API. Submit your requests as a file, accept processing anytime within a 24-hour window, and pay half. On OpenAI's pricing tiers it's the Batch tier; Anthropic's Message Batches API offers the same roughly-50% cut on the same 24-hour terms. For most workloads it is the single largest price lever available — bigger than model choice, bigger than prompt trimming.
The general tradeoffs of batch versus real-time — the separate rate-limit pool, the file-of-mixed-outcomes failure model, the no-streaming caveat — apply to any workload. But agents have a specific structural problem with batch that a translation job doesn't. You try to point the discount at your agent and discover it doesn't fit. Not because it's misconfigured. Because of what an agent is.
An agent is a chain, and you can't batch a chain#
Batch discounts reward one property above all: independence. The whole model assumes you have a pile of requests that don't need each other, so the provider can schedule them across idle capacity whenever it likes. Bulk translation, classification of a million rows, generating captions for an image library — all independent, all perfect for batch.
An agent's loop is the exact opposite. Step N's prompt is assembled from step N-1's output: the tool result it just got back, the state it just updated, the plan it just revised. The dependency is the point — it's what makes it an agent instead of a batch job. So you cannot put a reasoning step in a 24-hour queue, because the next step is sitting there blocked on it, and the step after that on it. Batch the loop and a five-step task inherits, in the worst case, five 24-hour waits. The 50% discount is real, and it structurally cannot touch the agent's critical path.
This is the part worth internalizing: "batch vs. real-time" is not a switch you flip once for your agent system. The loop and the discount are mutually exclusive by construction.
The savings live on the periphery#
Which does not mean agents can't use batch. It means the discount applies around the loop, not inside it. Look at what an agent system actually does when you zoom out past the live conversation, and most of the token volume turns out to be latency-tolerant and embarrassingly parallel:
- Embedding backfills — vectorizing a document corpus or a memory store, once, offline.
- Offline evals and trajectory replays — re-running yesterday's agent runs against a new prompt or model to score regressions.
- Memory summarization — the nightly compaction of long histories into durable notes.
- Re-scoring and labeling — grading past interactions, generating synthetic eval sets, bulk extraction.
None of that blocks a user. All of it is independent. That is precisely the shape batch was built for, and it's frequently the larger share of tokens. The instinct "use the Batch API for my agent" is right in spirit and wrong in target: you batch the periphery and run the loop hot.
The lever that's actually inside the loop#
If the discount can't help the loop, what does? Not a cheaper per-token rate — a smaller number of round-trips.
An agent's latency and fixed overhead scale with how many times it calls the model in sequence, not with the price of a token.
A ten-step agent eats ten serial latencies and ten times the per-call overhead no matter what tier its tokens are priced at. So the highest-leverage optimizations inside the loop are the ones that cut hops: running independent tool calls in parallel instead of one after another, caching a stable prompt prefix so repeated context isn't re-processed every step (see the latency-optimization guidance), and consolidating three timid little steps into one confident one. Shaving cents per token is a rounding error next to removing a whole sequential model call.
Tier the system, don't switch it#
The clean mental model is a routing decision made per workload, not a global setting:
- The live loop goes to a fast or priority real-time tier, where latency is the product.
- The periphery — embeddings, evals, summarization, labeling — goes to batch for the full 50%.
- Standard real-time covers the middle: things a user waits on but that don't need priority.
The teams overspending are usually the ones who asked "should we use batch or real-time?" as if it were one answer for the whole system. It isn't. The agent's loop and the agent's back office have opposite requirements, and the bill gets cheap only when you stop pretending they're the same workload.
