1 Introduction↩︎

Large Language Models (LLMs) now play a central role in modern digital infrastructure. Usage has grown dramatically across both professional and personal contexts [1]. The Seed team has developed a comprehensive model family that includes general-purpose LLMs, multimodal models, open-source releases, code-specialized models, diffusion-based language modeling, formal theorem proving, and generative media systems: Seed1.6/1.8, Seed1.5-VL, Seed-OSS, Seed-Coder, Seed Diffusion, Seed-Prover, and Seedream/Seedance [2]–[13]. These models currently power a large-scale product ecosystem serving hundreds of millions of daily active users across applications. Meanwhile, the field is moving toward an agentic paradigm where LLMs tackle scientific research, complex software development, autonomous documentation learning, and multi-step real-world workflows. This shift motivates Seed2.0 Series (Pro / Lite / Mini), which is designed to deliver optimal user experience in large-scale production environments.

Seed2.0 prioritizes user experience under large-scale online deployment. Interactive quality is most directly shaped by four factors: the prevalence of visual and multimodal queries, the impact of inference latency on user satisfaction, the need for reliable complex instruction execution, and the demand for seamless coding assistance. Our design reflects these priorities:

• Robust Visual and Multimodal Understanding. A substantial fraction of real user queries involve images—screenshots, charts, scanned documents, and mixed-media content. Seed2.0 strengthens visual reasoning with reduced hallucination [14]–[16] and improves structured extraction from documents and figures [17], [18].

• Fast and Flexible Inference. Inference latency directly impacts user experience. Seed2.0 offers three model sizes (Pro / Lite / Mini), allowing developers to choose the appropriate balance between performance and speed for their specific use case.

• Reliable Complex Instruction Execution. In production, we observe that users frequently issue complex, multi-step instructions that require precise execution—tasks where success depends not on factual recall but on structured reasoning and constraint satisfaction. Recent benchmarks such as \(DeR^2\) [19] and CL-bench [20] capture exactly this demand. Seed2.0 treats it as a first-class requirement.

Seed2.0 also pursues a broader goal: handling tasks with real-world complexity. The Seed team has focused on raising the intelligence ceiling, moving from Olympiad-style problems toward research-level reasoning tasks. Seed2.0 tackles Erdos problems and performs Scientific Coding, pushing the boundaries of machine intelligence [21]–[24].

Current agent systems, however, show an interesting asymmetry: they solve competition-level problems yet often fail to reliably complete practical tasks end-to-end—like building a well-designed application in one pass [25]. Two factors explain this gap. First, real-world tasks span long horizons and multiple stages, but existing LLM agents struggle to autonomously construct effective workflows and accumulate experience over extended timescales [26]–[28]. Second, real-world knowledge is highly domain-specific and long-tailed; models strong in math and code often provide little value in specialized professional contexts. Seed2.0 addresses this through systematic ingestion of long-tail domain knowledge [29], [30].

This report presents our initial progress toward real-world complexity. To systematically track and guide this effort, we establish an evaluation framework spanning four dimensions: Science Discovery, Vibe Coding, Context Learning, and Real-World Tasks—each targeting a core aspect of complex, long-horizon agent performance. This framework serves both as a benchmark suite and an iterative development guide.

Note that the Seed2.0 Series still have gaps with international frontier LLMs, while Seed identifies the directions for enhancing the model’s capabilities for real-world complexity and makes great efforts to optimize Seed Model Series in this regard. Seed2.0 Series have considerable gaps with Claude in terms of coding, taking SWE-Evo and NL2Repo as examples. Seed2.0 Series have relatively obvious gaps with Gemini in terms of long-tail knowledge closely related to user experience, taking SuperGPQA and SimpleQA-Verified as examples.

In the following sections, we present Seed2.0’s performance across standard benchmarks-where it performs on par with leading international frontier models—and showcase representative cases of Seed2.0 solving complex real-world problems. We hope you enjoy exploring what Seed2.0 can do.

2 Seed2.0 Deployment Patterns and Developer Behavior↩︎

2.1 MaaS Usage in Mainland China↩︎

MaaS usage patterns in mainland China concentrate heavily on enterprise-facing digital industries and cognitively intensive applications (Figure 1 (a)).

At the industry level, the Internet sector dominates overwhelmingly, accounting for the vast majority of traffic. Consumer electronics, finance, new retail, and business services follow at a considerable distance. Traditional verticals like manufacturing, automotive, and communication each represent less than 1% of total usage, perhaps due to the capability shortcomings of the previous Seed model series. The leading industries share key characteristics: higher information density, faster product iteration cycles, and tighter integration between models and production systems. Seed2.0 operates primarily within large-scale digital infrastructures where models participate directly in core business workflows, not as peripheral productivity tools.

At the scenario level, we analyze data from the Doubao Collaboration Incentive Program^{1 2}, an open program that encourages partners and developers to grant authorization for the use of authentic model usage data (Figure 1 (a), right). Unstructured information processing and analysis dominates, representing the largest single share. Education, content creation, and search and recommendation follow as the next tier. Together, these top scenarios account for most deployment cases. Specialized applications—social companion, professional consulting, customer service and sales, quality inspection, coding, and structured information processing—each occupy substantially smaller shares. This pattern reflects how enterprises currently adopt AI: they start with scenarios requiring models to process heterogeneous data at scale, synthesize cross-domain knowledge, and generate actionable insights. More specialized use cases remain in earlier deployment stages.

The dominant scenarios impose specific technical demands: models must handle long contexts, integrate heterogeneous knowledge sources, execute multi-step instructions, and produce structured, high-fidelity outputs for downstream systems. In unstructured information processing—the largest category—enterprises use Seed Models to analyze user feedback, extract insights from multi-source documents, and generate structured reports for decision-making. Education applications power intelligent tutoring systems and personalized learning content. Content creation leverages multimodal capabilities for automated writing, video script generation, and multimedia synthesis. Search and recommendation systems integrate Seed Models for improved semantic understanding and ranking accuracy.

Seed Model functions as a workflow-oriented MaaS foundation rather than a lightweight conversational model, emphasizing multimodal understanding, long-context reasoning, structured generation, and tool-augmented execution for reliable end-to-end enterprise task completion.

Globally, this approach aligns with recent enterprise AI reports from OpenAI, Anthropic, and Google Cloud, which identify software engineering, research, analytics, customer support, and knowledge work as the fastest-growing enterprise AI categories [31]–[33].

2.2 Query Distribution in Agentic Coding↩︎

To understand real-world interaction patterns in agentic coding, we analyze trajectory-level developer usage data. The most striking finding is the dominance of frontend development (Figure 2). Queries related to page layout, styling, and UI logic management far exceed those for backend services, client-side applications, or full-stack integration. This distribution likely reflects both the iterative nature of frontend work—where visual feedback loops encourage frequent model interactions—and the relative accessibility of frontend tasks for AI assistance.

Programming language and framework statistics reinforce this pattern. Frontend-related languages (JavaScript, TypeScript, CSS, HTML) collectively account for the majority of code touched in these sessions. Among frameworks, Vue.js leads decisively—more than three times the adoption of React—reflecting the developer ecosystem in mainland China where Vue has historically enjoyed stronger community support.

By task type, bug fixing dominates, followed by refactoring and documentation work. This distribution suggests developers primarily turn to AI assistance for reactive maintenance rather than greenfield development. The high proportion of debugging queries indicates that error diagnosis and resolution remain significant pain points where AI provides clear value.

These patterns carry implications for model development. The concentration on frontend work suggests that JavaScript/TypeScript understanding, CSS layout reasoning, and framework-specific knowledge should be prioritized. The prevalence of bug-fixing queries indicates that models benefit from strong debugging capabilities—the ability to trace error messages, understand stack traces, and reason about program state.

2.3 Cost Efficiency↩︎

A key advantage of Seed2.0 lies in its cost structure. Table [tab:model95pricing] compares API pricing across major foundation models. While Seed2.0 achieves comparable performance to frontier models on user experience, its token pricing is roughly an order of magnitude lower.

This cost differential is particularly significant for enterprise MaaS deployments. In scenarios involving high-volume, workflow-integrated usage—such as the unstructured information processing and content generation tasks described above—API costs can become a limiting factor for adoption. Seed2.0’s pricing enables use cases that would be economically infeasible with more expensive alternatives, without sacrificing the reasoning and generation quality required for production systems.

The Seed2.0 Series offer tiered options to match different workload requirements. Seed2.0 Pro targets complex reasoning and long-context tasks where capability is paramount. Seed2.0 Lite provides a balanced trade-off for general-purpose applications. Seed2.0 Mini, with decode pricing under $0.50 per million tokens, opens possibilities for high-throughput, latency-sensitive applications where cost per query must remain minimal.

3 Comprehensive Evaluation Framework and Methodology↩︎

3.1 Fundamental Language Capacity↩︎

This section evaluates Seed2.0’s fundamental capabilities, including reasoning, complex instruction following, and broad knowledge understanding. We compare our results with representative frontier models, including GPT-5.2 High, Claude-Sonnet-4.5, Claude-Opus-4.5, Gemini-3-Pro High, and Gemini-3-Flash High.

Specifically, we evaluate Seed2.0 on AIME 2025 and HMMT 2025 [21], BeyondAIME [24], IMOAnswerBench (no tool) [34], AetherCode [35], LiveCodeBench(v6) [36], Codeforces Elo Rating [37], [38] on the problem set from June to December 2025, GPQA Diamond [23], PhyBench [39], BABE [40], KORBench [41], ARC-AGI-1/2 [42], Inverse IFEval [43], MARS-Bench [44], MultiChallenge [45], COLLIE [46], MMLU-Pro [47], SuperGPQA [48], and LPFQA [29], along with a set of internal benchmarks designed to reflect high-value real-world tasks. For Graphwalks, we use our in-house tokenization pipeline during evaluation, which leads to a mismatch in how tokens are counted compared with the official OpenAI Graphwalks tokenization and scoring setup.

3.1.1 Long-tail Professional Knowledge Benchmarks↩︎

While benchmarks such as SimpleQA or HLE are valuable probes of factual recall and difficult trivia, they often emphasize rare or idiosyncratic facts that are only occasionally useful in real-world workflows. Inspired by the design philosophy of SuperGPQA [48], we place stronger emphasis on professionally relevant long-tail knowledge that arises in practical work settings. To this end, we design two new benchmarks, LPFQA and Encyclo-K, to directly measure a model’s ability to function as a high-end search engine over long-tail professional knowledge.

