Source-linked AI summary
Alita: Generalist Agent Enabling Scalable Agentic Reasoning with Minimal Predefinition and Maximal Self-Evolution
Jiahao Qiu, Xuan Qi, Tongcheng Zhang, Xinzhe Juan, Jiacheng Guo, Yifu Lu, Yimin Wang, Zixin Yao, Qihan Ren, Xun Jiang, Xing Zhou, Dongrui Liu, Ling Yang, Yue Wu, Kaixuan Huang, Shilong Liu, Hongru Wang, Mengdi Wang
TL;DR
General-purpose agents often depend on manually predefined tools and workflows, creating coverage and flexibility limitations. Alita instead combines one core direct-solving capability with autonomous MCP construction, adaptation, and reuse. It achieves top-ranking GAIA validation performance and also reports results on Mathvista and PathVQA, while its MCP reuse improves smaller-LLM agents; its main stated limitation is reliance on LLM coding ability.
Problem
Existing general-purpose agents rely heavily on manually engineered workflows, predefined tools, and hardcoded components, limiting coverage, creativity, and flexibility across tasks.
Method
Alita uses a web agent as its single core capability and autonomously generates, adapts, executes, and reuses task-related MCPs instead of relying on static predefined tools.
Results
75.15% pass@1 and 87.27% pass@3 on GAIA validation rank Alita among the top general-purpose agents; MCP reuse also significantly improves smaller-LLM agents, including Level 3 accuracy from 3.85% to 11.54%.
Takeaways & Limitations
Alita supports scalable agentic reasoning through a radically simple design, while generated MCPs can be reused by other frameworks and smaller-LLM agents.
Takeaways & Limitations
Alita relies heavily on the LLM’s coding capability and performs worse than traditional generalist agents when that capability is poor.
Abstract
from arXiv · showhide
Recent advances in large language models (LLMs) have enabled agents to autonomously perform complex, open-ended tasks. However, many existing frameworks depend heavily on manually predefined tools and workflows, which hinder their adaptability, scalability, and generalization across domains. In this work, we introduce Alita--a generalist agent designed with the principle of "Simplicity is the ultimate sophistication," enabling scalable agentic reasoning through minimal predefinition and maximal self-evolution. For minimal predefinition, Alita is equipped with only one component for direct problem-solving, making it much simpler and neater than previous approaches that relied heavily on hand-crafted, elaborate tools and workflows. This clean design enhances its potential to generalize to challenging questions, without being limited by tools. For Maximal self-evolution, we enable the creativity of Alita by providing a suite of general-purpose components to autonomously construct, refine, and reuse external capabilities by generating task-related model context protocols (MCPs) from open source, which contributes to scalable agentic reasoning. Notably, Alita achieves 75.15% pass@1 and 87.27% pass@3 accuracy, which is top-ranking among general-purpose agents, on the GAIA benchmark validation dataset, 74.00% and 52.00% pass@1, respectively, on Mathvista and PathVQA, outperforming many agent systems with far greater complexity. More details will be updated at $\href{https://github.com/CharlesQ9/Alita}{https://github.com/CharlesQ9/Alita}$.
1 Introduction
Alita addresses the limited coverage, creativity, and flexibility of heavily engineered generalist agents through minimal predefinition and maximal self-evolution. It uses a simple architecture to construct task-specific MCPs and reports strong benchmark performance despite avoiding complex predefined tools and workflows.
- Motivation: Existing general-purpose agents rely on manually designed workflows, predefined tools, and hardcoded components, limiting coverage, creativity, and flexibility.The cited passage also identifies interface and environment mismatches as a limitation of predefined tools.
- Design principles: Alita follows minimal predefinition by using one core capability and general-purpose modules instead of manually engineered components for specific tasks.Its direct problem-solving capability is the web agent.
- Design principles: Alita follows maximal self-evolution by dynamically generating, adapting, and reusing MCPs according to task demands.MCP construction replaces static, predefined tools with on-the-fly capability expansion.
- Contribution: Alita is presented as a radically simple architecture intended to support scalable and generalizable agent frameworks.The contribution emphasizes simplicity as a design strength rather than a constraint.
- Empirical results: 75.15% pass@1 and 87.27% pass@3 on GAIA validation rank Alita among the top general-purpose agents, surpassing OpenAI’s Deep Research at 67.36% pass@1.The result is reported despite Alita using no complex predefined tools and workflows for specific tasks.
2 Related Works
Related work spans generalist-agent collaboration, autonomous agent and workflow generation, tool creation, and MCP-based tool connection and retrieval. Alita builds on these directions by wrapping generated valid tools into reusable MCPs.
- Generalist Agents: Generalist-agent research includes task decomposition with specialized toolkits, multi-agent collaborative development, and systems that build world models.OWL, Omne, and OpenAI Deep Research exemplify these approaches.
- Auto-Generating Agents: Auto-generating-agent methods create task-specific agents, workflows, or interactive development architectures.Examples include AutoAgents, OpenHands, and AFlow.
- Tool Creation: Tool-creation methods generate, retrieve, extend, prune, or execute code-based tools at different levels of task granularity.CRAFT, TroVE, CREATOR, and AutoAgent represent this line of work.
- Model Context Protocol: MCP standardizes connections between AI systems and external data sources and services, while RAG-MCP retrieves relevant tools from MCP descriptions.Alita wraps generated valid tools into MCPs for subsequent reuse by itself and other agents.
3 Methods
Alita solves tasks through a minimal manager-centered architecture that plans needed tools, searches open-source resources, generates and executes scripts, and stores successful tools as reusable MCPs.
- Architecture: Alita’s manager agent orchestrates a web agent with basic tools rather than relying on extensive manually designed toolkits.The framework uses brainstorming to plan task-specific tools and then enhances its capabilities autonomously.
- Architecture: The system iteratively analyzes tasks, identifies functional gaps, and triggers MCP brainstorming to synthesize required capabilities.The Manager Agent collaborates with the Web Agent while integrating intermediate results toward a final output.
- Task processing: Each task may involve external web queries, new-tool synthesis, and execution within isolated environments.These steps occur after constructing an augmented prompt containing the original query.
- Capability reuse: After successful tool generation and result formulation, the corresponding script is transformed into an MCP and stored for future reuse.Reasoning steps, intermediate code, and final outputs are systematically logged.
3.2 Manager Agent
The Manager Agent coordinates Alita’s minimal toolkit by deciding when new capabilities are needed, decomposing tasks, and routing subtasks to retrieval or tool-generation components.
- Coordination: The Manager Agent first uses MCP Brainstorming to determine whether additional tools are needed and specify their requirements.This makes capability expansion task-dependent rather than fully predefined.
- Coordination: It decomposes tasks into subtasks and dispatches them either to the Web Agent or to external-tool generation.Retrieved web information can support subsequent tool construction and task completion.
- Tool usage: MCP Brainstorming detects functional gaps and outlines supplementary-tool specifications, while ScriptGeneratingTool turns specifications into tools.CodeRunningTool completes the concise manager toolkit for Alita’s minimal design.
3.3 Web Agent
The web agent retrieves external information when internal knowledge is insufficient, using a lightweight text interface and modular navigation tools to support multi-site research and code retrieval.
- The web agent retrieves relevant information from external sources when internal knowledge is insufficient.
- It traverses multiple websites, extracts relevant segments, and returns URLs or raw content.
- SimpleTextBrowser, VisitTool, PageUpTool, and PageDownTool provide the web interface and page-level navigation.
- GoogleSearchTool and GithubSearchTool support open-web lookup, reusable open-source tool discovery, and context-aware tool planning.
3.4 MCP Creation Component
Alita’s MCP creation component assesses capability gaps, generates external tools from task descriptions and open-source resources, validates them in isolated environments, and supports reuse or refinement.
- MCP Brainstorming assesses whether the current framework can complete a task and provides tool-generation references when capabilities are insufficient.
- ScriptGeneratingTool constructs external tools from subtask descriptions, code suggestions, and potentially useful GitHub resources.
- Generated scripts include environment-creation and cleanup scripts, making them self-contained, executable, and reusable.
- CodeRunningTool executes generated scripts in an isolated environment and registers successful tools as reusable MCPs.
- The environment planner extracts dependencies and setup instructions from repository or script metadata to build isolated execution profiles.
- Runtime environments are initialized locally in parallel without administrative privileges or containerization technologies.
- During execution, the environment is activated before code interpretation to support isolation and reproducibility.
- Initialization failures trigger fallback recovery strategies; unsuccessful recovery causes the tool to be discarded and logged.
4 Experiments
Alita is evaluated across general-purpose, visual mathematical, and medical visual-question-answering benchmarks against several agent baselines. It achieves top reported performance on GAIA and strong results on MathVista and PathVQA.
- Benchmarks: GAIA contains 466 real-world questions spanning daily tasks, scientific reasoning, web browsing, and tool usage.
- Benchmarks: MathVista evaluates mathematical reasoning in visual contexts, including visual comprehension, programming, and related skills, using 100 sampled examples.
- Benchmarks: PathVQA evaluates medical visual question answering across visual understanding, spatial reasoning, medical knowledge integration, and language processing, using 100 sampled examples.
- Baselines: The comparison includes OctoTools, Open Deep Research-smolagents, AutoAgent, OWL, A-World, and OpenAI Deep Research.
- Results: 75.15% pass@1 and 87.27% pass@3 are achieved on the GAIA validation dataset with Claude-Sonnet-4 and GPT-4o, ranking Alita at the top.
- Results: 74.00% pass@1 on MathVista and 52.00% pass@1 on PathVQA are achieved with Claude 3.7 Sonnet and GPT-4o.
- Results: Table 1 reports accuracy by GAIA difficulty level and overall MathVista and PathVQA performance, with pass@1, pass@2, and pass@3 based on repeated runs and best-answer selection.
5 Analysis
Alita-generated MCPs improve other agents across GAIA difficulty levels, including agents using smaller LLMs, while Alita’s own performance depends strongly on the underlying model’s coding capabilities.
- 5.1.2 Reuse by Open Deep Research-smolagents: Alita-generated MCPs improve ODR-smolagents’ performance across GAIA Levels 1, 2, 3, and the average.The MCPs are generated while running GAIA with Claude-3.7-Sonnet and GPT-4o, then reused by another framework.
- 5.1.3 Reuse by Base Agent on Smaller LLM: Alita-generated MCPs significantly improve the smaller-LLM base framework, with Level 3 accuracy tripling from 3.85% to 11.54%.The MCPs encapsulate capabilities distilled from more powerful models for use by agents based on GPT-4o-mini.
- 5.1.3 Reuse by Base Agent on Smaller LLM: MCP reuse can help smaller models process challenging tasks without independently developing the full reasoning chain.The reported Level 3 improvement is identified as particularly substantial on the most challenging problems.
- 5.2 Alita on Smaller LLM: Replacing Alita’s underlying models with GPT-4o-mini substantially worsens GAIA performance, highlighting the importance of coding capability.The experiment uses GPT-4o-mini without distilled MCPs, requiring the agent to generate its own MCPs.
- 5.3 Case Study: A GAIA Level 3 case study shows Alita brainstorming a task-specific MCP and using open-source resources to implement it.The case study describes structured MCP brainstorming followed by relevant-resource identification and implementation.
6 Conclusion
Alita combines minimal predefinition with maximal self-evolution to reduce reliance on manually predefined tools and workflows. The paper concludes that this simple design can support scalable agentic reasoning and improve generalist-agent performance and adaptability.
- 6 Conclusion: Alita reduces reliance on manually predefined tools and workflows by combining minimal predefinition with maximal self-evolution.The design uses autonomous capabilities in real time.
- 6 Conclusion: The paper concludes that simplicity in design does not undermine, but rather enhances, generalist-agent performance and adaptability.
A Detailed Case Study
The case study follows Alita solving a difficult GAIA question by creating a YouTube Video Subtitle Crawler MCP. The resulting workflow extracts the correct answer from the video transcript.
- Case Study: YouTube 360 VR Video Subtitle Extraction: 100000000 was correctly extracted as the number mentioned after dinosaurs first appeared in the target YouTube 360 VR video.The recorded answer, correct answer, and correctness indicator all agree.
- Workflow: Alita proposes a YouTube Video Subtitle Crawler MCP to automate subtitle extraction and isolate text following the relevant event.
- Workflow: The Manager Agent finds an open-source transcript library, writes Python code and setup instructions, and packages the resulting MCP for execution.The workflow uses youtube-transcript-api to retrieve the video transcript.
B Limitations
Alita’s main stated limitation is its strong dependence on the LLM’s coding capability. With poor coding ability, it can perform worse than traditional generalist agents.
- B Limitations: Alita highly relies on the LLM’s coding capability and can perform worse than traditional generalist agents when that capability is poor.