Tongyi DeepResearch
An open model and inference system for long-horizon web research, evidence gathering, and research question answering.
The README identifies external components for search, page reading, summarization, file parsing, model serving, and Python sandboxing, and states that the credential-bearing .env file is gitignored. Papers, project lineage, a team citation, and a named contact provide useful attribution. Deductions apply because the supplied files do not show least-privilege controls, per-action confirmation, a complete data-flow map, substantive secret protection, outbound-request boundaries, dependency auditing, or rollback/revocation design. Exact dependency pins improve traceability but do not establish security. Publisher identity is treated as unknown as instructed, without adverse inference.
The model, intended use, two inference paradigms, configuration fields, and launch procedure are described consistently. Dependencies are comprehensively pinned, and both local and hosted routes are identified. Deductions apply because operation depends on a long chain of external APIs, model weights, GPU/CUDA components, and a sandbox endpoint. Failure guidance is largely limited to a warning about demo latency and tool QPS; structured errors, retry boundaries, and diagnostic procedures are not evidenced.
The repository clearly targets long-horizon information seeking and documents web research, document questions, benchmark evaluation, local deployment, and hosted API use. ReAct and Heavy modes plus their configuration requirements provide some capability boundaries. Deductions apply because fine-grained tool enablement, task-trigger rules, and risk-specific operating profiles are not demonstrated. Environment support is centered on Python 3.10, CUDA 12, a large model, and several cloud services rather than broad deployment conditions.
The README has a coherent structure covering purpose, features, downloads, installation, configuration, data formats, execution, evaluation, FAQ routing, contact details, and citation. Installation notes are particularly concrete, and the complete Apache-2.0 license earns full credit. Deductions apply because the FAQ contents are absent from the supplied evidence, limitations receive only a brief latency/QPS note, and dated news entries are not a formal changelog or semantic version history. Readers must also distinguish DeepResearch, Tongyi DeepResearch, WebAgent, and inference-mode names. A maintainer contact is present, but no support commitment or maintenance policy is shown and publisher identity remains unverified.
The documented workflow can consume JSON or JSONL question sets, process referenced documents, run benchmark evaluation, and save results to a configured path. Web search, document parsing, long-horizon research, and two inference paradigms offer plausible value beyond a basic model call. Deductions apply because no concrete output schema, citation format, quality-control mechanism, or representative generated result is supplied. The 30B model, GPU/CUDA stack, multiple quota- or fee-bearing APIs, and sandbox service imply substantial cost without resource, latency, throughput, or pricing comparisons.
Major capability and performance claims are connected to a technical report, blog, model pages, named benchmarks, and an evaluation directory; the broader research family is tied to specifically named papers. Deductions apply because the supplied evidence excludes the report contents, evaluation implementation, raw results, and inspectable numerical tables. Leading and state-of-the-art claims are therefore predominantly self-supported, and factual statements, promotional conclusions, and inference are not systematically separated.
- Review the implementation's network egress, tool permissions, and Python sandbox isolation before use; the README does not establish that these controls exist.
- Before sending prompts, web content, or uploaded documents to Serper, Jina, an OpenAI-compatible service, Dashscope, or other endpoints, verify data classification, retention, and compliance requirements.
- Do not treat exact version pins as proof of dependency safety. This large stack includes CUDA, model serving, document parsing, cloud SDKs, and networking components and requires separate vulnerability and supply-chain review.
- The leading and state-of-the-art claims lack raw results and independent confirmation in the supplied static evidence and should not alone drive procurement or production decisions.
- Local deployment may require substantial GPU capacity, storage, and external API quotas; estimate cost, latency, rate limits, and degradation behavior first.
What does this agent do, and when should you use it?
Tongyi DeepResearch is a long-horizon information-seeking model and agent inference project from Tongyi Lab, with 30.5 billion total parameters, 3.3 billion activated per token, and a 128K context length. The repository provides inference scripts, a ReAct execution path, an IterResearch-based Heavy mode, and evaluation scripts for multiple research benchmarks. Its runtime can combine Serper.dev search and Google Scholar, Jina page reading, an OpenAI-compatible page-summarization endpoint, DashScope file parsing, and a SandboxFusion Python environment. It accepts JSON or JSONL records containing question and answer fields, generates predictions, and uses the reference answer for automated benchmark judging. It is best suited to research or engineering teams prepared to host a model, configure several external services, and operate their own evaluation workflow rather than adopters seeking a turnkey chat-platform integration.
The user points DATASET to a JSON or JSONL question set and configures MODEL_PATH, OUTPUT_PATH, and the required service credentials. Running bash run_react_infer.sh invokes the ReAct workflow in inference/react_agent.py, which can use retrieval, web search, a calculator, page reading, file parsing, or a Python sandbox according to the enabled tools, then saves predictions under OUTPUT_PATH. Document questions require source files in eval_data/file_corpus/ and an uploaded-file prefix in the question text. Scripts under evaluation/ assess generated responses on supported benchmarks, using each record's answer as the ground-truth or reference response. As an alternative to local weights, users can edit call_server, the model identifier, and content concatenation in inference/react_agent.py to call alibaba/tongyi-deepresearch-30b-a3b through OpenRouter.
- A search-agent research team wants to run and evaluate a long-horizon model on Humanity's Last Exam, BrowseComp, BrowseComp-ZH, WebWalkerQA, xbench-DeepSearch, FRAMES, or SimpleQA.
- An enterprise research group has a JSONL collection of questions and reference answers and needs batch web-research predictions for automated judging.
- An analysis team needs to ask questions about local PDF or XLSX material and can place files in eval_data/file_corpus/ while configuring DashScope parsing.
- A model engineering group wants to compare ReAct with the IterResearch-based Heavy inference paradigm and study test-time scaling.
- A developer without local GPUs is willing to modify inference/react_agent.py and invoke the hosted Tongyi-DeepResearch model through OpenRouter.
What are this agent's strengths and limitations?
- The 30B-A3B mixture-of-experts configuration activates 3.3 billion parameters per token and exposes a documented 128K context window for long-horizon information seeking.
- It supports both ReAct for testing intrinsic model behavior and an IterResearch-based Heavy mode aimed at a higher test-time performance ceiling.
- The repository includes runnable inference, structured JSON/JSONL ingestion, and benchmark evaluation rather than publishing model weights alone.
- Its documented tool chain covers web search, Google Scholar, page reading, file parsing, and sandboxed Python execution for multi-step research.
- Users can choose a local model path or follow the documented OpenRouter route when local GPUs are unavailable.
- The full workflow depends on separately managed credentials and potentially separate costs for Serper.dev, Jina, an OpenAI-compatible endpoint, DashScope, and SandboxFusion.
- Python 3.10.0 is specifically recommended, and the source warns that other versions may cause dependency problems.
- OpenRouter is not a ready-made adapter: users must edit inference/react_agent.py, including server settings, the model name, and content assembly.
- The hosted demos may be slow or fail intermittently because of model latency and tool QPS limits; stable operation requires local deployment or the Bailian service.
- The documented output is a results directory, with no evidenced turnkey production Web API, authorization layer, or operational deployment specification.
How do you install or deploy this agent?
Use the recommended Python 3.10.0 environment:
conda create -n react_infer_env python=3.10.0
conda activate react_infer_env
pip install -r requirements.txt
cp .env.example .envEdit .env and configure the services used by your run: SERPER_KEY_ID, JINA_API_KEYS, API_KEY/API_BASE, DASHSCOPE_API_KEY, and SANDBOX_FUSION_ENDPOINT, plus MODEL_PATH, DATASET, and OUTPUT_PATH. Serper.dev supplies web and Google Scholar search, Jina reads pages, the OpenAI-compatible endpoint summarizes pages, DashScope parses files, and SandboxFusion supplies Python execution. The source states that .env is gitignored.
How do you use this agent?
Create a JSONL file with one object per line, such as {"question":"What is the capital of France?","answer":"Paris"}; a JSON array of equivalent objects is also supported. Edit run_react_infer.sh so MODEL_PATH points to the model weights, DATASET contains the full input path, and OUTPUT_PATH names the results directory, then add the keys or BASE_URL values required by enabled tools. Start inference with:
bash run_react_infer.shFor document processing, place files in eval_data/file_corpus/ and prefix the question with text such as “(Uploaded 1 file: ['report.pdf'])\n\nWhat are the key findings?”. To use OpenRouter, edit call_server in inference/react_agent.py with the OpenRouter key and URL, change the model to alibaba/tongyi-deepresearch-30b-a3b, and adjust content concatenation as described by the comments associated with lines 88–90.
How does this agent compare with similar options?
ReAct is presented as the path for rigorous evaluation of the model's core intrinsic abilities, while the IterResearch-based Heavy mode uses test-time scaling to pursue the model's maximum performance ceiling. For delivery, local deployment favors stability and direct control; the ModelScope and Hugging Face demos favor quick trials but carry latency and QPS caveats; Bailian is identified as the production-oriented service; and OpenRouter removes the local-GPU requirement at the cost of manual changes to inference/react_agent.py.