LPFQA. LPFQA (Long-tail Professional Forum-based Question Answering) [29] is constructed from long-tail questions collected from professional forums and expert communities. It evaluates whether a model can correctly answer realistic, domain-specific questions encountered in daily work, covering fields such as programming, finance, engineering, medicine, and applied science. LPFQA therefore measures the model’s reliability in retrieving and synthesizing long-tail professional knowledge.

Encyclo-K. Encyclo-K [49] evaluates genuine mastery of book-level professional knowledge. It extracts atomic knowledge statements from books and dynamically composes them into evaluation instances, enabling flexible construction of test sets. This design supports both zero-shot and few-shot in-context learning (ICL) evaluation, allowing us to probe knowledge acquisition in pre-training and post-training stages. Compared with static QA datasets, Encyclo-K provides a scalable and compositional way to assess whether models internalize structured knowledge from long-form sources.

HLE-Verified. HLE-Verified (Humanity’s Last Exam—Verified) is a curated subset of Humanity’s Last Exam created in response to researchers reporting inaccurate, blurry, or underspecified questions in the original benchmark. We hire domain experts to review and select only questions that are clear, unambiguous, and confidently verifiable, thereby providing a more reliable evaluation of a model’s true performance on challenging expert-level problems.

3.2 Fundamental Vision Capacity↩︎

To comprehensively evaluate the vision capabilities of Seed2.0, we conduct extensive evaluations across 50 public image benchmarks and 24 public video benchmarks. For image understanding, the selected benchmarks cover nine distinct categories: Math, STEM, Visual Puzzles, Perception & Recognition, General VQA, Pointing & Counting, 2D & 3D Spatial Understanding, Document & Chart Understanding and LongContext Understanding. The following benchmarks are used for evaluating the image understanding capability of Seed2.0:

• MultiModal Math: Mathematical reasoning within a visual context constitutes a core challenge for modern multimodal models, requiring rigorous logic and symbol grounding. To evaluate this capability, we employ a suite of benchmarks including MathVista (testmini) [50], MathVision [51], DynaMath [52], MathKangaroo [21], and MathCanvas [53]. Regarding specific metrics, for DynaMath, we report the worst-case accuracy, requiring the model to correctly answer all 10 variants of a problem to score. For MathKangaroo, performance is measured by the average accuracy across all bimonthly competitions in 2025, while complete accuracy is utilized for MathCanvas.

• MultiModal STEM: Mastery of domain-specific knowledge in science and engineering is essential for expert-level assistance. We assess this competence using MMMU [14], MMMU-Pro [54], EMMA [55], SFE [56], HiPhO [57], XLRS-Bench [58], and PhyX [59]. In terms of evaluation settings, for MMMU-Pro, we aggregate scores across the Standard (10 options) and Vision subsets. For HiPhO, the reported metric is the average normalized score from 13 Physics Olympiad competitions. For XLRS-Bench, we calculate the macro average accuracy on the lite subset. For PhyX, we report the accuracy over the testmini openended subset.

• Visual Puzzles: Abstract reasoning and pattern recognition capabilities are tested through puzzle-solving tasks, which serve as a proxy for general intelligence. Our evaluation includes LogicVista [60], VPCT [61], ZEROBench [62], ArcAGI (Image) [42], and VisuLogic [63]. Specifically, for ZEROBench, we assess accuracy on both main questions and sub-questions. In the case of ArcAGI, models are provided with both text matrices and rendered images. We notice that the additional visual input significantly improves the performance of Seed2.0 on ArcAGI.

• Perception & Cognition: Ensuring reliability involves minimizing hallucinations and mitigating biases in visual interpretation. We investigate these fundamental perceptual traits using VLMsAreBiased [64], VLMsAreBlind [65], VisFactor [66], RealWorldQA [67], and BabyVision [68]. For VisFactor, we report the macro average accuracy over all constituent tasks.

• General VQA: The model’s versatility in handling open-ended queries and following instructions is reflected in General Visual Question Answering. This broad capability is gauged via SimpleVQA [15], HallusionBench [16], MME-CC [69], MMStar [70], MUIRBench [71], MTVQA [72], VibeEval [73], and ViVerBench [74]. Distinctively, for MTVQA, we deploy an LLM-judge (Deepseek-V3-0324) rather than rule-based matching to evaluate predictions. For VibeEval, raw scores on the 1–5 scale are normalized to a 0–100 range for reporting.

• Point & Counting: Fine-grained visual grounding and precise object enumeration are critical for tasks requiring high spatial fidelity. We measure these skills using CountBench [75], FSC-147 [76], and PointBench [77]. With respect to evaluation metrics, we report the Mean Absolute Error (MAE) for FSC-147.

• 2D & 3D Spatial Understanding: Comprehending geometric relationships and depth is vital for embodied agents and 3D-aware applications. We utilize a comprehensive set of benchmarks including BLINK [78], MMSIBench [79], TreeBench [80], RefSpatialBench [81], DA-2K [82], All-Angles [83], and ERQA [84]. To ensure a robust assessment of spatial consistency in MMSIBench, we apply the circular evaluation strategy [85].

• Document & Chart Understanding: The ability to extract information from dense texts and interpret complex infographics is key for professional workflows. This domain is covered by ChartQAPro [86], OCRBenchv2 [87], OmniDocBench [17], and CharXiv [18]. For scoring specifics, OCRBenchv2 results represent the average of overall English and Chinese scores. We use Normalized Edit Distance (NED) for OmniDocBench 1.5, and for CharXiv, we average accuracy across both descriptive questions (DQ) and reasoning questions (RQ).

• LongContext Understanding: Processing extensive visual inputs, such as multi-page documents or long-form videos, tests the model’s memory and temporal reasoning. To benchmark this capacity, we select DUDE [88], MMLongBench [89], LongDocURL [90], and MMLongBench-Doc [91].

For video understanding, we conducted a extensive evaluation across six dimensions: video knowledge, video reasoning, fundamental video perception and motion understanding, long-video understanding, multi-video understanding, and streaming video understanding, covering a total of 24 open benchmarks.

• Video Knowledge: We mainly adopt VideoMMMU [92], MMVU [93], and VideoSimpleQA [94] to evaluate the model’s video knowledge capability. These benchmarks evaluate not only the model’s mastery of world knowledge expressed in videos, but also its ability to acquire and internalize knowledge from video content.

• Video Reasoning: Multi-hop reasoning and video state tracking are core competencies for video reasoning. To this end, we conduct an in-depth evaluation using VideoReasonBench [95], Morse-500 [96], VideoHolmes [97], and Minerva [98]. Given that Morse-500 places a stronger emphasis on reasoning over physical dynamics, we increase the input frame rate to 5 FPS for this benchmark (the same setting is applied to all compared models).

• Motion & Perception: Foundational video perception, particularly motion perception, is central to video understanding. We therefore evaluate this capability using TVBench [99], ContPhy [100], TempCompass [101], EgoTempo [102], TOMATO [103], and MotionBench [104]. Given the prevalence of fast motion and rapid temporal state changes in these benchmarks, we increase the input frame rate to 2 FPS across all evaluations (the same setting is applied to all compared models).

• Long-Video Understanding: Long videos remain a major challenge in video understanding and a stringent test of a model’s multimodal long-context reasoning. To accurately assess performance under long-video settings, we evaluate on VideoMME [105], CGBench [106], LongVideoBench [107], VideoEval-Pro [108], and LVBench [109], which include many hour-scale videos.

• Multi-Video Understanding: Multi-video understanding introduces new challenges for cross-context reasoning and is prevalent in real-world applications. Accordingly, we use CrossVid [110] as the primary benchmark to evaluate the model’s performance on cross-video reasoning.

• Streaming: To assess real-time perception and interaction capabilities, we employ a comprehensive benchmark suite. OVBench [111] and OVOBench [112] are utilized to evaluate online reasoning and temporal awareness; LiveSports3K [113] emphasizes fine-grained sports event perception; ODVBench [114] tests generalization in autonomous driving scenarios; and ViSpeak [115] focuses on real-time visual referring capabilities.

3.3 Fundamental Agentic Capacity↩︎

With the transition from passive assistants to agentic systems, LLMs must go beyond single-turn responses and demonstrate the ability to plan, invoke tools, interact with environments, and complete multi-step tasks. We define this foundational layer as Fundamental Agentic Capacity. To avoid underestimating competing products, the final score is defined as the maximum of the score reported in the official documentation and the score obtained in our tests.

For better agentic evaluation, we conduct systematic refactoring of test scripts to optimize execution stability and reproducibility. We eliminate task-level entrypoint configurations to reduce redundant environment provisioning, consolidating execution environments into pre-built images. Where reference-script environments have degraded or contained errors, we perform targeted repairs to restore functionality. Additionally, we replace external package repositories with internal mirrors to ensure consistent dependency resolution.

We also implement quality-based filtering to remove problematic test cases. This exclusion criterion targets several categories: multi-container Docker Compose scenarios that introduced unnecessary complexity; test cases where reference solutions fail to pass their own validation; cases exhibiting non-deterministic behavior across runs; tasks causing abnormal disk consumption; network-dependent problems with inconsistent outcomes; and scenarios requiring extended downloads or complex validation procedures that undermine reproducibility.

Specifically, we evaluate Seed2.0 across five representative dimensions: Coding Agents, Search Agents, Tool Use, GUI Agents, and Deep Research. These benchmarks cover repository-level software engineering (e.g., Terminal-Bench [116], SWE-Lancer [117], SWE-Bench [118], Multi-SWE-Bench [119], SWE-Bench Pro [120], SWE Multilingual [121], Scicode [122], SWE-Evo [123], Aider Polyglot, ArtifactsBench [124], CodeSimpleQA [125] and SpreadsheetBench Verified [126]), and Trae In-House Bench covering frontend and backend production scenarios), broad and deep information seeking (e.g. BrowseComp [127], [128], HLE [22], WideSearch [129], FinSearchComp [30] and seal-0[130]), tool invocation and orchestration (e.g., \(\tau^2\)-Bench[27], BFCL-v4 [131], MCP-Mark [132], VitaBench [26]), agentic visual tasks(e.g. Minedojo-Verified [133], HLE-VL and MM-BrowseComp [134] ) and long-horizon research reasoning and synthesis (e.g., DeepConsult [135], Deep Research [136] and ResearchRubrics [137]). Unless explicitly stated, evaluations are conducted without external tools and follow each benchmark’s official protocol. For Terminal-Bench 2.0, we exclude three cases (extract-moves-from-video, mailman, and install-windows-3.11) due to network access restrictions and security considerations in our evaluation environment. The remaining tasks are adapted to our internal agent framework while preserving the original evaluation criteria.

3.4 Advanced Economically & Scientifically Valuable Tasks↩︎

