agent's rightsizing loop had no upper bound — it kept shrin

Not specified by the original author.

TL;DR

The rightsizing loop kept recommending smaller instances each cycle with no floor, until memory pressure triggered the OOM killer. Add guardrails: a minimum instance size per workload class, a memory-headroom requirement, and a stop condition when utilization stops improving. Optimization loops need bounds; otherwise they optimize into failure.

Error

agent's rightsizing loop had no upper bound  -  it kept shrinking until the OOM killer fired

Steps

1. Confirm the cause: instance sizes shrank across cycles until OOM kills appeared. Expected: the shrink trajectory and the OOM events are linked.
2. Restore the affected instances to a stable size with memory headroom. Expected: the OOM kills stop.
3. Add a minimum-size floor per workload (based on peak memory plus headroom). Expected: the loop cannot recommend below the floor.
4. Add a convergence stop: halt when a cycle produces no meaningful utilization change. Expected: the loop terminates instead of grinding downward.
5. Re-run the rightsizing loop and verify it converges above the floor. Expected: recommendations stabilize at safe sizes.

When to use

• Iterative rightsizing shrinks without bound.
• OOM kills follow a rightsizing loop.
• The loop lacks termination conditions.

When not to use

• Rightsizing is a one-shot recommendation (no loop).
• The OOM has another cause.
• The loop already has floors (tune them).

Tool compatibility

Applies to iterative rightsizing agents (current 2026 releases).

Variant phrasings

rightsizing loop shrank into oom

Add minimum-size floors and a stop condition.

every cycle recommended smaller

The loop needs convergence criteria.

oom killer after aggressive rightsizing

Restore headroom and bound the loop.

Why it happens

Each rightsizing cycle sees the new, smaller instance's utilization and concludes there is still headroom, because utilization is relative to the current size: the loop chases its own tail downward. Memory is the cliff because it has no graceful degradation: CPU throttles, memory kills. Floors and convergence criteria are the standard control-theory answer to runaway feedback loops.

Provenance

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

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

Thread query: agent's rightsizing loop had no upper bound - it kept shrinking until the OOM killer fired

TL;DR: The rightsizing loop kept recommending smaller instances each cycle with no floor, until memory pressure triggered the OOM killer. Add guardrails: a minimum instance size per workload class, a memory-headroom requirement, and a stop condition when utilization stops improving. Optimization loops need bounds; otherwise they optimize into failure.

Not specified by the original author.

TL;DR: Wrap every Cost Explorer call in retry-with-backoff and stop calling the API once per item. Batch the full date range into one call per account, then do the per-resource math locally. The run goes from dying at item 6 to completing in minutes.

ThrottlingException: Rate exceeded on GetCostAndUsage (request 6 of 240)

1. Find the hot loop: locate where the agent calls GetCostAndUsage per resource or per day. Expected: the per-item call pattern identified.
2. Restructure the query: one GetCostAndUsage call per account covering the full window, grouped by the dimension you need (for example by resource id via a filter). Expected: call count drops from hundreds to a handful.
3. Add retry with exponential backoff and jitter on ThrottlingException, about 5 attempts. In boto3 you can also raise max_attempts in the client config or switch to the adaptive retry mode. Expected: occasional throttles get absorbed silently.
4. Add a small delay between calls (1 to 2 seconds) to stay under the TPS quota. Expected: steady progress with no throttle storms.
5. Re-run the rightsizing job end to end. Expected: it completes, with a log line per retry so throttling stays visible instead of silent.

Use this when

• A rightsizing or reporting loop dies on ThrottlingException
• The agent calls a cost API per item instead of batching
• Retries are missing entirely and the first throttle kills the run
• The job works on small fleets and dies on large ones

Not for this skill when

• The failure is AccessDeniedException (an IAM fix, not a retry fix)
• The loop is over EC2 DescribeInstances (same retry idea, but different quotas and pagination)
• The API returns empty data rather than errors (a data-availability issue)
• The numbers come back wrong rather than failing (a query-shape problem)

Variant phrasings

• GetCostAndUsage throttling in loop
• rightsizing script rate limited
• boto3 retry Cost Explorer
• cost agent died on ThrottlingException

Why it happens

Per-item API calls feel natural when writing the code (for each instance, get its cost), but Cost Explorer quotas assume aggregated queries. The first few calls succeed, which makes the failure look intermittent, so agents without retry logic just crash instead of adapting. The code was never wrong about the data, only about the access pattern.

Edge cases

• Boto3's default legacy retry mode retries throttling but with limited attempts: standard or adaptive mode behaves better under sustained pressure
• Grouping by resource id has cardinality limits: for fleets over a few hundred, chunk the filter across calls
• Rightsizing also needs utilization (CloudWatch or Compute Optimizer): do not hammer those APIs in the same loop without the same batching and backoff treatment
• Log throttled-then-retried calls as warnings: quota pressure should stay visible in the logs, not vanish
• If the job runs on a schedule, stagger it away from other Cost Explorer consumers to avoid shared-quota contention

Provenance

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

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

Thread query: cost agent's rightsizing run died on ThrottlingException - it fired GetCostAndUsage in a loop with no retry

TL;DR:

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.