Trae (AI IDE Platform Market Research)

1. Introduction

Trae is the AI-native IDE launched by ByteDance; its name is derived from "The Real AI Engineer." The international version went live in January 2025 (the official position dates the product's birth to January 20), and the product runs on a dual-track operation split between the international site trae.ai and the domestic site trae.cn. It is the representative of a domestic big-tech ecosystem-style IDE among the six platforms in this group: it entered with the most aggressive pricing (Pro $10/month, roughly half of comparable leading products), is backed by ByteDance's own model ecosystem (Doubao) and cloud infrastructure (Volcengine), and in 2026 pushed its main product line from "human-led + AI-assisted" toward "AI-managed delivery" — namely the SOLO mode and the subsequent TraeCode / TraeWork split.

Trae's research value lies in that it answers a question different from Cursor and Windsurf: when a big tech company with a complete model and application ecosystem enters the AI IDE track, at which layer will it choose to build differentiation? The answer grew clear across 2026: not in point-editing experience, but in L1 (the rules and skills layering of context engineering) and L3 (SOLO's multi-agent managed delivery), while treating "AI-ification of non-coding roles" (PMs writing PRDs, operations producing reports) as an incremental battleground.

1.1. Developer and Product History

1.2. Positioning and Latest Version

Trae IDE is positioned as an editor for "human-led development + AI assistance"; Trae SOLO is positioned as "fully automated end-to-end delivery" — starting from requirements, agents complete the full chain from planning, coding, and testing to deployment. The relationship between the two is not a feature toggle but the coexistence of two delivery paradigms: in the IDE paradigm the human is the executor and AI is the amplifier; in the SOLO paradigm AI is the executor and the human becomes the reviewer. The MTC (More Than Coding) mode further generalizes SOLO's capabilities beyond coding — product documentation, data analysis, and operations reports — which is the most aggressive step from "assisted coding" toward "managed delivery."

The latest version is high-frequency changing information. Per the official changelog, it was in the v3.5.6x series in early June 2026; the current latest stable version is recorded as [To be filled].

1.3. Pricing System

International pricing (largely consistent across multiple sources for individual benefit details):

Paying annually saves about 25% versus monthly (third-party figure). For the domestic version, individual users are free; enterprise editions additionally have third-party figures of ¥49 / ¥99 / ¥199 monthly tiers, marked [To be verified]. The engineering implication of pricing: SOLO's concurrent cloud task count is directly tied to the tier (2 / 10 / 15 / 20), meaning the marginal cost of managed delivery capability is borne by the platform side, and users buy by concurrency count — this is a billing form unique to the "managed delivery" paradigm, distinct from both per-token and per-seat billing.

2. Glossary

3. Feature Description

3.1. Agent System

3.2. SOLO and Managed Delivery Capabilities

• End-to-end tasks: starts from natural-language requirements, automatically decomposes tasks, and executes in parallel in the cloud.
• Multi-format file parsing: files such as CSV, JSON, Word and PPTX can be used directly as input.
• Plan mode: communicate → create a plan → communicate to revise → execute after confirmation.
• Design Mode: generates design mockups and exports code.
• Voice Chat: voice interaction, optionally with web search.
• Cross-device sync: syncs task progress between the desktop and web clients.

3.3. Context and Extension Capabilities

• CUE completion: cross-line completion that predicts the next edit location.
• # reference system: #Code / #File / #Folder / #Workspace / #Doc / #Problems / #Web, explicitly injecting the corresponding context.
• Ignore configuration: compatible with .gitignore rules, controlling the indexing scope.
• MCP: three transport protocols + full OAuth authorization flow (authorize, execute, call, revoke).
• Open skills ecosystem: the .agents/skills/ directory adopts an open standard, so skills can interoperate across agent products; the community can share and discover agents.

4. Platform Architecture

图 4-1｜Trae 平台总体架构：本地 × 云端五组件堆叠

数据来源：基于本文分析绘制的示意图。

4.1. Overall Architecture

4.2. Model System and ByteDance Ecosystem

Trae's model strategy reflects a typical "ecosystem-style" approach:

Integration with the ByteDance ecosystem unfolds along two lines: on the model side, the domestic version uses the Doubao series as its default capability source, drawing on ByteDance's own model training and inference infrastructure; on the platform side, SOLO's cloud execution relies on ByteDance's cloud services, and enterprise-side deployment and compliance needs can connect with Volcengine's cloud solutions (the Volcengine website is in the references; the specific integration form is marked [To be verified]). For comparison against other domestic ecosystem-style products: Tongyi Lingma and CodeBuddy both primarily take the form of IDE plugins, while Trae is the only one that fully delivers "standalone IDE + managed delivery + dual-track operation."