As highlighted in the Introduction, the arrival of the Agent era fundamentally shifts the role of LLMs from answering isolated prompts to driving long-horizon, economically and scientifically valuable workflows. In this paradigm, models are expected to support scientific research, autonomously construct software systems, learn from user-provided context and documentation, and execute complex real-world tasks with tangible economic impact. Motivated by this shift, we build a set of scenario-grounded evaluations that directly reflect such real-world agentic workloads.

Specifically, we organize our advanced evaluations into four dimensions: Scientific Discovery, Vibe Coding, Context Learning, and Real-World Tasks. Each dimension is anchored by Seed-designed benchmarks targeting concrete failure modes observed in practice.

Scientific Discovery. We introduce Ainstain Bench [136] and BABE [138] to evaluate research-oriented capability. Ainstain Bench emphasizes scientific coding, measuring whether models can implement and manipulate computational procedures used in scientific workflows. BABE focuses on reasoning over interleaved textual and visual scientific information in the biological domain, assessing whether models can perform research-style inference grounded in multimodal evidence [135], [136].

Vibe Coding. We build NL2Repo-Bench to measure whether a model can complete an entire software repository from a natural-language specification in a single end-to-end process. This benchmark targets long-horizon repository construction, cross-file consistency, and dependency management, reflecting the emerging demand for extreme “vibe coding’’ scenarios [35]–[37].

Economically Valuable Fields. Beyond fundamental capabilities such as reasoning and knowledge, we prioritize high-value real-world applications to ensure that Seed2.0’s development aligns with practical economic utility. To this end, we have developed a suite of specialized in-house benchmarks [4] including:

• Education: Evaluates performance in teaching-oriented scenarios, including problem solving, grading, explanation, and question generation, covering core subjects across K–12 levels.

• Text Classification: Evaluates the model’s ability to analyze text and generate structured outputs or labels. This integrates compositional tasks—where multiple elements like intent and slots are identified in a single inference—with broader information processing, such as sentiment analysis and the synthesis of core viewpoints from unstructured data.

• Information Extraction: Assesses structured extraction of relevant elements (e.g., words, sentences, or fields) from heterogeneous documents, including meeting records, legal texts, contracts, and corporate knowledge bases.

Context Learning. In enterprise and developer-facing settings, users require strict execution based on supplied context, such as long manuals or internal documents. Beyond existing evaluations like CL-Bench [20] and KOR-Bench [41], we incorporate DeR\(^2\), which evaluates whether models can extract and utilize useful information from noisy long-form technical documents to perform reasoning and problem solving [19]. Furthermore, we introduce two in-house scenarios [4] to reflect agentic workloads:

• Customer Support Q&A: Assesses the ability to recognize user intent and synthesize answers after retrieving information from enterprise knowledge bases, specifically handling cases where recalled information is highly noisy.

• Complex Workflow: Validates the model’s capacity to complete sophisticated, continuous tasks by synthesizing complex information and instructions provided within the context.

Real-World Tasks. We construct fine-grained internal evaluations for end-to-end task fulfillment. In particular, we curate GDPVal-Verified, a reliable subset of GDPVal with rubric-based automatic evaluation, and build the comparable XpertBench [4]. In addition, we introduce WorldTravel [139] to measure the model’s ability to decompose goals and produce executable multi-step plans in real-world scenarios.

Overall, this evaluation suite operationalizes the vision described in our Introduction: assessing whether LLMs can function as agentic systems that complete real tasks, rather than merely answering questions. By grounding evaluation in realistic workflows and long-horizon completion, we obtain a more faithful measurement of advanced economically and scientifically valuable capability.

4 Results↩︎

4.1 Fundamental Language Evaluation↩︎

We evaluate Seed2.0 (Pro/Lite/Mini) on a comprehensive suite of fundamental language benchmarks spanning knowledge and science, mathematics, code and STEM reasoning, long-context understanding, multilinguality, instruction following, and hallucination robustness. [tab:language_large,tab:language_small] report the detailed results.

Overall, Seed2.0 Pro sits comfortably within the international leading group across core language capabilities. Our optimization is shaped by large-scale product feedback: for user-facing deployments such as Doubao, we prioritize instruction-following robustness, long-tail knowledge coverage, and long-context stability; for coding-oriented products such as Trae, code reasoning and front-end generation quality take precedence. The benchmark results reflect these choices.

Knowledge and Science. Seed2.0 Pro leads on HealthBench and remains neck-and-neck with GPT-5.2 and Gemini-3-Pro on SuperGPQA and Encyclo-K, surpassing them in several cases. These gains matter for production: real user queries often probe obscure facts and domain-specific knowledge that generic training underserves.

Mathematics, Code, and STEM Reasoning. Seed2.0 Pro demonstrates advanced proficiency in mathematical reasoning. It exhibits highly competitive performance on popular evaluation suites (AIME, HMMT) and performs on par with SOTA models on extremely challenging benchmarks such as IMOAnswerBench and MathApex. Notably, Seed2.0 Pro achieves gold-medal level performance in Olympiad-level mathematical competitions: 2025 International Mathematical Olympiad (IMO) and 2025 China Mathematical Olympiad (CMO). Beyond natural language reasoning, Seed2.0 also excels in formal theorem proving, demonstrating superior performance on the Putnam-200 (a random subset of 200 problems from PutnamBench [140]) and making strides in open Erdős problems. Table 1 and Table 4 report the results. Implementation details are provided in Appendix 12. In coding, it reaches a Codeforces Elo of 3020 and posts strong LiveCodeBench numbers. STEM-oriented benchmarks such as FrontierSci-research tell a similar story, with Seed2.0 Pro matching or edging out Gemini-3-Pro in multiple cases. This reflects our continued investment in deep reasoning and code-centric training.

Long Context Understanding. Seed2.0 Pro ranks first on the Frames leaderboard. While retrieval-heavy tasks such as MRCR and Graphwalks still show some headroom compared to other leading models, these gaps have limited impact on real-world user experience—and similar weaknesses are observed across other frontier models.

Instruction Following, Multilinguality, and Hallucination. Instruction-following capability sees clear gains over Seed1.8, which directly benefits complex user requests in deployment. Multilingual performance and hallucination robustness remain competitive, with room for further improvement in future iterations.

Complex Instruction Following. We run a fine-grained analysis using an in-house benchmark (see Table ¿tbl:tab:instruction95following95data?) tailored for Chinese-language production scenarios: 912 test cases across 17 weighted dimensions reflecting practical deployment importance.

As shown in Table 5, Seed2.0 Pro scores 75.26%, a +2.37% absolute gain over Seed1.8. The largest jumps come in tone control (+15.16%), phrasing adherence (+10.31%), and few-shot learning (+9.53%). In practice, this means more precise Chinese pragmatic effects—including subtle stylistic modes like tsundere-like affect and sarcastic or ironic (“yin-yang”) expression—and more reliable multi-constraint prompting. At the few-shot level, the model better infers structural and stylistic requirements implied by exemplars, including quantitative constraints such as paragraph counts or emoji quotas, and shows improved compliance with strict length limits in both Chinese and English.

Lite and Mini Variants. Seed2.0 Lite and Seed2.0 Mini offer strong efficiency–quality trade-offs. Across a wide range of benchmarks, our small models hold their own against counterparts from OpenAI and Google. Seed2.0 Lite in particular posts strong math and reasoning numbers while maintaining solid instruction-following performance— well-suited for latency-sensitive and cost-constrained deployments.

4.2 Vision Task Evaluation↩︎

We evaluate the performance of Seed2.0 (including Pro, Lite, and Mini variants) on a comprehensive suite of public visual-language benchmarks, comparing it against its predecessor Seed1.8 and several state-of-the-art models such as Gemini-3-Pro, GPT-5.2, and Claude-Opus-4.5. The evaluation covers a broad spectrum of capabilities, ranging from mathematical and STEM reasoning to visual puzzles, spatial understanding, and long-context document processing. 6 presents the detailed results, where Seed2.0 Pro demonstrates superior performance, achieving the highest scores across the majority of benchmarks.

Math and STEM Reasoning. In mathematical reasoning, Seed2.0 Pro demonstrates exceptional capability, achieving state-of-the-art results on MathVision (88.8), MathKangaroo (90.5), and MathCanvas (61.9), while tying for the top score on MathVista (89.8). Notably, Seed2.0 Lite also excels, securing the top spot on DynaMath (70.5). In STEM tasks, Seed2.0 Pro leads in EMMA (72.0), XLRS-Bench (54.6), and PhyX (72.1). On the remaining benchmarks, Seed2.0 Pro also delivers transformative gains compared to Seed1.8: scores on HiPhO and MMMU-Pro improved by 15.8 and 5.0, respectively, rapidly narrowed the gap with best methods.

Visual Puzzles and Logic. Seed2.0 Pro exhibits significant advancements in logical reasoning and visual puzzle solving. It achieves the highest scores on LogicVista (81.4) and ZeroBench (Main 12.0, Sub 47.6), demonstrating robust problem-solving abilities. On the challenging VisuLogic benchmark, Seed2.0 Pro scores 47.4, outperforming all counterparts by a notable margin. Although GPT-5.2 leads on ArcAGI-Image, Seed2.0 Pro secures a competitive second place (88.8 on ArcAGI1 and 43.3 on ArcAGI2), showing substantial improvement over Seed-1.8.

Perception and General VQA. For perception and recognition, Seed2.0 Pro demonstrates exceptional capabilities. It achieves SOTA results on VLMsAreBiased (77.4), VLMsAreBlind (98.6), and BabyVision (60.6) . In general VQA benchmarks, Seed2.0 Pro leads in SimpleVQA (71.4), MUIRBench (81.8), and VibeEval (81.4). Seed2.0 Pro consistently outperforms Seed1.8 across all general VQA tasks, highlighting its refined visual understanding.

Spatial Understanding and Counting. Seed2.0 Pro excels in spatial understanding and fine-grained localization. It sets new state-of-the-arts on DA-2K (92.3), RefSpatialBench (72.6), and BLINK (79.5), surpassing the strong baseline of Gemini-3-Pro. In counting tasks, Seed2.0 Pro achieves best performance on FSC-147 with a mean absolute error of 11.3 (lower is better), significantly improving upon Seed1.8 and competitor models.

Document and Long-Context Understanding. A standout feature of Seed2.0 Pro is its dominance in long-context understanding. It achieves SOTA scores on DUDE (72.4), MMLongBench (74.8), and MMLongBench-Doc (61.4). In document and chart understanding, Seed2.0 Pro also leads on ChartQAPro (71.2) and OmniDocBench 1.5, proving its efficacy in processing complex, information-dense visual inputs.

