Over the past two months, we've made a series of deep optimizations to Trae Agent—from core infrastructure to LLM context handling, all the way down to how each tool is integrated and executed. The result? A major leap in real-world coding performance.
Based on SWE-bench benchmarks, Trae Agent now performs ~20% better on Claude 3.5 and ~10% better on Claude 3.7 compared to previous versions.
Here's a breakdown of how we did it.
Rethinking Proposals: More Autonomy, Smarter Decisions
In recent updates to Trae Agent, we removed the fixed “Proposal” planning stage to unlock greater model autonomy and decision-making accuracy. Previously, Trae Agent followed a Plan-then-Execute workflow—where the model generated a full execution plan before taking any action. While this approach brought structure and clarity, especially for earlier models, as workflows within IDEs became more complex, we saw trade-offs in its limited flexibility.
For example, rigid early planning sometimes led the model down the wrong path—especially when more code context was needed to form a better strategy. In other cases, the model's follow-up actions lacked sufficient conversational context due to the initial plan being disconnected from later tool invocations. This sometimes resulted in redundant steps or degraded outcomes.
So in the latest version of Trae Agent, we've removed the fixed Proposal stage entirely.
This architecture shift enables:
-
More model autonomy: Instead of being locked into an upfront plan, the model now decides when to gather more context, when to reason, and when to act—based on the evolving state of the session.
-
Context is fully unified: Everything from past user messages to tool usage logs is now continuously available in a shared conversation window. This helps the model stay grounded in the full history of interaction.
-
Improved efficiency with prompt caching: With richer context, we've doubled the effective context window for models while also optimizing costs using prompt caching.
That said, reasoning is still essential. While we've removed the rigid planning phase, we've enhanced the model's ability to think when it needs to. Through optimizing prompt engineering and systemic tuning, the current version of Trae Agent can dynamically generate plans when appropriate—leading to better decisions at every step of the toolchain.
Looking ahead, we're also experimenting with lightweight planning modules like sequential thinking tools that can be invoked mid-session. The goal is to balance autonomy and clarity, giving the agent freedom to act, but the structure to think smart.
Unified Modes and Enhanced Code Retrieval in Trae Agent
The newly upgraded Trae Agent now powers not only the Builder mode, but also the classic Chat mode. Both modes are fully integrated into a unified, agentic workflow. In this latest version, Trae's Chat experience has evolved to run in full agent mode, giving it the same autonomy and tool access as Builder.
When users interact with Trae without explicitly selecting Builder or a custom Agent, they remain in Chat mode. But under the hood, the model can now autonomously decide whether to call tools, write code, or respond directly based on the available context and conversation history. Users can freely follow up with additional questions or copy and apply generated code directly to their editor at any time.
Even more powerful: your context memory is now fully shared across all modes—Chat, Builder, and Custom Agents. That means you can start a session in Chat to gather background or clarify a task, switch to Builder for full code generation, and then pass results into a Custom Agent for advanced refinement. All tool uses, prompts, and responses persist and remain visible to the model across these transitions.
To support this seamless multi-modal experience, we've also upgraded our internal code retrieval engine. The original code knowledge graph (CKG) system (once limited to the #Workspace) has been abstracted into a new Workspace Search Tool, accessible in all modes. Whenever the model needs relevant code context, it can invoke this tool to retrieve the most pertinent files, functions, or components, therefore boosting both accuracy and response speed during generation or editing tasks.
Together, these updates significantly improve agent performance, contextual continuity, and productivity.
More Memory Through Context Expansion
As mentioned earlier, the latest version of Trae Agent features a significantly expanded context window. But even with more room for history, long-running sessions with dozens of user interactions and tool calls inevitably push past the token limit. To solve this, we introduced a newsummary mechanism.
In previous versions of Trae Agent, models could technically “see” some past tool usage, but the available context was often stitched together manually, lacking depth, nuance, or task-specific relevance. With the upgraded system, Trae now continuously stores the raw content of your session history. Once the context window approaches its limit, our summary mechanism kicks in invisbly and automatically.
Here's how it works:
-
Recent turns are preserved verbatim, ensuring recency and accuracy.
-
Older turns are distilled using LLM-based summarization, generating compact memory entries that retain high-level reasoning, tool usage, and task dependencies.
-
This summarization process is ultra-fast, has no impact on latency, and doesn't consume user model quotas—even for premium-tier models.
For example, in older versions, if the model accessed a code file during a session, it might only remember the file path or that a read action occurred. In the new system, the summary includes why the file was accessed, which parts of the content were relevant to the current task, and how the tool call contributed to solving the problem. This gives Trae Agent a far more accurate and detailed long-term memory within the chat session.
With this context compression strategy, we maintain rich tool-level awareness and reasoning chains even across extended coding sessions, allowing Trae to deliver smarter, more contextually grounded responses as your work evolves.
Smarter Tooling
The tools available to an AI agent are critical to how well it performs. While today's models are increasingly capable, even the most advanced LLMs rely on precise and reliable tool execution to deliver meaningful results.
In recent Trae Agent updates, alongside major architecture and context improvements, we've focused on refining tool reliability, particularly in edge cases where execution fails or output is suboptimal. Tool optimization is an ongoing investment, but here's a snapshot of some recent high-priority improvements we've made:
-
Toolset Simplification and Merging: In Builder mode, we consolidated redundant tools-for example, merging "create file" and "overwrite file" into a single action. We also removed rarely used tools. A leaner toolset reduces decision complexity for the model and improves call accuracy.
-
Smarter Code Edits: For core code editing tools, we introduced a more intelligent application strategy. Even in edge cases such as when the model's expected pre-edit snippet doesn't perfectly match the current file, the system can now execute edits successfully. This has led to a measurable drop in file edit failure rates.
-
Improved Read Tool Output: Tools for accessing codebases—like folder browsing, file reading, and code search—have been enhanced to return more structured, semantically rich information. This helps the model better understand the code it's interacting with and increases precision when navigating or modifying large projects.
These enhancements make Trae Agent more reliable, especially in complex development environments where accuracy and tooling matter most.
With this series of upgrades - from core architecture and expanded context to tool-level precision, Trae Agent is officially stepping into its 2.0 era. Looking ahead, we'll continue tuning every layer of the Agent to move closer to our vision: a truly capable, autonomous AI engineer.