4.3. Configuration File System

The IDE also auto-generates .trae/rules/git-commit-message.md for commit-message rules — the practice of the platform dynamically generating rule files is uncommon among similar products, implying that the rules directory is not a purely static configuration area.

5. Harness Design

5.1. L1 Context Engineering Layer (Key Focus of This Platform)

The four application modes of Rules (as of v3.5.18):

The four modes are semantically highly isomorphic to Cursor's four rule categories, but Trae adds two differentiating points:

1. Multi-level subdirectory nesting (v3.5.51): subfolders can be created under .trae/rules/ and the system reads them recursively up to 3 levels; module-specific rules can also be configured with .trae/rules/ in any subdirectory, applied automatically when its directory files are mentioned or read. This lets rule granularity align with monorepo module levels — a capability that corresponds to Cursor's Auto Attached glob mechanism, but Trae's directory nesting is more intuitive.
2. Compatible reading of competitor rules: Trae also reads AGENTS.md, CLAUDE.md, and CLAUDE.local.md at the repository root as rule sources (toggleable in settings). For the reality of a team using multiple agent tools at once, this is a correct low-cost compatibility design.

The division of labor between Rules and Skills is the most noteworthy L1 design of this platform:

This division aligns with Claude Code's Rules / Skills progressive-disclosure philosophy, but Trae codified it into the product structure in a more direct way: Rules govern constraints (must be resident), Skills govern processes (taken on demand). Community practice offers an actionable ratio: keep Rules within roughly 1,000 characters, containing only the project overview, skill references, and key constraints; push all detailed specifications down into Skills.

Remaining L1 channels: CUE completion is based on the workspace-wide index; the # reference system provides explicit injection; Doc Sets (only .md and .txt) serve as a persistent knowledge base. On tool quotas, community testing reports that the agent's available tools are capped at 40 (including MCP tools), exceeding which triggers a warning — meaning that when connecting a large MCP server, one needs to curate carefully to avoid overlapping with built-in tool functionality (community figure).

5.2. L2 Tools and Execution Layer

L2's shortfall is the same as Windsurf's: the local execution path does not disclose an OS-level sandbox mechanism, marked [To be filled]. The highlight is that the preview tab is designed as a debugging surface the agent can operate on — the loop of "change code → see rendering → read console → change again" can take place without leaving the editor, which is indirect construction toward L5 (the feedback loop).

5.3. L3 Orchestration and Control Layer (Key Focus of This Platform)

The "main agent - subagent" collaboration of SOLO is the core of its orchestration:

1. The main agent receives the end-to-end goal and completes task decomposition and plan creation.
2. The four specialized subagents (architect / developer / tester / operations, third-party figure) take on requirements analysis, technical solution, coding, debugging/testing, and deployment respectively.
3. Custom agents can be invoked as subagents, letting a team encapsulate domain workflows into dispatchable orchestration units.
4. Parallel cloud tasks provide 2–20 concurrent slots by tier, with tasks isolated from each other and progress synced across devices.
5. Plan mode locks the solution before work begins, and is the only productized "plan first, execute later" control point.

Compared with the other platforms in this group: GitHub Copilot's orchestration is bounded by PRs (see Article 03), Windsurf's orchestration is bounded by flows and checkpoints (see Article 04), and Trae's orchestration is bounded by "role division + concurrency count" — it encoded "which roles a software project needs" directly into the product. Its strength is the high completeness of managed delivery (from PRD to deployment); its risk is the adaptability of fixed role division to atypical tasks, and the uncontrollability of task decomposition quality — if decomposition goes wrong, the four subagents will each go off in the wrong direction in parallel. The official side has disclosed no validation mechanism for task decomposition quality, [To be filled].

5.4. L4 Memory and State Layer

No official checkpoint or automatic memory governance mechanism was found, marked "no results". L4's completeness sits between Cursor (files + cloud task state) and Windsurf (managed memory + checkpoints): if Global Memory holds, cross-session continuity looks good, but its governance (viewing, editing, deleting memory content) has not been disclosed.

5.5. Evaluation and Observation Layer

No official evaluation or observation mechanism was found: no public disclosure of trajectory tracing, agent output quality scoring, regression suites, or usage/quality dashboards, marked "no results". The only indirect observations available are cloud task progress sync and terminal output.