In summary, Seed2.0 Pro delivers state-of-the-art performance across a diverse array of visual-language tasks, particularly excelling in mathematics reasoning, perception proficiency, spatial reasoning, and long-context understanding, while Seed2.0 Lite and Mini offer competitive efficiency-focused alternatives.

4.3 Video Task Evaluation↩︎

We conduct a comprehensive evaluation of the Seed2.0 family (including Seed2.0 Mini, Seed2.0 Lite, and Seed2.0 Pro) across multiple dimensions of video capabilities, including knowledge, reasoning, perception, motion understanding, as well as long-term, multi-video, and streaming video analysis.

As shown in Table 7, Seed2.0 pushes the performance frontier for video understanding and delivers state-of-the-art results on multiple benchmarks, with exceptional performance in motion perception, reasoning, and streaming video understanding.

Video Knowledge. In terms of knowledge, Seed2.0 achieves leading performance on the multidisciplinary benchmark MMVU [93], and delivers results comparable to Gemini-3-Pro on VideoMMMU [92] and VideoSimpleQA [94], representing a substantial improvement over the previously released Seed1.8 [4]. In addition, it is worth noting that our lightweight model, Seed2.0 Mini, also performs strongly.

Video Reasoning. In video reasoning, Seed2.0 Pro continues to push the performance frontier. On VideoReasonBench [95], Seed2.0 surpasses human performance, with particularly strong results in visual state tracking, widely regarded as one of the most fundamental capabilities underlying video reasoning.

On Morse-500 [96], a highly challenging reasoning benchmark covering video abstract reasoning, physical reasoning, and planning reasoning, Seed2.0 further achieves a new state of the art, reaching 37.4% accuracy. Despite this progress, a substantial gap to human-level performance remains, and future iterations of the model will continue to close this gap.

Video Perception and Motion Understanding. Foundational video perception is critical to video understanding and reasoning. Among these perceptual competencies, motion understanding is particularly crucial for modeling temporal state transitions and tracking dynamic changes over time. Seed2.0 further strengthens its motion perception and understanding capabilities. As summarized in Table 7, Seed2.0 Pro attains state-of-the-art performance on the majority of benchmarks and substantially outperforms Seed1.8 and Gemini-3-Pro across several evaluations.

For TOMATO [103], we explore a Thinking with Tracking strategy in which we prompt to encourage the model to explicitly output per-frame bounding boxes for the moving target during reasoning, and then identifies the motion type based on the target’s trajectory. This strategy is effective for both the Gemini and Seed models, and yields meaningful gains on TOMATO. Nevertheless, performance on TOMATO and TVBench suggests that a considerable gap to human-level proficiency remains. We will continue to advance motion perception in subsequent iterations to further narrow this gap.

Long Video Understanding. For long-video understanding, Seed2.0 Pro achieves a breakthrough performance of 89.5 on VideoMME [105]. Seed2.0 also delivers strong results on LVBench and LongVideoBench, showing substantial improvements over Seed1.8 across these benchmarks. In addition, the entire Seed2.0 model family is equipped with VideoCut tool-use capabilities by default to improve long video reasoning.

Multiple Video Understanding. Multi-video understanding requires models to identify and integrate critical evidence across multiple video contexts, and is a core capability for real-world applications as well as video agents. On CrossVid [110], a benchmark for multi-video understanding, Seed2.0 Pro achieves a new state-of-the-art score of 60.3. Looking ahead, we will prioritize further improvements in multi-video understanding, with an emphasis on strengthening cross-context reasoning.

Streaming. Moving beyond static analysis, streaming video understanding and interactive reasoning enable systems to comprehend and respond to visual inputs in real-time, providing key capabilities for interactive products (e.g., Doubao video calling). Across multiple benchmarks, Seed2.0 Pro delivers further improvements, while Seed2.0 Lite surpasses Gemini-3-Pro/Flash in several evaluations with high efficiency.

Video Tool-Use: VideoCut. Seed2.0 also further enhances video tool-use capability, i.e., VideoCut. When processing long videos or tasks that require high-frame-rate perception, it can adopt VideoCut to replay relevant segments at a higher FPS, which is an intuitive and effective mechanism for video understanding and reasoning. As shown in Table 8, we evaluate the performance of enabling VideoCut for Seed2.0 Pro. With VideoCut, Seed2.0 Pro further raises the ceiling of long-video understanding, yielding substantial improvements on CGBench, LVBench, and the challenging ZeroVideo, which consists of challenging, real-world video reasoning scenarios, including fine-grained high-frame-rate motion perception and long-form, multi-hop reasoning over extended videos.

4.4 Fundamental Agentic Capacity↩︎

We evaluate Seed2.0 (Pro/Lite) on a diverse set of agentic benchmarks covering search agents, deep research, vision agents, coding agents, and tool use. [tab:agent_large,tab:agent_small] report detailed results.

Overall, Seed2.0 Pro lands in the top tier across agentic capabilities, with clear advantages on search, deep research, and vision agent tasks—the workloads that matter most for high-frequency user scenarios like information seeking, complex reasoning, and multimodal interaction.

Search, Deep Research, and Vision Agents. Seed2.0 Pro consistently leads or sits near the top on search and research-oriented benchmarks: HLE, BrowseComp, WideSearch and DeepSearchQA. On deep research tasks, it posts the best results on Deep Research and Research Rubrics. In vision-agent settings, Seed2.0 Pro pulls ahead of reported baselines by a wide margin on Minedojo-Verified, MM-BrowseComp, and HLE-VL—evidence of strong multimodal grounding for action-oriented tasks. Taken together, these numbers place Seed2.0 Pro at or near state-of-the-art on search, deep research, and vision agents.

Tool Use and Coding Agents. Tool use and coding-agent performance is solidly first-tier. Seed2.0 Pro holds its own on SWE-Bench Pro and SWE Bench Verified, and tops SpreadSheetBench for structured artifact manipulation. We also see distinctive gains on SWE-Evo, pointing to robust evolutionary code improvement. Beyond this, Seed2.0 Pro also delivers strong performance on general tool use tasks such as MCP-Mark, BFCL-v4 and \(\tau^2\)-Bench. That said, complex API orchestration and long-horizon code execution still leave room to grow.

Efficient Agentic Deployment. Among small models, Seed2.0 Lite consistently ranks first or second on efficient agentic benchmarks. It performs well on search and deep research tasks and posts excellent SpreadsheetBench numbers. Paired with significantly lower inference cost, Lite offers a practical quality–cost trade-off for large-scale and latency-sensitive deployments.

4.5 Advanced Economically and Scientifically Valuable Tasks↩︎

We further evaluate Seed2.0 on advanced tasks that reflect scientific discovery, economically valuable workflows, context-based learning, and real-world task completion. [tab:advanced_large,tab:advanced_small] report the detailed results.

Scientific Discovery. Seed2.0 Pro operates at the frontier. It posts strong numbers on FrontierSci-research and scientific coding benchmarks, and leads on AInstein Bench—signs of robust hypothesis-driven reasoning in research-style scenarios.

Real-World Economic Value. Beyond science, Seed2.0 Pro translates well to tasks with direct economic value. It tops XPert Bench and remains highly competitive on GDPVal and multiple ToB benchmarks. Notably, the model excels on user-oriented scenarios we explicitly optimize for: customer-service QA, information extraction, intent recognition, and K12 problem solving. These results reflect reliable instruction-following behavior in production.

Context Learning and Repository-Level Code. Clear headroom remains on context-driven learning and end-to-end vibe coding. Seed2.0 Pro trails the strongest baselines on DeR\(^2\) Bench and NL2Repo-Bench, suggesting that long-horizon context integration and repository-level code generation are still challenging. We have flagged these as priority directions and are actively pushing targeted research.

Efficiency at Scale. Seed2.0 Lite holds up well on advanced tasks among efficient models. It posts strong results on ToB real-world benchmarks, solid scientific discovery numbers, and competitive context-learning outcomes. On several advanced benchmarks, Lite beats GPT-5-Mini outright while offering favorable latency and cost.

Across agentic capacity and advanced real-world tasks, Seed2.0 delivers consistent top-tier performance. Seed2.0 Pro excels in search, deep research, vision agents, and scientific discovery; Lite provides a compelling efficiency-focused alternative for large-scale deployment.

5 Use Cases of Seed2.0↩︎

In this section, we demonstrate the applicability of Seed2.0 across diverse real-world scenarios, illustrating how the model addresses practical challenges in vibe coding, application operation, and even scientific discovery.

5.1 Vibe Coding↩︎

In the "Vibe Coding" setting, the model is evaluated on end-to-end software engineering behavior under realistic constraints rather than isolated code snippets. Tasks include interpreting underspecified requirements, forming executable plans, producing runnable artifacts, and iteratively refining solutions based on feedback until acceptance criteria are met.

To characterize Seed2.0’s capabilities in this regime, we present five representative case studies: algorithmically challenging code synthesis under compute constraints (§ 5.1.1), repository-level construction from requirements documents alone (§ 5.1.2), zero-regression debugging guided by unit tests (§ 5.1.3), cross-version upgrade debugging using release notes with full test suite validation (§ 5.1.4), and competition-level programming under official limits (§ 5.1.5). These settings vary supervision completeness, engineering scope, and failure signal observability, enabling comprehensive assessment of planning, implementation, verification, and iterative correction in realistic development workflows.

5.1.1 Complex Code Generation↩︎

To evaluate Seed2.0’s capacity for complex code synthesis, we examine its performance on the "feal-linear-cryptanalysis" task from TerminalBench 2.0 [116], classified as Hard. This task provides a simplified FEAL-like block cipher as a Feistel network, a reference decryption program, and multiple plaintext–ciphertext pairs. The objective is to construct a known-plaintext attack that recovers the secret key and decrypts additional ciphertexts. Naïve brute-force enumeration over the effective key space is computationally infeasible within benchmark constraints, requiring algorithmic insight rather than exhaustive search.

As shown in Figure 3, Seed2.0 completes this task in 12 interaction rounds through systematic repository analysis. It inspects the project structure, examines feal.c to reconstruct the round function, and studies documentation to align its implementation with expected formats and correctness criteria. This structured approach minimizes specification inconsistencies and informs development of attack.py, a cryptanalytic program tailored to the specific FEAL variant.

The attack’s effectiveness derives from combining algebraic inversion with time–memory trade-offs. Seed2.0 derives inverse transformations for the cipher’s internal operations, including the reversal of rotation and modular-addition steps in relevant components, and implements an explicit inverse routine for the \(F\)-function (f_inv_function). Seed2.0 then precomputes an inverse mapping table for the expand() operation, a \(20\)-bit to \(32\)-bit expansion described in the task specification, enabling efficient back-mapping from expanded subkey material to seed candidates and eliminating redundant computation during the search phase.

