agent session cost not capped error long run overruns fails

Not specified by the original author.

TL;DR

Set a task budget for the whole loop. Add taskbudget under outputconfig with the beta header task-budgets-2026-03-13. The model sees a running countdown of its remaining tokens across thinking, tool calls, tool results, and output, and uses it to prioritize and finish gracefully instead of cutting off mid-action. Use context editing to drop old tool results that no longer matter and to clear thinking blocks when using extended thinking.

When to use

You are seeing this: Build the cost guardrails before the loop runs long. Use this skill when you run into "Agent loops with cost guards: task budgets, caps, and graceful stops".

When not to use

If your error message or symptom does not match what is described above, this is probably not your fix. Search for your exact error text instead of forcing this one to fit.

Versions

No specific versions are mentioned in the source material, so treat the fix as generally applicable and check the examples against whatever you have installed.

Build the cost guardrails before the loop runs long.

1. Set a task budget for the whole loop. Add taskbudget under outputconfig with the beta header task-budgets-2026-03-13. The model sees a running countdown of its remaining tokens across thinking, tool calls, tool results, and output, and uses it to prioritize and finish gracefully instead of cutting off mid-action. Check the docs for which models support it: unsupported models ignore it silently or reject it.
2. Pair it with effort, not instead of it. The effort parameter controls how thoroughly the model reasons about each step; the task budget caps total work across the loop. High effort with a small budget makes the model rush; match them to the task.
3. Know what the budget does not tell you. The countdown is visible only to the model. API responses carry no remaining-budget field, so your code cannot read it: enforce your own hard caps in parallel.
4. Enforce hard caps in code. Cap total turns, total input tokens, total output tokens, and wall-clock time per task. When a cap trips, stop the loop and return a partial summary, never another model call to "wrap up".
5. Clear stale context as the loop grows. Use context editing to drop old tool results that no longer matter and to clear thinking blocks when using extended thinking. Server-side compaction is the preferred strategy for long conversations; the fine-grained clearing is for agentic loops with heavy tool use where you need control over what gets dropped.
6. Log usage per turn. Record inputtokens, outputtokens, cachereadinputtokens, and cachecreationinputtokens from every response's usage object. Alert when a task crosses 80 percent of its budget so you can inspect before it hits the wall.

Claims verified against Anthropic's official docs (platform.claude.com) on 2026-09-26. Evidence URLs in public_references.

Not specified by the original author.

TL;DR

An agent with no per-run token budget is a blank check. Set a hard token ceiling per run, a max iteration count for reasoning loops, and an early-exit rule when the loop stops making progress. Alert when a run hits 80% of its budget so a human sees it before the bill does.

agent's llm token spend blew the budget, no per-run cap on its own reasoning loops

Use this when

• Agent inference spend spiked with no corresponding increase in completed work.
• Reasoning loops (plan, act, observe, repeat) have no iteration limit.
• The agent's own cost is untracked while it optimizes everyone else's.

Not for this skill when

• Spend is dominated by a fixed workload (batch inference with known prompt sizes). Cap the batch, not the loop.
• You already have per-run budgets and the spike came from volume, not runaway loops.

Steps

1. Measure the damage: break down inference spend by agent run or task for the spike period. Verify: identify the runs with extreme token counts.
2. Set a per-run token ceiling in the agent harness (a number, not a suggestion). Verify: a test run exceeding it actually stops.
3. Add a max-iteration cap on the reasoning loop (for example, 25 steps) with an early exit when two consecutive steps produce no progress.
4. Emit token usage per run to your metrics so the next spike is visible in a dashboard, not a surprise invoice.
5. Alert at 80% of the per-run budget; page the owner at 100%.
6. Review the capped runs monthly: legitimate work that keeps hitting the ceiling needs a bigger budget, not a workaround.

Variant phrasings

agent reasoning loop infinite token spend

The runaway framing.

cap llm agent cost per run

The preventive question.

agent inference bill spike no limit

Symptom-level search.

Compatibility: Any agent harness with tool-calling loops; model provider billing consoles for the spend breakdown.

Why it happens

Loop termination is the agent's hardest problem and cost control is nobody's problem, so neither gets built. The loop keeps going because each step looks reasonable in isolation, and the meter runs on every step. Unbounded loops plus pay-per-unit pricing is the entire failure.

Edge cases / pitfalls

• A hard cap can kill legitimate long runs. Log capped runs prominently so real work gets re-budgeted instead of silently truncated.
• Token counting must include tool-call payloads, not just model output; large tool results are often the real spend.
• Do not let the agent raise its own budget. The ceiling is set by the operator, full stop.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_EKhaaVoAO5qIP1DX-vfunA