This layer has the greatest impact on the selection judgment for Trae: SOLO shifts the executor from humans to agents, which actually increases the acceptance burden — people go from being "the ones who write code" to "the ones who review code", while the platform provides no mechanized acceptance criteria. Therefore this group's recommendation is: teams using SOLO must first establish their own regression testing and pre-deployment gates before expanding the concurrent task count; managed delivery without mechanized criteria is equivalent to amplifying the problem of "almost right but not quite" from a single file to the whole project.

5.6. L6 Governance and Security Layer

Official disclosure gaps: no official documentation was found for hooks, permission modes, sandbox configuration, or organization-level policy; marked "no results". Only two facts are verifiable:

1. MCP OAuth: the full authorize, execute, invoke, revoke flow gives external tool integration a revocation channel, but no organization-level MCP allowlist was found.
2. Data practices (third-party evaluation): user chat data (including code snippets) may be used for analysis and model training when privacy mode is not enabled, i.e. training opt-out is opt-out rather than opt-in; codebase files are temporarily uploaded to compute embeddings and then deleted; a third party claims persistent outbound connections (even when the editor is idle); no telemetry-off option; no SOC 2 / ISO-class security certification documentation found.

The governance differences of the domestic route: Trae's dual-track operation is itself a compliance design — the domestic version (trae.cn) targets scenarios where data must not leave the country, and the free domestic personal tier lowers the adoption barrier. But for cross-border teams and international-version users, the above data practices constitute a material constraint: international-version users handling proprietary code should first confirm the current state of privacy mode and data retention policy before deciding the scope of adoption (current status marked [To be verified]; defer to the official privacy policy).

The conclusion drawn from the Amazon Q incident (2025-08-11, prompt injection induced deletion of AWS resources) is the same as in the previous two articles: for a platform with no sandbox disclosure and no mechanized enforcement mechanism, its L6 defense is in effect "agent-type role division + human confirmation + cloud isolation"; its behavior under prompt injection is entirely unknown, constituting a high-risk gap.

5.7. Six-Layer Capability Summary

6. Case Studies

Note: At the time of writing, no enterprise adoption case with quantified metrics published by Trae was found. The following are the measured results and reported figures from verifiable sources.

Case 1: third-party measurement across five scenarios. A third party ran measurements on SOLO across 5 scenarios (third-party figure): a browser mini-game (generated complete HTML/CSS/JS in about 5 minutes and started a preview service), batch CSV merging (about 3 minutes), a Vue + Vite + Tailwind full-stack blog skeleton (about 10 minutes), a web crawler (about 5 minutes), and runtime debugging (about 1 minute to analyze a Python traceback). The reusable conclusion is not the specific durations but the gradient of task type versus SOLO fit: small self-contained tasks with clear criteria and few dependencies fit best; tasks requiring deep context of an existing codebase were not covered by the measured scenarios.

Case 2: Builder mode generates a complete project. A third party reported that Builder mode 2.0 can generate pixel-perfect front-end code from Figma designs and hand-drawn sketches, with a complete-project generation success rate of 92% (third-party figure). The multimodal-input-to-code pipeline is the crux of this case: designs and sketches are inputs of the "visual criterion" kind, and paired with the preview tab's real-time rendering feedback, they form a generative loop of multimodal + real-time feedback.

Case 3: scale figures (marketing-oriented). A third party claims the domestic developer user count surpassed 12 million (third-party figure); the G2 platform lists only single-digit reviews with middling-to-low ratings (third-party figure). The huge tension between these two sets of numbers shows that distribution-driven user scale and deep-usage scale are two different things; when selecting, rely on your own pilots and trust neither end.

Case 4: official user testimonials. The official site hosts testimonials from multiple developers (e.g. completing a full application with SOLO within two weeks, team productivity rising significantly after two months), all of which are marketing statements marked [To be verified]; this article does not treat them as evidence of effectiveness.

7. Summary

7.1. Advantages

1. L1 most complete at its price point: four rule modes, 3-level subdirectory nesting, compatibility with AGENTS.md / CLAUDE.md / CLAUDE.local.md, and a clear resident/on-demand division between Rules and Skills.
2. Most aggressive managed-delivery paradigm: SOLO's end-to-end chain from requirements to deployment + 2—20 concurrent cloud tasks, making "AI as the executor" a product mainline rather than an add-on mode.
3. Multi-agent role division productized: custom agents can be deployed as callable subagents, and domain workflows can be encapsulated, dispatched, and shared.
4. Pricing and migration friendly: Lite $3 / Pro $10 is half of leading products; .agents/skills/ adopts an open standard, so skill assets can be reused across products.
5. Multimodal and domestic model ecosystem: designs and sketches generate code, video understanding; the domestic version relies on Doubao and DeepSeek with good adaptation to Chinese-language scenarios.