Crucially, Seed2.0 uses a meet-in-the-middle strategy to avoid exhaustive enumeration over the 80-bit key space. It splits the computation at an intermediate state and matches partial forward and backward results, trading memory and preprocessing for a large reduction in runtime and making the attack feasible under benchmark constraints.

After recovering a candidate key, Seed2.0 thoroughly validates it. It checks the key against all 32 plaintext–ciphertext pairs and cross-verified outputs with the provided decrypt program, including early spot checks. Only after consistent agreement finishes, it decrypts the 100 ciphertexts in ciphertexts.txt, writes outputs to plaintexts.txt, and reports successful completion.

This case study is notable because Seed2.0’s approach differs from the benchmark reference implementation. This divergence supports the claim that it performed structural program analysis and task-specific cryptanalytic reasoning rather than matching a known solution. The layered verification further indicates a rigorous engineering workflow in a complex setting.

5.1.2 Project Repository Construction↩︎

To evaluate the model’s Project Repository Construction capabilities, we use the NL2Repo [141] task, which requires building a library-level Python repository from an empty workspace using only a requirements document. The deliverable is a Decouple-style configuration utility that separates configuration from code while remaining installable, testable, and usable as a standard Python package. Seed2.0 completes the task in 37 interaction rounds. As shown in Figure 4, the workflow follows three standard phases: Specification Analysis, Implementation & Configuration, and Testing & Debugging. Seed2.0 first reads start.md and extracts requirements for configuration decoupling, multi-source loading. Implementation centers on decouple.py, which defines eight core classes for source precedence, parsing, and type conversion.

Quality assurance relies on a pytest suite (tests/test_decouple.py) with 22 model-written test cases. Failures reveal issues that were fixed iteratively: installing a missing pytest dependency; addressing a Python 3.12-related configuration-reading import failure by switching to parser.read_file(); adding a guard for boolean casting on empty strings; moving fixtures to global scope to avoid class-scoping conflicts; and correcting a parameter-name mismatch (flat versus choices) to match the intended API. This pattern indicates systematic debugging guided by test output.

After these fixes, all 22 tests pass. The model also runs example code, validates installation via “pip install -e .”, and confirms cross-directory imports, showing both functional correctness and packaging readiness. Overall, Seed2.0 follows a structured, engineer-like workflow from requirements to implementation, testing, and debugging, producing a complete, convention-compliant repository with documentation.

5.1.3 Iterative Code Debugging↩︎

To systematically analyze the iterative code debugging capabilities of Seed2.0, we present a detailed case study from SWEBenchPro [120]. This case presents a zero-regression refactoring that relocates the Qt warning suppression logic and its tests from log.py to qtlog.py, correcting module boundaries without altering external behavior.

As shown in Figure 5, the refactoring preserves runtime semantics, the public API, and downstream compatibility across four key stages: Understanding & Location, Edition & Optimization, Local Verification, and Global Verification. The goal is not redesign but stronger verification through test relocation and extension. The core constraint is strict behavioral equivalence, identical behavior to the original, with the same effects on all non-Qt and non-matching logs.

More specifically, during Edition & Optimization, correctness is validated at the handler boundary. Non-matching warnings continue to appear in the console and captured logs, while matching warnings are fully suppressed before reaching handlers. Suppression follows the original semantics: a message is hidden if it equals the filter string or begins with the configured pattern; otherwise, it prints normally. The filtering mechanism, including hide_qt_warning and QtWarningFilter, is migrated to qtlog.py, with tests moved to test_qtlog.py. For backward compatibility, log.py retains an import layer so existing call sites remain intact, consolidating qtlog.py as the single source of truth.

Validation proceeds through five phases: boundary scanning, migration with compatibility wiring, unit regression testing, integration verification, and final cleanup. Results show 56 passing unit tests, verified import compatibility, accurate handler outputs, and complete reference coverage. A logger-parameter issue found during testing is fixed and revalidated, ensuring precise behavioral equivalence. The refactoring delivers comprehensive test coverage and production-level maintainability.

5.1.4 Complex Iterative Debugging↩︎

In this Release-Note-only SWE-EVO upgrade case, the agent’s objective shifts from resolving a single, well-scoped issue (as in SWE-bench) to upgrading a library across versions using only release notes as guidance. With no explicit file-level directives, the model has to infer which components encoded the promised behavioral changes and treat the full unit test suite as the acceptance oracle, including both historically passing and historically failing tests. As shown in Figure 7, across 79 turns, the workflow converges on an exploration→implementation→verification loop: it first maps the repository and dependency surface (via directory inspection and setup.py) and identifies the codebase as DVC, then iteratively implements cross-cutting upgrades spanning OS compatibility, logging semantics, CLI/API consistency, concurrency safety, and user-facing output correctness.

The most involved change is the end-to-end introduction of an --all-commits flag across push, pull, status, and metrics, because it requires more than CLI plumbing: the agent has to thread a single semantic intent from command entry points through repository operations and into revision traversal, ultimately extending the branch iteration mechanism (brancher.py) and ensuring repository initialization invokes the updated traversal path (init.py).

In parallel, it handles platform constraints by gating speedcopy imports using sys.getwindowsversion() (a robust choice over fragile string parsing) and refines progress reporting by switching tqdm-related locking to threading.RLock() to mitigate re-entrancy and multi-thread contention. It also improves UX fidelity by suppressing the “No changes” message in metrics diff when suppression is requested, demonstrating attention to behavioral edge cases that tests commonly encode. Notably, the PyDrive2 large-file upload item is resolved as a dependency conformance check, pydrive2>=1.4.8 is already declared, so the agent avoids unnecessary code churn, aligning with a minimal-change upgrade strategy. Verification proceeds through repeated targeted test runs and final holistic validation, including checking CLI help output to ensure argument exposure matched the intended interface design.

5.1.5 Competition-Level Programming↩︎

To evaluate capabilities on competition-level programming, we assess model performance across five recent ICPC Official contests in late 2025. These five contests include the ICPC 2025 World Finals Baku (Sept 4, 2025), the ICPC 2025 Xi’an Regional Contest (Oct 19, 2025), the ICPC 2025 Chengdu Regional Contest (Oct 26, 2025), the ICPC 2025 Wuhan Regional Contest (Nov 2, 2025), and the ICPC 2025 Shanghai Regional Contest (Nov 23, 2025). We utilize test cases, time limits, and memory limits consistent with the official competitions. We compare the Pass@8 score for each model, which represents the percentage of problems solved when allowing each model up to eight independent generations per problem. The input prompt for the models contains only the problem statement and a simple instruction requiring the solution in C++, without the use of multi-turn interaction or external tool calls.

The results are shown in Figure 8. Seed2.0 Pro achieves a Pass@8 score of 73.02%, significantly outperforming GPT-5.2 and Gemini-3-Pro. Compared against human team performance, Seed2.0 Pro achieves Gold Medals in all five contests.

5.2 Real-world Application Operation↩︎

In productivity software, GUI interactions are state-dependent: toolchains vary with workspace or mode changes; parameters interlink across editing rounds; and interaction details (e.g., dialog prompts, focus management, double-clicking, drag-to-align) can trigger cascading failures. To examine whether Seed2.0 exhibits semantic understanding and long-horizon execution for complex interfaces, we evaluate it in two settings: (i) FreeCAD, a CAD environment emphasizing modeling context and constraint logic, and (ii) CapCut, a video-editing environment emphasizing timeline alignment and multi-track editing. These case studies illustrate how the model executes multi-step procedures while tracking interface state and self-corrects when UI errors arise.

5.2.1 FreeCAD Operation↩︎

As shown in Figure 10, we evaluate whether Seed2.0 can perform semantic GUI understanding in a stateful CAD environment beyond template-based interactions. The model successfully tracks contextual information, including active workbenches, bodies, operational modes, and attachment planes. When encountering errors such as incorrect tool selection or unresponsive dialogs, the model demonstrates expert-like recovery by formulating micro-plans (e.g., "create circle, constrain diameter, exit sketch") and executing them. The model’s self-reflection mechanism functions as an online control loop under noisy UI feedback. Rather than simply documenting errors, the model diagnoses failure modes (misclicks, mode errors, or UI lag), applies targeted corrective actions (dismissing dialogs, reselecting tools, or reconfirming constraints), and resumes the parametric workflow. This behavior suggests a generalizable framework for robust GUI agents: maintain system invariants, restore operational context, and proceed with the intended task.

Based on this, correctness is anchored by redundant verification rather than “looks right.” The model validates the final solid via both the Properties panel (Data → Shape → Volume/Area) and an independent Python readout (obj.Shape.Volume, obj.Shape.Area), turning a GUI procedure into a checkable outcome and reducing common silent failures like wrong selection or wrong document state.

5.2.2 CapCut Operation↩︎

Further, we demonstrate Seed2.0’s capabilities on operational CapCut tasks. As shown in Figure 12, we present a case where Seed2.0 functions as an execution-oriented editor, tasked with producing a frame-accurate CapCut (Jianying Pro) project. The system maintains coherent goal states across multiple operations, video splitting, transition placement, audio splicing, and global effects application, while employing reflective self-correction to recover from UI-level errors. These errors include missed double-clicks, incorrect effect selection, and misaligned audio placement.

The trace reveals Seed2.0’s core strength: adaptive control under partial failure. Upon detecting actions that fail to yield the intended UI state, the system re-identifies the correct control sequence. For instance, it re-targets the "Audio" panel, closes obstructive pop-ups, or switches from "click add" to "drag-to-join" for dissolve transitions. Crucially, the system re-anchors the workflow to canonical timeline invariants, project starts at 00:00:00:00 and splice boundary at 00:00:02:29, before proceeding. This re-anchoring mechanism prevents error propagation in multi-stage editing workflows.

The specification’s HH:MM:SS:FR timecodes are meaningful only under a consistent project frame rate. Therefore, Seed2.0’s emphasis on precise alignment and playhead repositioning serves as a critical control mechanism that guards against silent drift at split and splice boundaries. Within this frame-accurate regime, the system applies the requested "Dissolve" transitions by locating them in CapCut’s transitions library and placing them at each clip junction created by the three splits. Similarly, the system extends a snow-style atmospheric overlay to cover the full 00:00:00:00–00:00:08:26 program window by applying an effect clip on the timeline and adjusting its duration to match the target interval.

5.2.3 Image-to-Code Generation↩︎