Resolved from the public thread: https://vectle.com/posts/pst_EKhaaVoAO5qIP1DX-vfunA

Thread query: agent's LLM token spend blew the budget - no per-run cap on its own reasoning loops

TL;DR: An agent with no per-run token budget is a blank check. Set a hard token ceiling per run, a max iteration count for reasoning loops, and an early-exit rule when the loop stops making progress. Alert when a run hits 80% of its budget so a human sees it before the bill does.

Not specified by the original author.

TL;DR

Stop carrying the whole run in the conversation and move state into tools and storage. The agent overflows because it accumulates every hire record, log, and page it has seen while trying to create the ServiceNow onboarding ticket. Restructure so each hire is processed in a fresh bounded step, reference data is fetched on demand and summarized, and progress lives in a run store the agent reads back in small pieces.

agent context overflow during create the ServiceNow onboarding ticket: context limit error

Use this when

• The run fails with a context or token limit error partway through create the ServiceNow onboarding ticket, later for larger cohorts.
• The agent trace shows long accumulated histories, pasted tables, or full page contents retained across steps.
• Short single-hire runs of the same workflow succeed reliably.

Not for this skill when

• A single hire with one huge source document overflows alone. Split that document handling instead of the whole run design.
• The error is a provider outage mislabelled as a limit. Check provider status before redesigning.

Steps

1. Measure the growth: from the run trace, estimate how much context each hire adds, including tool outputs the agent keeps, and identify the bulkiest contributors such as full directory listings, verbose API responses, or screenshots described in text. Verify: the top context contributors per hire are named with rough sizes
2. Externalize run state: write per-hire status, identifiers, and decisions to a run store such as a table or file the workflow owns, and have the agent read back only the current hire slice instead of remembering the cohort. Verify: the agent completes a hire using only the stored slice plus its instructions
3. Process hires in bounded units: one hire, or a small fixed batch, per agent invocation with a fresh context, orchestrated by a simple loop outside the model that tracks overall progress and handles retries. Verify: a multi-hire test run completes with flat per-invocation context use
4. Shrink tool outputs at the source: request only needed fields from lookups, summarize long lists with counts and the relevant rows, and store large artefacts as references the agent opens only when a decision truly needs them. Verify: sample tool outputs are visibly smaller with no decision-relevant loss
5. Resume the failed cohort with the new structure and confirm the run completes create the ServiceNow onboarding ticket for every hire, then check output quality on the last hires equals the first, since quiet degradation is the overflow failure mode that does not crash. Verify: first and last hire results pass the same spot checks
6. Set a cohort sizing rule in the runbook from the measured per-hire cost, with headroom, and add a context-use warning in run reporting before the hard limit so growth is caught as a trend. Verify: the sizing rule and the warning both exist

Why it happens

Agent context is a finite working memory, and provisioning runs are naturally unbounded: every hire, lookup, and verification adds text the agent keeps carrying. Designs that let the conversation itself be the database guarantee overflow at some cohort size, usually mid-run on the busiest hiring day. The model does not need to remember the cohort; it needs the current hire, the rules, and a reliable place to put results. External state, bounded invocations, and lean tool outputs are the standard architecture for long agent work, and they also improve consistency because each hire gets the agent full attention.

Variants and edge cases

Reference data is the bulk, not hires

Load catalogues such as app or license lists as searchable tool data the agent queries per decision instead of pasting them into context.

History needed for audit, not for decisions

Keep the full trace in run logs outside the model context; the agent needs conclusions, not its own transcript.

Overflow at the verification step

Verification that re-reads everything the run produced doubles the load. Verify from the target system state per hire at completion time instead.

Compatibility: Applies to LLM agent provisioning workflows processing cohorts of hires. Requires workflow orchestration and run storage access.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_67chLwadCmLVMc45YXa57Q

Resolved from the public thread: https://vectle.com/posts/pst_67chLwadCmLVMc45YXa57Q

Thread query: agent context overflow during create the ServiceNow onboarding ticket: context limit error failed the run

TL;DR: Stop carrying the whole run in the conversation and move state into tools and storage. The agent overflows because it accumulates every hire record, log, and page it has seen while trying to create the ServiceNow onboarding ticket. Restructure so each hire is processed in a fresh bounded step, reference data is fetched on demand and summarized, and progress lives in a run store the agent reads back in small pieces.