Learn token economics

1# Every prompt is a series of tokens
2import tiktoken
3
4enc = tiktoken.get_encoding("o200k_base")
5
6system = "You are a helpful assistant."
7user = "Fix the auth bug."
8
9system_tokens = len(enc.encode(system))
10user_tokens = len(enc.encode(user))
11
12print(f"System: {system_tokens} tokens")
13print(f"User: {user_tokens} tokens")
14print(f"Total: {system_tokens + user_tokens} tokens")

1# Context Window = Your Token Budget
2import anthropic
3
4client = anthropic.Anthropic()
5WINDOW = 1_000_000  # Claude Sonnet 5.5
6
7count = client.messages.count_tokens(
8    model="claude-sonnet-5-5",
9    system="You are a helpful assistant.",
10    messages=[{"role": "user", "content": "Fix the auth bug."}],
11)
12remaining = WINDOW - count.input_tokens
13print(f"Budget remaining: {remaining:,} tokens")

1# Trimming: Last-N Strategy
2def trim_history(messages, n=3):
3    """Keep only the last N turns."""
4    system = [m for m in messages if m['role'] == 'system']
5    turns = [m for m in messages if m['role'] != 'system']
6    return system + turns[-n * 2:]
7
8# 20 messages → 6 (last 3 turns)
9messages = trim_history(conversation, n=3)
10print(f"Kept {len(messages)} messages")

1# Summarisation: Token Economy
2import anthropic
3
4def summarise_history(messages, client):
5    """Condense conversation to save tokens."""
6    history_text = "\n".join(
7        f"{m['role']}: {m['content']}" for m in messages
8    )
9    response = client.messages.create(
10        model="claude-sonnet-5-5",
11        max_tokens=500,
12        messages=[{
13            "role": "user",
14            "content": f"Summarise this conversation:\n{history_text}"
15        }]
16    )
17    return response.content[0].text

1# Token Budget Manager
2class TokenBudget:
3    def __init__(self, limit=1_000_000):  # Claude Sonnet 5.5
4        self.limit = limit
5        self.allocations = {}
6
7    def allocate(self, name, tokens):
8        self.allocations[name] = tokens
9
10    @property
11    def remaining(self):
12        used = sum(self.allocations.values())
13        return self.limit - used
14
15    @property
16    def utilization(self):
17        return sum(self.allocations.values()) / self.limit

1# Context Pollution Detection
2def detect_pollution(messages):
3    """Flag stale or redundant content."""
4    stale = []
5    for i, msg in enumerate(messages):
6        if msg.get('tool_result'):
7            age = len(messages) - i
8            if age > 10:  # older than 10 turns
9                stale.append(i)
10    print(f"Found {len(stale)} stale entries")
11    return stale

1# Server-side compaction (threshold mode)
2import anthropic
3
4client = anthropic.Anthropic()
5
6response = client.beta.messages.create(
7    model="claude-sonnet-5-5",
8    max_tokens=16000,
9    betas=["compact-2026-01-12"],
10    context_management={"edits": [{
11        "type": "compact_20260112",
12        "trigger": {"type": "input_tokens", "value": 150_000},
13    }]},
14    messages=messages,
15)
16
17# Keep the compaction block: append the full content
18messages.append({"role": "assistant", "content": response.content})

1# Context editing: clear old tool results by rule
2response = client.beta.messages.create(
3    model="claude-sonnet-5-5",
4    max_tokens=16000,
5    betas=["context-management-2025-06-27"],
6    context_management={"edits": [{
7        "type": "clear_tool_uses_20250919",
8        "trigger": {"type": "input_tokens", "value": 100_000},
9        "keep": {"type": "tool_uses", "value": 3},
10        "clear_at_least": {"type": "input_tokens", "value": 10_000},
11        "exclude_tools": ["memory"],
12    }]},
13    tools=tools,
14    messages=messages,
15)

1# Custom summary instructions for domain needs
2context_management={"edits": [{
3    "type": "compact_20260112",
4    "trigger": {"type": "input_tokens", "value": 50_000},
5    "instructions": (
6        "Preserve: ticket IDs, categories, "
7        "priorities, teams, outcomes. "
8        "Discard: full KB articles, draft text."
9    ),
10}]}

1# Effort, adaptive thinking, and caching in one request
2response = client.messages.create(
3    model="claude-opus-5-5",
4    max_tokens=16000,
5    thinking={"type": "adaptive"},
6    output_config={"effort": "high"},
7    cache_control={"type": "ephemeral"},
8    system=STABLE_SYSTEM_PROMPT,
9    messages=messages,
10)