Here are two examples of code generation in real-world application scenario. As shown in Figure 13, the task is to recreate a website according to the given image. Some features are clearly required in the query prompt, including number rolling count animation, XP bar animation, 3D tilt effect + highlight sweep animation for Mission cards, and dynamic shimmer texture for progress bars. By saving the prediction code part as an HTML file and opening it directly in any browser, we could get a website almost the same as the input with all required features. As shown in Figure 14, the task is to recreate a 3D plot as a matplotlib expert, in which x-y projection, x-z projection, and y-z projection relationships are provided. By compiling the generated Python code, we could get a 3D phase space which follows the projection as input.

5.3 Multidisciplinary Scientific Research↩︎

To comprehensively examine Seed2.0’s utility in cross-disciplinary scientific research, we evaluate its capacity to facilitate scientific discovery through two complementary task scenarios: code generation across scientific domains and cross-domain analytical reasoning.

5.3.1 Multidisciplinary Scientific Research Coding↩︎

In real-world development of multidisciplinary scientific software, problems typically involve coupling among mathematical representations, physical conventions, and large-scale codebases, leading to subtle yet high-cost errors. Seed2.0 demonstrates robust generalization and debugging capabilities on such cross-domain tasks by identifying structural causes of anomalous behavior and producing verifiable fixes through dependency tracing and execution context analysis. The following sections present representative case studies from quantum computing, numerical general relativity, and computational chemistry.

5.3.1.1 Quantum Computing.

On specialized and emerging tasks, Seed2.0 demonstrates remarkable generalization capabilities. In the quantum software engineering track of AInstein Bench [136], Seed2.0 successfully resolves a subtle bug in Qiskit’s Solovay–Kitaev (SK) compiler stemming from a representation mismatch. The bug arises because Qiskit performs SK recursion in \(\mathrm{SO}(3)\) (Bloch-sphere rotations), whereas target single-qubit gates belong to \(\mathrm{SU}(2)\). Because \(\mathrm{SU}(2)\) double-covers \(\mathrm{SO}(3)\), the recursion cannot distinguish \(U\) from \(-U\), so global phase information can be dropped and must be restored when mapping the result back to an \(\mathrm{SU}(2)\) circuit. The reported symptom, decomposing Pauli-\(Y\) yields an operator exactly equal to \(-Y\) with an inconsistent global phase, reflects this structural phase ambiguity rather than approximation error.

Seed2.0’s approach to this problem exemplifies systematic debugging methodology. The system first reproduces the failure using a minimal test case, verifies that the discrepancy manifested as a pure sign flip (phase difference of \(\pi\)), and localizes the root cause to the post-processing boundary in solovay_kitaev.py where phase assignment occurs. Critically, Seed2.0 avoids modifying the mathematically correct recursion itself. After rejecting gate-specific constant-offset patches that would lack generalizability, it implements a principled solution: aligning operators by computing the phase \(\phi\) such that \(e^{i\phi} U_{\text{decomp}} = U_{\text{target}}\), then validating that this fix generalizes across all single-qubit gates without introducing regressions. This trajectory demonstrates agentic debugging through domain-theoretic diagnosis, precise code-level intervention at the appropriate interface, and rigorous generalization testing.

This case underscores Seed2.0’s capability in quantum compiler debugging, a demanding scientific software engineering task that cannot be resolved through pattern matching or localized edits alone. Success requires understanding the mathematical abstraction (Lie group coverings), mapping this abstraction onto the software architecture, and identifying where theoretical guarantees must be enforced in the implementation. The demonstrated trajectory indicates that Seed2.0 can effectively navigate tasks requiring a deep integration of mathematical reasoning and software engineering principles.

5.3.1.2 General Relativity.

Seed2.0 demonstrates robust performance on numerical relativity tasks from AInsteinBench [136]. When tasked with implementing numerical-relativity functionality in the Einstein Toolkit’s legacy Fortran codebase (Cactus framework), the agent autonomously diagnoses and resolves a critical integration failure: it identifies that AHFinder_dis.F, referenced by the build system, is missing from src, then traces its call site in AHFinder.F to determine the routine’s role in multi-horizon tracking during binary black-hole simulations. This systematic debugging approach, locating missing components and verifying execution context, demonstrates practical software engineering capabilities beyond isolated code generation.

The implementation exhibits both physics insight and numerical rigor. Seed2.0 correctly interprets "distance" as proper distance in curved spacetime rather than coordinate separation, implementing \(s = \int \sqrt{g_{ij}\,dx^i\,dx^j}\) with the full spatial 3-metric including all off-diagonal components (\(g_{xx}, g_{yy}, g_{zz}, g_{xy}, g_{xz}, g_{yz}\)). The solution properly accesses metric variables using Einstein Toolkit conventions, integrated with AHFinder’s output patterns, and includes robustness checks for invalid handles and absent horizons. While the production implementation incorporates additional refinements, grid symmetry handling, horizon–line intersections via spherical harmonics, and improved quadrature, the agent’s solution captures the essential physics with appropriate simplifying assumptions.

This performance illustrates Seed2.0’s capacity to navigate the multidimensional challenge space of scientific computing: translating physical concepts (Riemannian geometry, geodesic integration) into numerical methods (interpolation, quadrature) within complex software architectures (framework APIs, mixed-language codebases with F77/F90 syntax and preprocessor macros). The agent’s successful integration of domain knowledge with system-level engineering reflects the core competencies that AInsteinBench is designed to evaluate.

5.3.1.3 Computational Chemistry.

Meanwhile, Seed2.0 can identify and resolve a subtle defect in PySCF’s density-fitting (DF/RI) implementation that manifests exclusively with complex-valued density matrices. Density fitting accelerates \(J/K\) matrix construction by replacing four-center integrals with auxiliary-basis three-center tensors. The diagnostic symptom, a substantial energy deviation of approximately \(0.9\) Hartree in DF calculations with complex SCF inputs, occurs despite excellent agreement between real and complex non-DF energies (precision to \(10^{-11}\) Hartree). This pattern immediately localizes the failure to the DF \(J/K\) pipeline rather than general complex-number handling. Seed2.0 reproduces the error and traces the execution path to pyscf/df/df_jk.py, correctly identifying that the underlying computation routes through low-level C AO2MO kernels whose naming and packing conventions assume real-valued, symmetric arrays. By instrumenting the computation to isolate energy contributions, Seed2.0 determines that \(J\) remains accurate under the DF approximation while \(K\) exhibited severe corruption. This diagnostic pattern is consistent with complex buffers being misinterpreted as real memory, a failure mode that produces plausible but silently incorrect outputs. The implemented fix is minimal yet mathematically rigorous. Seed2.0 intercepts complex density matrices, decomposes \(D\) into real and imaginary components, executes the existing optimized real DF pathway twice, and recombines results via linearity: \(K(D_{\mathrm{re}} + iD_{\mathrm{im}}) = K(D_{\mathrm{re}}) + iK(D_{\mathrm{im}})\). Post-patch validation confirms that DF complex energies match both DF real and non-DF references to numerical precision (\(\sim 10^{-11}\) Hartree). Seed2.0 further verifies robustness by executing the existing test suite and ensuring comprehensive coverage of complex-DF behavior.

This resolution exemplifies Seed2.0’s capability to integrate domain expertise, understanding \(J/K\) matrix construction under density fitting, with systems-level debugging skills, including analysis of ctypes-to-C boundaries and packed storage conventions. The resulting patch maintains computational efficiency while preserving the stability of the real-valued fast path.

5.4 Multidisciplinary Scientific Research Analysis↩︎

In this section, we systematically evaluate Seed2.0’s scientific research analysis capabilities across tasks that mirror real-world workflows. We design four thematic categories spanning theoretical derivations, computational modeling, and experimental design. Our assessment examines whether Seed2.0 produces outputs that are technically sound, internally consistent, and aligned with domain conventions, including explicit assumptions, appropriate methodological choices, and reproducible procedures. We further evaluate its justification of technical decisions and the transferability of outputs to downstream applications, thereby characterizing its performance across multidisciplinary research settings.

5.4.0.1 Complex Mathematics Solution.

To demonstrate the model’s capability in Seed2.0 to solve complex mathematical tasks, we present proofs of two Erdős Problems [142], generated through a iterative refinement pipeline with Seed2.0. Figure 22 shows a summary of the output and demonstrates that Seed2.0 can address frontier-level challenges in mathematical research. Human experts have verified these proofs for correctness, and we have formalized the proof of Erdős 1051 using Seed-Prover 1.5 [6]. The model demonstrates a strong capacity for systematic reasoning and rigorous proof construction. See Appendix 12 for evaluation details and full outputs.

5.4.0.2 Cannabidiol (CBD)-Mediated Modulation Analysis.

To assess Seed2.0’s performance on complex biomolecular simulation tasks, we evaluate its ability to design a coarse-grained molecular dynamics (CG-MD) workflow for studying cannabidiol (CBD)–mediated modulation of the \(\alpha\)​7 nicotinic acetylcholine receptor (\(\alpha\)​7 nAChR). The task requires generating a complete protocol for identifying CBD binding sites, including system preparation, ligand parameterization, trajectory analysis, and specification of expected results with downstream applications. Critically, the model needs to justify all methodological choices and parameter settings, thereby demonstrating both practical competence in MD workflow construction and understanding of underlying simulation principles.

As shown in Figure 24, Seed2.0 exhibits several notable strengths. The model correctly identifies an appropriate PDB structure and outlines a standard procedure for molecular structure preparation. The selected density functional theory (DFT) level for quantum mechanical calculations is suitable for the system. Notably, Seed2.0 proposes using the partition coefficient (\(\log P\)) as a validation metric to assess force field accuracy, a thoughtful choice for evaluating hydrophobic ligand behavior. The workflow incorporates proper gmx commands to address periodic boundary condition (PBC) artifacts, an essential preprocessing step. Time definitions are clearly stated with concrete decision criteria and corresponding GROMACS commands. The model also suggests appropriate validation strategies, including all-atom simulations and free energy perturbation (FEP) and molecular mechanics Poisson-Boltzmann surface area (MMPBSA) calculations for cross-validation.

However, the output contains several limitations. Most significantly, the model hallucinates specific details regarding PDB entries and cited literature, requiring careful verification before implementation. Such inaccuracies can mislead researchers and compromise workflow reliability.

Overall, Seed2.0 generates a logically structured and reasonably comprehensive workflow with detailed operational steps and validation approaches aligned with standard practices. The output provides a useful initial template for protocol development that can be iteratively refined. Nevertheless, the hallucination issues represent a critical weakness that must be systematically addressed through manual verification before practical application.

5.4.0.3 Maleimide Polyacetylene Analysis.

