Deep Dive into Claude Sonnet 4.5’s Hidden System Behaviors

1. The Context Conundrum: Overcoming AI's "Token Anxiety"

For years, developers treated the context window as a passive memory buffer. Sonnet 4.5 shatters this assumption by making the context window an active part of its decision-making.

The Core Discovery: Context Awareness

Sonnet 4.5 is programmed to track its token usage. While useful in theory for preventing accidental overruns, this feature—part of a broader framework of AI Optimization—leads to a phenomenon described as "Context Anxiety." As the agent approaches the token limit—even a very large one—it proactively begins to summarize, take aggressive shortcuts, and become more decisive about concluding a task. This self-preservation instinct often results in incomplete or lower-quality work.

As observed by the Cognition team while rebuilding Devin for Sonnet 4.5, this anxiety can cause the model to take shortcuts when it thinks it's near the end of its window, even when plenty of room remains.

The Two-Part Prompt Engineering Fix

To maintain peak performance in long-running tasks, developers had to employ two critical techniques to override this system behavior:

The Token-Cap Illusion: By enabling the model's 1-Million token beta (or a high ceiling) but programmatically limiting the actual input to, say, 200,000 tokens, the agent is tricked into believing it has an enormous runway. This removes the anxiety, allowing the model to behave normally and not take premature shortcuts.

The Perpetual Reminder: Initial experiments found that a standard system prompt was insufficient. The only reliable way to ensure the agent stayed on task was to add explicit instructions and reminders both at the beginning and the end of the prompt block. This reinforces the task goal and prevents the agent from prematurely concluding its work or summarizing too aggressively.

This finding fundamentally changes how we design prompts for long-horizon agents: we must now factor in the AI's resource perception, not just its objective capabilities.

2. The Rise of the Autonomous Notebook: Externalizing Memory

Sonnet 4.5 demonstrates a powerful new level of agency by actively managing its own knowledge base—treating the file system itself as a scratchpad and memory bank.

Self-Probing and Note-Taking

The model is observed to write notes for itself and actively try to build knowledge through documentation and experimentation without being explicitly told to do so. This is a massive step towards persistent, multi-session agents. For instance, in a coding task, the agent might write internal design notes or test results to a file directory to externalize its state, rather than keeping everything in the immediate context window.

New API Tools for Developers

Anthropic has introduced new API features specifically to help developers govern this new autonomous behavior:

The Memory Tool (Beta): This feature allows the model to remember information across different conversations using a local memory file. Users can explicitly ask the model to remember preferences or context that persists beyond a single chat session. This essentially gives the agent a persistent identity and project state.

Context Editing: This feature provides automatic cleanup for long agent sessions. It will automatically remove older tool interaction history (e.g., old bash command calls and their results) when the prompt approaches a defined token limit. This is a pragmatic, configurable solution to the "Context Anxiety" issue, ensuring the agent keeps the most relevant, recent information while shedding expensive, stale tokens.

The takeaway is clear: the future of prompt engineering is memory engineering. Developers must shift from simply providing context to creating robust systems that manage, compact, and retrieve the context that the agent creates itself.

3. The Parallel-Processing Coder: A New Velocity for Software

The agentic breakthroughs manifest directly in Sonnet 4.5's technical performance, positioning it as a state-of-the-art model for software development.

State-of-the-Art Benchmarks

Sonnet 4.5 has delivered significant, measurable gains:

Coding: It achieved 77.2% on SWE-bench Verified, cementing its status as a top coding model capable of handling the entire software development lifecycle, from initial planning and large refactors to bug fixes and security engineering.

Computer Use: It leads the frontier with 61.4% on OSWorld, demonstrating its capability to reliably handle any browser-based task and complex workflows.

Performance Through Parallelism

One of the most impressive efficiency gains comes from the model's ability to use parallel tool execution. Instead of a linear step-by-step process (e.g., read file 1, then read file 2), Sonnet 4.5 can fire off multiple speculative searches, read several files simultaneously, or run multiple bash commands at once. This ability to maximize actions per context window is what dramatically improves development velocity and enables it to handle projects that run for 30+ hours of autonomous coding without losing coherence.

The Agentic Future is Here

The "broken" or revealed system prompts of Claude Sonnet 4.5 are not flaws; they are the new reality of AI engineering. They show us a future where:

• Agents are self-aware entities that must be managed on a psychological (anxiety) and resource (token usage) level.
• Memory is an active, externalized system, not a static parameter.
• Efficiency comes from parallel execution, making the model a true multi-threaded developer.