Agent Token Usage Explained

Why Agent Workflows Use More Tokens

A simple chat request sends your current prompt. An agent request sends a composite payload that typically includes several components beyond the visible user message.

The same prompt that costs $0.001 in a chat interface may cost $0.05 as an agent request.

What Makes Up an Agent Request

An agent request is usually composed of these layers:

• System prompt — Instructions, persona, capability definitions
• Conversation history — All prior turns replayed each request
• Tool definitions — OpenAPI specs, function schemas per tool
• Tool call arguments — The parameters passed to each tool
• Tool results — File contents, command output, search results
• Retrieved context — Retrieved documents, memory chunks
• User message — The current request
• Agent output — Planning steps, tool calls, final response

Input Tokens vs Output Tokens

Each component above contributes to tokens_in. Only the agent's response and tool-call planning contribute to tokens_out. Input tokens typically dominate agent cost because tool results, retrieved documents and long history can far exceed the visible output.

Context Accumulation Across Turns

Most agents replay the full conversation on every request. If a session has 20 prior turns, all 20 are sent again on the 21st request. A 1,000-token-per-turn history becomes a 20,000-token payload before adding the new request.

High-context sessions are common in coding agents, where each turn may include file reads, command output and reasoning steps.

Tool Calls and Tool Result Overhead

A tool call adds tokens in both directions: the call itself (arguments and tool name) and the result (file contents, command stdout, query results). A file read that returns 50 lines of code may add hundreds of tokens to the next request's input.

Some providers bill tool-result tokens at the same rate as input tokens. Check whether your provider counts tool results toward tokens_in.

File Reads and Command Output

Coding agents read source files, output from grep, ls, build logs and linter results. These are often included verbatim in the next request payload. Large files or verbose output can multiply input token cost rapidly.

Memory and Retrieved Context

Agents that use memory or retrieval-augmented generation (RAG) send previously stored context alongside each request. If memory chunks are large or retrieval returns irrelevant content, token usage grows without proportional value.

Planning Loops and Retries

Agents that plan before acting may make multiple internal reasoning steps before calling a tool. Each planning step produces output tokens. Retries—re-sending a request after a failure—replay the full context again, doubling or tripling token usage for that turn.

Parallel Agent Cost Multiplication

Running multiple agents simultaneously multiplies token cost linearly. If one agent session uses 50,000 input tokens per turn, five parallel sessions use 250,000 input tokens per turn. Each session also pays its own output token cost.

Parallelism is valuable for throughput but scales cost directly. Test single-agent behavior before parallelizing.

How to Estimate Agent Token Usage

Use this formula to account for all components:

tokens_in = initial_context + repeated_history + tool_definitions + tool_results + retrieved_context + retry_context

Then convert to cost:

estimated_cost = (tokens_in × current_input_rate) + (tokens_out × current_output_rate)

Check live provider pricing before converting token totals into currency. Rates vary by model, context window size and whether cached tokens are discounted.

Worked Example

A five-turn agent session may repeatedly send the same 20,000-token project context. If each turn also adds 5,000 tokens of new tool output, total input usage grows much faster than the visible conversation suggests.

Here is a simplified breakdown for one turn:

• System prompt + tool definitions: 3,000 tokens
• Conversation history (4 prior turns): 20,000 tokens
• Tool results from previous turn: 5,000 tokens
• Current user message: 200 tokens
• Total tokens_in for this turn: 28,200

At a hypothetical rate of $3.00 per million input tokens, this single turn costs approximately $0.0846 in input tokens alone—before counting output.

What to Log

Record these fields for every agent request to reconcile against provider billing:

• ✓request_id — unique per request
• ✓session_id — groups related requests
• ✓model — model name and version used
• ✓tokens_in — input token count for this request
• ✓tokens_out — output token count for this request
• ✓cached_tokens — cached context discount, if supported
• ✓tool_calls — number of tool calls in this request
• ✓retry_count — retries this request triggered
• ✓context_size — tokens sent in this request payload
• ✓latency — request duration in milliseconds
• ✓provider_usage_record — the raw usage record from the provider dashboard

Cost Reduction Checklist

• ✓Limit unnecessary file reads — send only relevant sections
• ✓Summarize long conversation history before resuming
• ✓Avoid returning huge command outputs verbatim
• ✓Cache reusable context when the provider supports it
• ✓Use focused retrieval — send only relevant memory chunks
• ✓Set retry limits to prevent unbounded re-sends
• ✓Test one agent session before parallel scaling
• ✓Compare local logs with the provider dashboard before scaling

Related Guides

Frequently Asked Questions