To further evaluate Seed2.0’s capabilities, we examine its performance on a more challenging task: analyzing a high-performance copolymer synthesis route based on a ROMP–precursor oxidation strategy. This two-step protocol provides access to electron-deficient olefin polymers that are difficult to obtain through conventional polymerization methods. The assessment evaluates the model’s understanding of strategic route design, catalyst selection, an atypical coupling deprotonation–oxidation mechanism, and the relationships between polymer microstructure and macroscopic properties, thereby testing its grasp of complex organic reaction mechanisms, reaction selectivity, and fundamental structure–property correlations.

As shown in Figure 26, the model demonstrates strong mechanistic reasoning. In the ROMP step, it accurately identifies the ring-opening metathesis polymerization behavior of cyclobutene derivatives and correctly recognizes that highly strained, electron-deficient cyclobutene substrates require highly active Schrock-type catalysts. The model further notes that this strategy offers distinct advantages over traditional copolymerization approaches, including superior molecular-weight control, improved regularity of the alternating architecture, and effective suppression of side reactions. For the second-step TEA/oxidant coupling deprotonation–oxidation process, the model correctly identifies that triethylamine alone is too weak a base to drive a simple acid–base equilibrium and that the subsequent oxidation shifts the equilibrium forward. It appropriately proposes a pathway involving single-electron abstraction by the oxidant to generate radical intermediates, demonstrating sound reasoning for this less common organic oxidation mechanism.

The model also provides a thorough structure–property analysis. It correctly explains that the precursor polymer \(P\) contains \(sp^3\)-hybridized carbon centers that increase backbone flexibility, resulting in good solubility and processability. After oxidation, formation of the mPA backbone creates a highly conjugated, planar structure that maximizes \(\pi-\pi\) stacking, enabling efficient intrachain electron delocalization and interchain charge transport. The model recognizes that the maleimide moiety, as a strong electron-withdrawing group, effectively lowers the LUMO energy level to support an air-stable n-type semiconductor architecture.

However, the model exhibits one notable limitation. Although its macroscopic mechanistic narrative is logically consistent, it fails to identify the more specific charge-transfer (CT) complex mechanism operative in this reaction. Specifically, it does not recognize that TEA and the oxidant may first form a CT complex that serves as the reactive initiating species. Instead, the model relies on a more generic acid–base equilibrium coupled with electron-transfer explanation. Consequently, its account of how the weakly basic TEA efficiently triggers the reaction, particularly the key kinetic details, lacks mechanistic depth.

5.4.0.4 Golgi Proteins Analysis.

We next analyze a case involving an integrative experimental design that uses mice as a model organism to examine genetic engineering and animal model construction, cell biology and subcellular fractionation, and multi-omics analytical workflows. This study demands substantial domain knowledge and involves several nontrivial technical details. At the level of genetic engineering and model generation, the central question is how to leverage the Cre-LoxP system to achieve cell-type-specific and spatiotemporally controlled gene expression.

As shown in Figure 28, the key challenge from a cell biology perspective is how to rapidly isolate highly purified Golgi apparatus from complex brain tissue while preserving molecular integrity. Conventional fluorescence-activated cell sorting (FACS) is unsuitable because it is time-consuming and can induce cellular stress, both of which compromise the intended downstream analyses. The multi-omics component spans sample preparation, mass spectrometry measurements, and the analytical logic across proteomics, lipidomics, and metabolomics.

The proposed model exhibits several notable strengths. The experimental workflow is specified in fine-grained steps: beyond proposing a transgenic mouse strategy, it provides actionable CRISPR/Cas9 targeting details, including homology-arm design at the Rosa26 (R26) locus, guide RNA (gRNA) design considerations, and genotyping primer planning. It articulates a stringent quality-control framework at critical steps of Golgi immunoprecipitation (Golgi-IP), explicitly defining negative-control strategies (e.g., assaying endoplasmic reticulum, mitochondrial, and nuclear markers to exclude contamination) and offering quantitative purity assessment using a Pearson correlation coefficient (PCC)-based metric. For the multi-omics analysis, statistical criteria for differential testing are appropriately defined, specifically \(FDR<0.05\) and \(|LFC| \ge 1.2\).

One potential limitation concerns the choice of tag protein. The model selects Giantin as a Golgi marker; however, Giantin is a large matrix protein that may introduce more nonspecific binding during immunoprecipitation than transmembrane Golgi proteins such as Tmem115, and may pose a greater risk of perturbing Golgi architecture.

Overall, Seed2.0 performs at a level exceeding typical PhD student expectations, demonstrating the ability to integrate experimental details across subdisciplines. Rather than stopping at high-level strategy, it produces a feasible protocol with implementable steps. One practical consideration is that many PhD students would rely on commercial kits or established reagents rather than developing every component de novo; nevertheless, within a knowledge-driven framework, the model’s response is well-constructed and scientifically sound.

5.5 Automated Model-on-Model Behavioral Diagnostics↩︎

As evaluation ecosystems grow in scale and diversity, manual analysis of benchmark results becomes increasingly costly and difficult to standardize. We build an automated model-on-model diagnostic pipeline that uses LLMs to analyze the evaluation outcomes of peer models across heterogeneous benchmarks. The system aggregates metric scores and behavioral statistics, including token usage, formatting compliance, turn counts, emoji frequency, best-of-\(N\) statistics and other derived metrics, alongside instance-level outputs, reasoning traces, and execution trajectories. Through a three-layer design that separates data processing, scenario-adaptive analytical workflows, and report synthesis, the framework scales to large case volumes and helps algorithm researchers efficiently iterate on models by exposing model weaknesses, strategy trade-offs, and concrete behavioral issues such as code-switching and repetitive CoT patterns. Table 9 shows that the pipeline scales across diverse benchmarks and produces structured findings with quantified throughput and resource statistics.

6 Conclusion↩︎

The Seed2.0 model series takes a key step forward in the intelligent evolution of solving complex real-world tasks. First, the Seed team identifies users’ real needs, and selects or abstracts a series of benchmarks based on these real needs and complex real-world scenarios to build a reliable evaluation system. Based on the reliable and forward-looking evaluation system, Seed2.0 focuses on solving long-tail knowledge problems and complex instruction following problems, thereby enhancing the reliability of the model in complex and long-range real-world tasks. In addition, Seed2.0 has world-leading reasoning intelligence, visual understanding capabilities, and search capabilities, which meet the most real needs of a large number of users. The model card provides a large number of real use cases to prove that the Seed2.0 model begins to have the ability to handle initial complex real-world tasks, thus bringing more value to hundreds of millions of users.

7 Contributors↩︎

The authors are listed in alphabetical order by their first names. Some names refer to the authors’ internal aliases at the company.

8 FreeCAD Parametric Modeling: GUI Agent Case Study↩︎

8.1 Task Overview↩︎

8.2 Complete Workflow Visualization↩︎

Figure 29 illustrates the key milestones of the 96-step modeling process, from software initialization to programmatic verification. The agent successfully navigated through multiple interface challenges, demonstrating robust error recovery and systematic problem-solving capabilities.

8.3 Detailed Execution Trace↩︎

Below we present key reasoning traces from selected critical steps, highlighting the agent’s decision-making process and error recovery strategies.

Phase 1: Software Initialization (Steps 1-8)↩︎

Phase 2: Base Sketch Creation (Steps 9-30)↩︎

Phase 3: Dimensional Constraints (Steps 31-39)↩︎

Phase 4: First Pad Extrusion (Steps 40-52)↩︎

Phase 5: Rectangular Sketch Creation (Steps 53-78)↩︎

Phase 6: Second Pad Extrusion (Steps 79-82)↩︎

Phase 7: Programmatic Verification (Steps 83-96)↩︎

8.4 Agent Performance Analysis↩︎

Execution Statistics↩︎

• Total Steps: 96 sequential operations

• Error Recovery Instances: 8 failed tool selections, all successfully recovered

• UI Navigation Strategy: Shifted from toolbar icons to menu-based navigation after failures

• Element Selection Strategy: Adopted Elements panel method after direct clicking proved unreliable

• Verification Precision: 6 decimal places via Python API (vs. typical 2 decimals from GUI inspection)

Key Findings↩︎

1. Adaptive Error Recovery: When direct toolbar icon clicking failed (Steps 22-27, 44-47), the agent systematically switched to menu-based navigation, demonstrating flexible problem-solving rather than repetitive failed attempts.

2. Robust Selection Strategy: After encountering unreliable direct geometry clicking (Steps 31-33, 65-73), the agent learned to consistently use the Elements panel as a more reliable selection mechanism.

3. System Response Awareness: The agent exhibited patience with UI delays by using explicit wait commands (Steps 42, 50, 70), preventing premature actions that could derail the workflow.

4. Scriptable Verification: Rather than relying on visual GUI property inspection, the agent employed FreeCAD’s Python API for precise numerical verification, yielding higher-precision results critical for engineering applications.

8.5 Workflow Summary↩︎

8.6 Lessons for GUI Agent Design↩︎

This case study reveals several design considerations for future GUI automation systems:

1. Icon Ambiguity: CAD toolbars contain visually similar icons (circle, arc, point). Agents would benefit from OCR-based tooltip reading or enhanced icon classification models.

2. Selection Reliability: Direct geometric entity clicking proves unreliable in complex 3D environments. Structured selection via hierarchical element trees provides more robust alternatives.

3. Fallback Strategies: Menu-based navigation, while slower, offers unambiguous tool access. Agents should maintain hybrid strategies (toolbar-first, menu-fallback).

4. Verification Paradigm: Programmatic verification via scripting APIs provides superior accuracy over visual GUI inspection, particularly for numerical engineering tasks.

9 TerminalBench2.0-Cryptanalysis Agent: FEAL Linear Attack Case Study↩︎

9.1 Task Overview↩︎

9.2 Algorithm Analysis and Attack Strategy↩︎

Phase 1: Understanding the Cipher Structure↩︎

y[2] = g(x[3]^x[2], x[1]^x[0], 1);
y[3] = g(x[3], y[2], 0);
y[1] = g(x[1]^x[0], y[2], 0);
y[0] = g(x[0], y[1], 1);

temp = (a + b + x) & 0xFF;
return ((temp << 2) | (temp >> 6)) & 0xFF;

Phase 2: Attack Design — Meet-in-the-Middle↩︎

Phase 3: Implementing the F-function Inverse↩︎

def rotr2(x):  # Inverse of 2-bit rotation
    return ((x >> 2) | (x << 6)) & 0xFF

def f_inv_function(output_val):
    # Extract y bytes from output
    y = [output_val & 0xFF, ...]
    
    # Reverse G operations:
    temp_y1 = rotr2(y[1])
    x1_xor_x0 = (temp_y1 - y[2]) & 0xFF
    
    temp_y2 = rotr2(y[2])
    x3_xor_x2 = (temp_y2 - x1_xor_x0 - 1) & 0xFF
    
    temp_y3 = rotr2(y[3])
    x3 = (temp_y3 - y[2]) & 0xFF
    x2 = (x3_xor_x2 ^ x3) & 0xFF
    
    temp_y0 = rotr2(y[0])
    x0 = (temp_y0 - y[1] - 1) & 0xFF
    x1 = (x1_xor_x0 ^ x0) & 0xFF
    
    return combine_bytes([x0, x1, x2, x3])

