When Context Editing Made My Agent Re-run the Same Search — Field Notes on Clear Boundaries and Cache Invalidation

Confirm the Re-run Loop With Numbers

Settle it with counts, not vibes. Bucket tool calls by a hash of their arguments and count how many times the same call appears.

# From one agent run's transcript, count how often it redid the same investigation
# Goal: compare duplicate counts before/after clearing to detect over-aggressive settings
from collections import Counter
 
def count_redundant_tool_calls(transcript_blocks):
    seen = Counter()
    redundant = 0
    for b in transcript_blocks:
        if b.get("type") != "tool_use":
            continue
        key = hashlib.sha1(
            (b["name"] + json.dumps(b["input"], sort_keys=True)).encode()
        ).hexdigest()
        seen[key] += 1
        if seen[key] > 1:
            redundant += 1
    total = sum(seen.values())
    rate = redundant / total if total else 0.0
    return {"total_tool_calls": total, "redundant": redundant, "redundant_rate": round(rate, 3)}
 
# Rule of thumb: if redundant_rate jumps 0.1+ above the no-clearing baseline, raise keep

In my own runs, raising keep from 3 to 6 dropped the redundant rate from 0.28 to 0.05 on one occasion. Tokens rise slightly, but because the re-run results no longer pile up, total input tokens stay flat and response quality clearly recovers. What you want to drop is "old results," not "results still doing work" — an obvious point that only landed once I had the numbers.

Set trigger and clear_at_least From Measured Token Distributions

Set trigger too low and clearing fires while you still have headroom, so cache invalidation happens first with little benefit. Too high and you fail to contain the bloat. Don't guess here; plot the real per-turn input token curve once, then decide.

The order of decisions:

1. With clearing disabled, run a few representative workloads and record input_tokens per turn.
2. Look at the value just before tokens plateau, and use 80–90% of it as your initial trigger.
3. Set clear_at_least above the measured average cache_creation_input_tokens. This guarantees one clear saves more than it costs to rebuild the cache.
4. Add long-lived search and spec-reference tools to exclude_tools to protect them.

If clear_at_least falls below the cache write volume, you endlessly "clear a little, then rebuild the cache," which is the most expensive failure mode of all. This is the one knob to keep conservatively large. The token measurement basics are in measuring Claude API costs with token counting.

The Extra Trap When Combining Extended Thinking

While you're focused on clearing tool results, it's easy to miss the Extended Thinking side. If Thinking is enabled and you don't specify clear_thinking_20251015, only the most recent turn's thinking is retained by default. For an agent that needs multi-step reasoning, that becomes the reason it "forgets the chain of thought it was halfway through and starts reasoning from scratch."

# Manage tool results and thinking blocks with separate retention policies
# Goal: make the asymmetry explicit — keep investigation shallow, keep reasoning deep
resp = client.beta.messages.create(
    model="claude-opus-4-6",
    max_tokens=16000,
    temperature=1,  # required when Extended Thinking is on
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=conversation_messages,
    tools=my_tools,
    betas=["context-management-2025-06-27"],
    context_management={
        "edits": [
            {
                "type": "clear_tool_uses_20250919",
                "trigger": {"type": "input_tokens", "value": 50000},
                "keep": {"type": "tool_uses", "value": 6},
                "clear_at_least": {"type": "input_tokens", "value": 8000},
                "exclude_tools": ["web_search"],
            },
            {
                "type": "clear_thinking_20251015",
                "keep": {"type": "thinking_turns", "value": 2},
            },
        ]
    },
)
# Effect: tool results trimmed to the last 6, while reasoning continuity is kept for 2 turns

Tool results and thinking blocks are retained for different reasons. Tool results are an "inventory of facts," so older ones are usually safe to drop; thinking blocks are "continuity of judgment," so dropping them resets the reasoning. Apply the same keep instinct to both and you'll over-trim the Thinking side.

Reject Cache-Hostile Settings Before Shipping

Finally, estimate the trade-off once before you enable it. Roughly, compare the tokens a single clear saves (felt on later turns) against the cache rebuild tokens incurred at that moment.

The core judgment is one thing. Context Editing isn't a "reduce context" feature; it's a "control when, what, and how much to reduce" feature. The moment reduction becomes the goal, re-runs and cache destruction will turn it against you. For broader production cost design, see tightening Claude API cost optimization in production.

Next Step

First, with clearing disabled, run three representative workloads and put the input_tokens curve and the cache_read / cache_creation ratio into a single log. Then set trigger to 80% of the token plateau, clear_at_least above the average cache write, and start keep at the smallest value where the redundant rate doesn't spike. Enable it in that order and you'll avoid the "lighter but more expensive" trap. I hope it saves you from sinking time into the same pitfall.