7.2. Limitations

1. L5 and L6 are almost blank: no official evaluation/observation mechanisms, and no sandbox, permission, or hook disclosure; of the six layers, four depend on user self-building or are missing.
2. Data governance constitutes a material constraint: training opt-out is opt-out; no security certification documentation; cross-border teams and international-version users must first verify the privacy policy status ().
3. Long-session and large-repo capabilities are questionable: third-party reviews note that long-session context retention is weaker than leading competitors, and large repos lack deep repository-level indexing ().
4. Task decomposition quality is uncontrollable: SOLO's fixed role division has limited adaptability to atypical tasks, and decomposition errors get amplified in parallel.
5. Enterprise-grade capabilities are missing: no organization-level disclosure of SSO / RBAC / auditing, and the enterprise procurement path is unclear.

7.3. Applicability Boundaries

7.4. Selection Recommendations

The criteria for choosing Trae are: budget-sensitive or Chinese-ecosystem priority, and the main tasks are self-contained, clearly-criteria'd small-to-medium deliveries. Its SOLO mode represents a directional hypothesis of AI IDEs — the delivery subject shifting from human to agent — already validated on small tasks, though the evidence on complex projects is still insufficient. Correspondingly, the ByteDance ecosystem (Doubao models, Volcengine cloud) is an implicit vendor decision when choosing the domestic version, and should be included in the evaluation.

Regardless of whether you adopt it, this group recommends doing two things before expanding SOLO usage: first, establish regression testing and deployment gates (the L5 gap must be compensated by self-building); first, pilot on the Free / Lite tiers and confirm the data policy item by item (the L6 gap must be closed with contracts and configuration, rather than default trust). The benefits and risks of managed delivery are both amplified by the concurrency count; add guardrails before scaling up.

Information Gap Declaration

1. Current latest version number: the official changelog shows the v3.5.6x series (2026-06), with the current stable version marked [To be filled]; a third-party 2.3.0 figure conflicts with the official one, marked [To be verified].
2. SOLO subagent role division (architect / developer / tester / operations): from a third-party retelling, marked [To be verified].
3. Availability and governance of Global Memory: from a third-party figure (Q3 2026), marked [To be verified].
4. MCP tool cap of 40: from an official community post rather than an official documentation page, marked [To be verified].
5. Domestic enterprise-tier pricing and Volcengine integration form: from third-party figures, marked [To be verified].
6. Data training and privacy mode status: from a third-party evaluation, marked [To be verified]; review against the official privacy policy before purchasing.
7. Local execution sandbox, organization-level governance, evaluation and observation mechanisms: no official disclosure found, marked "no results".
8. Enterprise adoption effectiveness data: no first-hand enterprise case with quantified metrics was found, and this article uses no unverifiable quantified effectiveness figures.

8. References

1. TRAE Official Website (International) — ByteDance, 2026. https://www.trae.ai/
2. TRAE Official Documentation — ByteDance, 2026. https://docs.trae.ai/
3. TRAE Official Documentation · Changelog — ByteDance, 2026. https://docs.trae.ai/ide/changelog
4. TRAE Official Website (Domestic) — ByteDance, 2026. https://www.trae.cn/
5. Volcengine Official Website — ByteDance, 2026. https://www.volcengine.com/
6. Model Context Protocol Official Site — MCP / AAIF, 2024—2026. https://modelcontextprotocol.io/
7. Introducing Agent Skills (Agent Skills open standard announcement) — Anthropic, 2025-10-16. https://www.anthropic.com/news/skills
8. SWE-bench Official Site — Princeton / community, 2023—2026. https://www.swebench.com/
9. 2025 Stack Overflow Developer Survey — Stack Overflow, 2025-07-30. https://survey.stackoverflow.co/2025/
10. DORA 2025 State of AI-assisted Software Development — Google Cloud / DORA, 2025. https://dora.dev/
11. Effective context engineering for AI agents — Anthropic, 2025. https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
12. Terminal-Bench Official Site — Stanford / Laude Institute, 2025—2026. https://www.tbench.ai/