Phase 4: Key Recovery Implementation↩︎

exp_map = {}
for k in range(0, 1<<20):  # 2^20 iterations
    e = expand(k)
    exp_map[e] = k
# Result: 1,047,882 entries (some collisions)

Phase 5: Verification and Decryption↩︎

for i, (P, C) in enumerate(pairs):
    computed_C = encrypt(P, k0, k1, k2, k3)
    if computed_C != C:
        print(f"Pair {i} failed")
        break

$ echo "14898973196205001976" > test.txt
$ ./decrypt test.txt 0x68e63 0x62571 0x1f61c 0xb74a5
367472469947502207  # Matches expected plaintext!

def decrypt(ciphertext, k0, k1, k2, k3):
    key = [expand(k0), expand(k1), 
           expand(k2), expand(k3)]
    
    # Reverse final swap: C = merge(R4, L4')
    left = getright(ciphertext)  # Was R4
    right = getleft(ciphertext)  # Was L4'
    
    # Reverse post-round mixing
    left ^= right
    
    # Reverse 4 Feistel rounds (backwards)
    for round_num in range(3, -1, -1):
        temp = left
        left = right
        mixed = f_function(temp ^ key[round_num])
        right = temp
        left ^= mixed
    
    # Reverse pre-round mixing
    right ^= left
    
    return merge(left, right)

9.3 Attack Performance Analysis↩︎

Efficiency Gain:

• Brute force approach: \(2^{80} \approx 1.2 \times 10^{24}\) operations (infeasible)

• Meet-in-the-middle attack: \(2 \times 2^{20} \approx 2.1 \times 10^6\) operations

• Speedup factor: \(\sim 10^{18}\) times faster!

9.4 Key Findings and Agent Behaviors↩︎

1. Cryptanalytic Reasoning: The agent correctly identified that direct brute force of the \(2^{80}\) keyspace is infeasible, and autonomously designed a meet-in-the-middle strategy that exploits the Feistel structure to reduce complexity to \(O(2^{21})\).

2. Mathematical Inversion: Successfully derived the inverse of the F-function (\(F^{-1}\)) by analyzing the composition of G-functions and their rotation operations. This required understanding modular arithmetic and bit rotation properties.

3. Systematic Verification: Rather than accepting the first key candidate, the agent implemented multi-stage verification:

   • Used pair 0 & 1 to build delta map

   • Used pair 2 to derive \(k_1\)

   • Used pair 3 to verify \(k_1\) consistency

   • Verified against all 32 known pairs

   • Cross-checked with original decrypt binary

4. Efficient Precomputation: Built reverse lookup tables (expand map, delta map) to avoid redundant calculations during the search phase, demonstrating optimization awareness.

5. Code Quality: Implemented clean, modular code with helper functions (getleft, getright, merge, g_function, f_function, f_inv_function) mirroring the original C implementation for consistency.

9.5 Recovered Keys and Final Results↩︎

Task Completion Status:

• ✔ Recovered all 4 round keys from known plaintext-ciphertext pairs

• ✔ Verified keys against 32 pairs with 100% accuracy

• ✔ Successfully decrypted 100 ciphertexts from ciphertexts.txt

• ✔ Saved decrypted plaintexts to plaintexts.txt

• ✔ Cross-validated results using original decrypt binary

9.6 Lessons for Cryptanalysis Agent Design↩︎

This case study demonstrates several capabilities essential for autonomous security research agents:

1. Algorithm Analysis: Ability to read and understand cryptographic implementations from source code, identifying exploitable structural weaknesses (Feistel network properties, reduced keyspace).

2. Mathematical Reasoning: Deriving inverse functions through algebraic manipulation and understanding of composition properties—critical for working backwards from ciphertexts.

3. Attack Strategy Design: Autonomously selecting appropriate cryptanalytic techniques (meet-in-the-middle) based on problem constraints rather than attempting naive approaches.

4. Computational Efficiency: Recognizing when precomputation and lookup tables provide better amortized complexity than repeated calculations.

5. Multi-Stage Verification: Building confidence through progressive validation rather than trusting single-point checks, reducing risk of false positives in key recovery.

6. Code-Data Consistency: Maintaining faithful translations between different implementations (C \(\leftrightarrow\) Python) while preserving algorithmic correctness.

Security Implications: This task highlights the importance of adequate key sizes in cryptographic systems. The 20-bit key reduction (from standard 128-bit keys) made the cipher vulnerable to known-plaintext attacks within seconds on commodity hardware. Production systems must use cryptographically secure key lengths to resist modern computational attacks.

10 NL2Repo: Python-Decouple Library Implementation↩︎

10.1 Task Overview↩︎

10.2 Agent Execution Trace↩︎

10.3 Key Agent Capabilities Demonstrated↩︎

1. Specification Parsing: Extracted structured requirements from 39KB natural language document, identifying implicit constraints (e.g., Python 3.12 compatibility issues).

2. Error-Driven Development: Systematically debugged ImportError (read_config not available) by consulting Python 3.12 ConfigParser API documentation and adapting implementation.

3. Backwards Compatibility: Ensured API exports work from both expected locations using from qtlog import hide_qt_warning # noqa: F401 pattern.

4. Production Quality: Generated complete package infrastructure including LICENSE (MIT), MANIFEST.in, setup.cfg for PyPI distribution.

10.4 Performance Metrics↩︎

Final Validation:

$ python -c "from decouple import config; \;
  print('DEBUG =', config('DEBUG', default=False, cast=bool))"
Success! DEBUG = False

$ pip install -e .
Successfully installed python-decouple-3.8

Task Completed: Fully functional, installable Python package matching all specifications.

11 SWE-bench Pro: Qt Logging Module Refactoring↩︎

11.1 Task Overview↩︎

11.2 Agent Execution Trace↩︎

# Add to qtlog.py (lines 31-46)
class QtWarningFilter(logging.Filter):
    def __init__(self, pattern: str) -> None:
        super().__init__()
        self._pattern = pattern
    
    def filter(self, record: logging.LogRecord) -> bool:
        do_log = not record.msg.strip().startswith(self._pattern)
        return do_log

# Add to qtlog.py (lines 49-58)
@contextlib.contextmanager
def hide_qt_warning(pattern: str, logger: str = 'qt') -> Iterator[None]:
    log_filter = QtWarningFilter(pattern)
    logger_obj = logging.getLogger(logger)
    logger_obj.addFilter(log_filter)
    try:
        yield
    finally:
        logger_obj.removeFilter(log_filter)

from qutebrowser.utils import log
with log.hide_qt_warning(...):

# In log.py (line 35)
from qutebrowser.utils.qtlog import hide_qt_warning, QtWarningFilter  # noqa: F401

$ pytest tests/unit/utils/test_qtlog.py -xvs
===== 5 passed in 0.06s =====

$ pytest tests/unit/utils/test_log.py -xvs
===== 51 passed in 1.65s =====

# Import from both locations
from qutebrowser.utils.log import hide_qt_warning as h1
from qutebrowser.utils.qtlog import hide_qt_warning as h2
assert h1 is h2  # Same function object - PASS

# Simulate qtnetworkdownloads.py usage
with log.hide_qt_warning('QNetworkReplyImplPrivate', 'qt-tests'):
    logger.warning('QNetworkReplyImplPrivate::error...')  # Filtered
    logger.warning('Other warning')  # Passes through
# Result: Only "Other warning" appears - CORRECT

11.3 Refactoring Analysis↩︎

11.4 Key Software Engineering Practices↩︎

1. Incremental Migration: Agent performed refactoring in 5 systematic steps rather than bulk copy-paste, reducing risk of breaking changes.

2. Backwards Compatibility: Used Python re-export pattern (from qtlog import *) to maintain existing API surface while reorganizing internals.

3. Test-First Validation: Moved tests after moving code, then validated all tests pass before declaring success — ensuring no behavior regression.

4. Dependency Analysis: Searched codebase for all usages (grep -r "hide_qt_warning") to identify affected modules before making changes.

Impact: Zero breaking changes, improved code organization, all 56 tests passing.

12 Evaluation Details on Advanced Mathematical Reasoning↩︎

12.1 Natural Language Proving↩︎

We adopt an iterative refine pipeline based on the solve-verify-refine framework [143]. Under this paradigm, Seed2.0 Pro generates candidate solutions, autonomously identifies logical flaws, and refines its outputs to satisfy strict Olympiad scoring criteria. 1 reports the results.

Notably, the high scores achieved by Seed2.0 Pro are not merely the result of hallucinated correct final answers. Instead, the model demonstrates a strong capacity for systematic reasoning and rigorous proof construction. The solve-verify-refine iterative pipeline ensures that every step of the deduction is logically coherent and mathematically rigorous, fully validating that Seed2.0 can complete complex mathematical reasoning tasks reliably rather than generating specious correct answers.

12.2 Formal Theorem Proving↩︎

Beyond natural language reasoning, we test Seed2.0 on formal theorem proving using Putnam-200 (randomly sampled from [140])—200 formalized Putnam Competition problems evaluated in an agent-based multi-turn setup with Lean and Python tool access [6]. 4 reports the results.

Seed2.0 Pro reaches 35.5% Pass@8, a new state-of-the-art among comparable general-purpose models. This substantially surpasses Gemini-3-Pro and also exceeds our previous dedicated prover, Seed-1.5-Prover [6]. Seed2.0 Lite follows at 30.5% Pass@8, showing that strong formal reasoning survives even under efficiency constraints.

These results hint at meaningful transfer from natural language math reasoning to formal proof search. Unlike specialized provers trained primarily on formal corpora, Seed2.0 is optimized as a general-purpose model; its Putnam performance suggests that symbolic reasoning developed in natural language contexts can transfer to formal theorem proving.

12.3 Case study on Erdos Problems↩︎

This section demonstrates the AI agent’s capability to solve challenging open problems from Paul Erdős’s problem collection, covering combinatorial geometry (Erdős 652) and analytic number theory (Erdős 1051).

12.3.1 Erdos 652: Distinct Distances in Planar Point Sets↩︎

12.3.2 Erdos 1051: Irrationality of Infinite Series↩︎

Seed-Prover 1.5 also formalized this problem at https://github.com/ByteDance-Seed/Seed-Prover/blob/main/SeedProver-1.5/erdos_1051.lean.

References↩︎