RD-Agent

🖥️ Live Demo | 🎥 Demo Video ▶️YouTube | 📖 Documentation | 📄 Tech Report | 📃 Papers

📰 News

🗞️ News	📝 Description
Agent² RL-Bench Preprint	A benchmark for evaluating LLM agents on end-to-end post-training engineering. See the project page and code.
ICML 2026 Acceptance	We are thrilled to announce that our paper FT-Dojo: Towards Autonomous LLM Fine-Tuning with Language Agents has been accepted to ICML 2026. The FT-Agent implementation is available in the LLM fine-tuning guide.
ACL 2026 Findings Acceptance	We are thrilled to announce that our paper Reasoning as Gradient has been accepted to ACL 2026 Findings. Execution traces are available at Gome GPT-5 Traces
Web UI Release	We release a new frontend that can be built and served by rdagent server_ui for real-time interaction and trace viewing, currently excluding the data_science scenario.
NeurIPS 2025 Acceptance	We are thrilled to announce that our paper R&D-Agent-Quant has been accepted to NeurIPS 2025
Technical Report Release	Overall framework description and results on MLE-bench
R&D-Agent-Quant Release	Apply R&D-Agent to quant trading
MLE-Bench Results Released	R&D-Agent currently leads as the top-performing machine learning engineering agent on MLE-bench
Support LiteLLM Backend	We now fully support LiteLLM as our default backend for integration with multiple LLM providers.
General Data Science Agent	Data Science Agent
Kaggle Scenario release	We release Kaggle Agent, try the new features!
Official WeChat group release	We created a WeChat group, welcome to join! (🗪QR Code)
Official Discord release	We launch our first chatting channel in Discord (🗪)
First release	R&D-Agent is released on GitHub

🧪 Agent² RL-Bench

Agent² RL-Bench evaluates whether LLM agents can autonomously engineer end-to-end post-training pipelines, spanning static optimization and stateful online RL.

🏆 The Best Machine Learning Engineering Agent!

MLE-bench is a comprehensive benchmark evaluating the performance of AI agents on machine learning engineering tasks. Utilizing datasets from 75 Kaggle competitions, MLE-bench provides robust assessments of AI systems' capabilities in real-world ML engineering scenarios.

R&D-Agent currently leads as the top-performing machine learning engineering agent on MLE-bench:

Agent	Low == Lite (%)	Medium (%)	High (%)	All (%)
R&D-Agent o3(R)+GPT-4.1(D)	51.52 ± 6.9	19.3 ± 5.5	26.67 ± 0	30.22 ± 1.5
R&D-Agent o1-preview	48.18 ± 2.49	8.95 ± 2.36	18.67 ± 2.98	22.4 ± 1.1
AIDE o1-preview	34.3 ± 2.4	8.8 ± 1.1	10.0 ± 1.9	16.9 ± 1.1

Notes:

• O3(R)+GPT-4.1(D): This version is designed to both reduce average time per loop and leverage a cost-effective combination of backend LLMs by seamlessly integrating Research Agent (o3) with Development Agent (GPT-4.1).
• AIDE o1-preview: Represents the previously best public result on MLE-bench as reported in the original MLE-bench paper.
• Average and standard deviation results for R&D-Agent o1-preview is based on a independent of 5 seeds and for R&D-Agent o3(R)+GPT-4.1(D) is based on 6 seeds.
• According to MLE-Bench, the 75 competitions are categorized into three levels of complexity: Low==Lite if we estimate that an experienced ML engineer can produce a sensible solution in under 2 hours, excluding the time taken to train any models; Medium if it takes between 2 and 10 hours; and High if it takes more than 10 hours.

You can inspect the detailed runs of the above results online.

• R&D-Agent o1-preview detailed runs
• R&D-Agent o3(R)+GPT-4.1(D) detailed runs

For running R&D-Agent on MLE-bench, refer to MLE-bench Guide: Running ML Engineering via MLE-bench

🥇 The First Data-Centric Quant Multi-Agent Framework!

R&D-Agent for Quantitative Finance, in short RD-Agent(Q), is the first data-centric, multi-agent framework designed to automate the full-stack research and development of quantitative strategies via coordinated factor-model co-optimization.

Extensive experiments in real stock markets show that, at a cost under $10, RD-Agent(Q) achieves approximately 2× higher ARR than benchmark factor libraries while using over 70% fewer factors. It also surpasses state-of-the-art deep time-series models under smaller resource budgets. Its alternating factor–model optimization further delivers excellent trade-off between predictive accuracy and strategy robustness.

You can learn more details about RD-Agent(Q) through the paper and reproduce it through the documentation.

Data Science Agent Preview

Check out our demo video showcasing the current progress of our Data Science Agent under development:

https://github.com/user-attachments/assets/3eccbecb-34a4-4c81-bce4-d3f8862f7305

🌟 Introduction

R&D-Agent aims to automate the most critical and valuable aspects of the industrial R&D process, and we begin with focusing on the data-driven scenarios to streamline the development of models and data. Methodologically, we have identified a framework with two key components: 'R' for proposing new ideas and 'D' for implementing them. We believe that the automatic evolution of R&D will lead to solutions of significant industrial value.

R&D is a very general scenario. The advent of R&D-Agent can be your

• 💰 Automatic Quant Factory (🎥Demo Video|▶️YouTube)
• 🤖 Data Mining Agent: Iteratively proposing data & models (🎥Demo Video 1|▶️YouTube) (🎥Demo Video 2|▶️YouTube) and implementing them by gaining knowledge from data.
• 🦾 Research Copilot: Auto read research papers (🎥Demo Video|▶️YouTube) / financial reports (🎥Demo Video|▶️YouTube) and implement model structures or building datasets.
• 🤖 Kaggle Agent: Auto Model Tuning and Feature Engineering(🎥Demo Video Coming Soon...) and implementing them to achieve more in competitions.
• 🧪 FT-Agent: Autonomous LLM fine-tuning for benchmark-driven domain adaptation. See the LLM fine-tuning guide.
• ...

You can click the links above to view the demo. We're continuously adding more methods and scenarios to the project to enhance your R&D processes and boost productivity.

Additionally, you can take a closer look at the examples in our 🖥️ Live Demo.

⚡ Quick start

RD-Agent currently only supports Linux.

You can try above demos by running the following command:

🐳 Docker installation.

Users must ensure Docker is installed before attempting most scenarios. Please refer to the official 🐳Docker page for installation instructions. Ensure the current user can run Docker commands without using sudo. You can verify this by executing docker run hello-world.

🐍 Create a Conda Environment

• Create a new conda environment with Python (3.10 and 3.11 are well-tested in our CI):

  conda create -n rdagent python=3.10
  

• Activate the environment:

  conda activate rdagent
  

🛠️ Install the R&D-Agent

For Users

• You can directly install the R&D-Agent package from PyPI:

  pip install rdagent
  

For Developers

• If you want to try the latest version or contribute to RD-Agent, you can install it from the source and follow the development setup:

  git clone https://github.com/microsoft/RD-Agent
  cd RD-Agent
  make dev
  

More details can be found in the development setup.

💊 Health check

• rdagent provides a health check that currently checks two things.
  • whether the docker installation was successful.
  • whether the default port used by the rdagent ui is occupied.

  rdagent health_check --no-check-env
  

⚙️ Configuration

• The demos requires following ability:

  • ChatCompletion
  • json_mode
  • embedding query

  You can set your Chat Model and Embedding Model in the following ways:

  🔥 Attention: We now provide experimental support for DeepSeek models! You can use DeepSeek's official API for cost-effective and high-performance inference. See the configuration example below for DeepSeek setup.

• Using LiteLLM (Default): We now support LiteLLM as a backend for integration with multiple LLM providers. You can configure in multiple ways:

  Option 1: Unified API base for both models

  Configuration Example: OpenAI Setup :

  cat << EOF  > .env
  # Set to any model supported by LiteLLM.
  CHAT_MODEL=gpt-4o 
  EMBEDDING_MODEL=text-embedding-3-small
  # Configure unified API base
  OPENAI_API_BASE=<your_unified_api_base>
  OPENAI_API_KEY=<replace_with_your_openai_api_key>
  

  Configuration Example: Azure OpenAI Setup :

  Before using this configuration, please confirm in advance that your Azure OpenAI API key supports embedded models.

  cat << EOF  > .env
  EMBEDDING_MODEL=azure/<Model deployment supporting embedding>
  CHAT_MODEL=azure/<your deployment name>
  AZURE_API_KEY=<replace_with_your_openai_api_key>
  AZURE_API_BASE=<your_unified_api_base>
  AZURE_API_VERSION=<azure api version>
  

  Option 2: Separate API bases for Chat and Embedding models

  cat << EOF  > .env
  # Set to any model supported by LiteLLM.
  # Configure separate API bases for chat and embedding
  
  # CHAT MODEL:
  CHAT_MODEL=gpt-4o 
  OPENAI_API_BASE=<your_chat_api_base>
  OPENAI_API_KEY=<replace_with_your_openai_api_key>
  
  # EMBEDDING MODEL:
  # TAKE siliconflow as an example, you can use other providers.
  # Note: embedding requires litellm_proxy prefix
  EMBEDDING_MODEL=litellm_proxy/BAAI/bge-large-en-v1.5
  LITELLM_PROXY_API_KEY=<replace_with_your_siliconflow_api_key>
  LITELLM_PROXY_API_BASE=https://api.siliconflow.cn/v1
  

  Configuration Example: DeepSeek Setup :

  Since many users encounter configuration errors when setting up DeepSeek. Here's a complete working example for DeepSeek Setup:

  cat << EOF  > .env
  # CHAT MODEL: Using DeepSeek Official API
  CHAT_MODEL=deepseek/deepseek-chat 
  DEEPSEEK_API_KEY=<replace_with_your_deepseek_api_key>
  
  # EMBEDDING MODEL: Using SiliconFlow for embedding since deepseek has no embedding model.
  # Note: embedding requires litellm_proxy prefix
  EMBEDDING_MODEL=litellm_proxy/BAAI/bge-m3
  LITELLM_PROXY_API_KEY=<replace_with_your_siliconflow_api_key>
  LITELLM_PROXY_API_BASE=https://api.siliconflow.cn/v1
  

  Notice: If you are using reasoning models that include thought processes in their responses (such as <think> tags), you need to set the following environment variable:

  REASONING_THINK_RM=True
  

  You can also use a deprecated backend if you only use OpenAI API or Azure OpenAI directly. For this deprecated setting and more configuration information, please refer to the documentation.

• If your environment configuration is complete, please execute the following commands to check if your configuration is valid. This step is necessary.

  rdagent health_check
  

🚀 Run the Application

The 🖥️ Live Demo is implemented by the following commands(each item represents one demo, you can select the one you prefer):

• Run the Automated Quantitative Trading & Iterative Factors Model Joint Evolution: Qlib self-loop factor & model proposal and implementation application

  rdagent fin_quant
  

• Run the Automated Quantitative Trading & Iterative Factors Evolution: Qlib self-loop factor proposal and implementation application

  rdagent fin_factor
  

• Run the Automated Quantitative Trading & Iterative Model Evolution: Qlib self-loop model proposal and implementation application

  rdagent fin_model
  

• Run the Automated Quantitative Trading & Factors Extraction from Financial Reports: Run the Qlib factor extraction and implementation application based on financial reports

  # 1. Generally, you can run this scenario using the following command:
  rdagent fin_factor_report --report-folder=<Your financial reports folder path>
  
  # 2. Specifically, you need to prepare some financial reports first. You can follow this concrete example:
  wget https://github.com/SunsetWolf/rdagent_resource/releases/download/reports/all_reports.zip
  unzip all_reports.zip -d git_ignore_folder/reports
  rdagent fin_factor_report --report-folder=git_ignore_folder/reports
  

• Run the Automated Model Research & Development Copilot: model extraction and implementation application

  # 1. Generally, you can run your own papers/reports with the following command:
  rdagent general_model <Your paper URL>
  
  # 2. Specifically, you can do it like this. For more details and additional paper examples, use `rdagent general_model -h`:
  rdagent general_model  "https://arxiv.org/pdf/2210.09789"
  

• Run the Automated Medical Prediction Model Evolution: Medical self-loop model proposal and implementation application

  # Generally, you can run the data science program with the following command:
  rdagent data_science --competition <your competition name>
  
  # Specifically, you need to create a folder for storing competition files (e.g., competition description file, competition datasets, etc.), and configure the path to the folder in your environment. In addition, you need to use chromedriver when you download the competition descriptors, which you can follow for this specific example:
  
  # 1. Download the dataset, extract it to the target folder.
  wget https://github.com/SunsetWolf/rdagent_resource/releases/download/ds_data/arf-12-hours-prediction-task.zip
  unzip arf-12-hours-prediction-task.zip -d ./git_ignore_folder/ds_data/
  
  # 2. Configure environment variables in the `.env` file
  dotenv set DS_LOCAL_DATA_PATH "$(pwd)/git_ignore_folder/ds_data"
  dotenv set DS_CODER_ON_WHOLE_PIPELINE True
  dotenv set DS_IF_USING_MLE_DATA False
  dotenv set DS_SAMPLE_DATA_BY_LLM False
  dotenv set DS_SCEN rdagent.scenarios.data_science.scen.DataScienceScen
  
  # 3. run the application
  rdagent data_science --competition arf-12-hours-prediction-task
  

  NOTE: For more information about the dataset, please refer to the documentation.

• Run the Automated Kaggle Model Tuning & Feature Engineering: self-loop model proposal and feature engineering implementation application

  Using tabular-playground-series-dec-2021 as an example.

  1. Register and login on the Kaggle website.
  2. Configuring the Kaggle API. (1) Click on the avatar (usually in the top right corner of the page) -> Settings -> Create New Token, A file called kaggle.json will be downloaded. (2) Move kaggle.json to ~/.config/kaggle/ (3) Modify the permissions of the kaggle.json file. Reference command: chmod 600 ~/.config/kaggle/kaggle.json
  3. Join the competition: Click Join the competition -> I Understand and Accept at the bottom of the competition details page.

  # Generally, you can run the Kaggle competition program with the following command:
  rdagent data_science --competition <your competition name>
  
  # 1. Configure environment variables in the `.env` file
  mkdir -p ./git_ignore_folder/ds_data
  dotenv set DS_LOCAL_DATA_PATH "$(pwd)/git_ignore_folder/ds_data"
  dotenv set DS_CODER_ON_WHOLE_PIPELINE True
  dotenv set DS_IF_USING_MLE_DATA True
  dotenv set DS_SAMPLE_DATA_BY_LLM True
  dotenv set DS_SCEN rdagent.scenarios.data_science.scen.KaggleScen
  
  # 2. run the application
  rdagent data_science --competition tabular-playground-series-dec-2021
  

• Run FT-Agent for Autonomous LLM Fine-Tuning: an ICML 2026 LLM fine-tuning scenario for benchmark-driven data processing, training, evaluation, and feedback-guided refinement.

  # See the full setup, benchmark descriptions, dataset notes, and examples:
  # rdagent/app/finetune/llm/README.md
  # Configure FT_TARGET_BENCHMARK and FT_BENCHMARK_DESCRIPTION before running.
  rdagent llm_finetune --base-model Qwen/Qwen2.5-7B-Instruct
  

🖥️ Monitor the Application Results

Streamlit UI

Use the Streamlit UI to view run logs, especially for the data_science scenario.

rdagent ui --port 19899 --log-dir <your log folder like "log/"> --data-science

About the data_science parameter: If you want to see the logs of the data science scenario, set the data_science parameter to True; otherwise set it to False.

Web UI

We also provide a separate web frontend in web/ for the Flask backend started by server_ui.

NOTE: This web UI is different from rdagent ui. The current web UI does not support the data_science scenario yet. For the data_science scenario, please continue to use rdagent ui --data-science.

cd web
npm install

To build the frontend for the Flask backend, generate the static assets into the default directory used by server_ui:

cd web
npm run build:flask

By default, server_ui serves static files from ./git_ignore_folder/static. If you need a different location, set the UI_STATIC_PATH environment variable before starting the backend.

Start the Flask backend and serve the built frontend together with the real-time APIs:

export UI_SERVER_AUTH_TOKEN='<a-long-random-token>'
rdagent server_ui --port 19899

After that, open http://127.0.0.1:19899/?token=<a-long-random-token> once in your browser.

Web UI security and remote access

The Flask backend listens on 127.0.0.1 by default. All API access requires authentication, including localhost: a malicious website can send requests to a browser's local services. Configure a long, random UI_SERVER_AUTH_TOKEN before starting the server (for example, generate one with python -c 'import secrets; print(secrets.token_urlsafe(32))').

To access the Web UI from another machine, explicitly bind it to a non-local address and configure an authentication token:

export UI_SERVER_AUTH_TOKEN='<a-long-random-token>'
rdagent server_ui --port 19899 --host 0.0.0.0

Then open the following URL once to establish an authenticated browser session:

http://<server-host>:19899/?token=<a-long-random-token>

The server removes the token from the address bar by redirecting to / and stores it in an HTTP-only, same-site cookie. API clients can instead send it in the request header:

Authorization: Bearer <a-long-random-token>

The server refuses to start unless UI_SERVER_AUTH_TOKEN is set, even on localhost. When exposing it outside a trusted development machine, put it behind an HTTPS reverse proxy and avoid recording token-bearing query strings in proxy logs. The --host option controls the address when the server is started through the CLI; UI_SERVER_HOST is the corresponding default for direct use of the backend entry point.

Cross-origin browser access is disabled by default. If the frontend and backend are served from different origins, configure an explicit JSON allowlist rather than enabling every origin:

export UI_CORS_ALLOWED_ORIGINS='["https://ui.example.com"]'

Origins must be exact HTTP(S) origins, including any non-default port; wildcards and URL paths are rejected. The server validates request origins before executing API handlers. Cookie-authenticated POSTs require a same-origin or allowlisted Origin (or Referer when Origin is absent). Requests with missing provenance are rejected. Non-browser clients and internal trace publishers must send a Bearer token. Cross-origin clients must authenticate as well; CORS permission does not grant API access. When a reverse proxy changes the backend's host or scheme, add the exact browser-facing origin to the allowlist; arbitrary forwarded headers are not trusted.

The Web UI starts tasks that generate and execute code. Treat authenticated access as trusted operator access, and run workers in an isolated, least-privileged environment with restricted network egress and no host credentials or Docker socket exposed to generated code.

Web UI storage and compatibility settings

The Flask backend uses the following environment variables. Uploaded input files are deliberately kept outside the trace directory so that they cannot be discovered and deserialized as persisted traces.

Environment variable	Default	Description
UI_STATIC_PATH	./git_ignore_folder/static	Directory containing the built Web UI assets.
UI_TRACE_FOLDER	./git_ignore_folder/traces	Directory containing generated trace data and process logs.
UI_UPLOAD_FOLDER	./git_ignore_folder/uploads	Isolated directory for uploaded input files. Mount, back up, and clean it separately from the trace directory.
UI_SERVER_HOST	127.0.0.1	Default host used by the backend entry point. Use server_ui --host when starting it through the CLI.
UI_SERVER_AUTH_TOKEN	empty	Bearer/cookie authentication token. Required for all bindings, including localhost.
UI_CORS_ALLOWED_ORIGINS	[]	JSON list of allowed browser origins. CORS is disabled when the list is empty.
UI_MAX_UPLOAD_MB	20	Maximum size in MiB of an entire HTTP request, including all uploaded files and form data.
UI_LOAD_LEGACY_PICKLE_TRACES	false	Whether to deserialize persisted pickle traces when the server starts. Enable only for a fully trusted trace directory.

Uploads whose filenames end in .dill, .pickle, .pkl, .py, .pyc, or .pyo are rejected. Existing workflows that use these formats as uploaded inputs must convert them to a non-executable data format or provide them through another trusted mechanism.

The /upload API accepts actual file uploads only; URL and server-path text inputs are rejected before task creation. General Model Implementation requires exactly one uploaded report. Download any report through a trusted process first, then upload it. This removes the API's arbitrary report-fetch entry point; it does not sandbox code generated by an authorized task.

Legacy pickle trace loading is disabled by default because pickle deserialization can execute code. Consequently, after a server restart, an existing trace may still appear in the history list but its saved messages will not be loaded into the Web UI. If compatibility with trusted historical traces is required, opt in explicitly:

export UI_LOAD_LEGACY_PICKLE_TRACES=true
rdagent server_ui --port 19899

Only enable this setting when every file under UI_TRACE_FOLDER is trusted and the directory is not writable by untrusted users or services.

Data-science trace share links no longer accept a URL-controlled log_folder. A link can preserve the selected trace, but the recipient must have the corresponding log folder configured or select it in the UI.

Common Notes

Port 19899 is used in the examples above. Before starting either UI, check whether this port is already occupied. If it is, please change it to another available port.

You can check whether the port is occupied by running:

rdagent health_check --no-check-env --no-check-docker

🏭 Scenarios

We have applied R&D-Agent to multiple valuable data-driven industrial scenarios.

🎯 Goal: Agent for Data-driven R&D

In this project, we are aiming to build an Agent to automate Data-Driven R&D that can

• 📄 Read real-world material (reports, papers, etc.) and extract key formulas, descriptions of interested features and models, which are the key components of data-driven R&D .
• 🛠️ Implement the extracted formulas (e.g., features, factors, and models) in runnable codes.
  • Due to the limited ability of LLM in implementing at once, build an evolving process for the agent to improve performance by learning from feedback and knowledge.
• 💡 Propose new ideas based on current knowledge and observations.

📈 Scenarios/Demos

In the two key areas of data-driven scenarios, model implementation and data building, our system aims to serve two main roles: 🦾Copilot and 🤖Agent.

• The 🦾Copilot follows human instructions to automate repetitive tasks.
• The 🤖Agent, being more autonomous, actively proposes ideas for better results in the future.

The supported scenarios are listed below:

Scenario/Target	Model Implementation	Data Building
💹 Finance	🤖 Iteratively Proposing Ideas & Evolving▶️YouTube	🤖 Iteratively Proposing Ideas & Evolving ▶️YouTube 🦾 Auto reports reading & implementation▶️YouTube
🩺 Medical	🤖 Iteratively Proposing Ideas & Evolving▶️YouTube	-
🏭 General	🦾 Auto paper reading & implementation▶️YouTube 🤖 Auto Kaggle Model Tuning	🤖Auto Kaggle feature Engineering

• RoadMap: Currently, we are working hard to add new features to the Kaggle scenario.

Different scenarios vary in entrance and configuration. Please check the detailed setup tutorial in the scenarios documents.

Here is a gallery of successful explorations (5 traces showed in 🖥️ Live Demo). You can download and view the execution trace using this command from the documentation.

Please refer to 📖readthedocs_scen for more details of the scenarios.

⚙️ Framework

Automating the R&D process in data science is a highly valuable yet underexplored area in industry. We propose a framework to push the boundaries of this important research field.

The research questions within this framework can be divided into three main categories:

Research Area	Paper/Work List
Benchmark the R&D abilities	Benchmark
Idea proposal: Explore new ideas or refine existing ones	Research
Ability to realize ideas: Implement and execute ideas	Development

We believe that the key to delivering high-quality solutions lies in the ability to evolve R&D capabilities. Agents should learn like human experts, continuously improving their R&D skills.

More documents can be found in the 📖 readthedocs.

📃 Paper/Work list

Overall Technical Report

• R&D-Agent: An LLM-Agent Framework Towards Autonomous Data Science

@misc{yang2025rdagentllmagentframeworkautonomous,
      title={R&D-Agent: An LLM-Agent Framework Towards Autonomous Data Science}, 
      author={Xu Yang and Xiao Yang and Shikai Fang and Yifei Zhang and Jian Wang and Bowen Xian and Qizheng Li and Jingyuan Li and Minrui Xu and Yuante Li and Haoran Pan and Yuge Zhang and Weiqing Liu and Yelong Shen and Weizhu Chen and Jiang Bian},
      year={2025},
      eprint={2505.14738},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2505.14738}, 
}

📊 Benchmark

• Agent² RL-Bench: Can LLM Agents Engineer Agentic RL Post-Training? (Project Page · Code)

@misc{chen2026agent2rlbench,
      title={Agent$^2$ RL-Bench: Can LLM Agents Engineer Agentic RL Post-Training?},
      author={Wanyi Chen and Xiao Yang and Xu Yang and Tianming Sha and Qizheng Li and Zhuo Wang and Bowen Xian and Fang Kong and Weiqing Liu and Jiang Bian},
      year={2026},
      eprint={2604.10547},
      archivePrefix={arXiv},
      primaryClass={cs.AI},
      url={https://arxiv.org/abs/2604.10547}
}

• Towards Data-Centric Automatic R&D

@misc{chen2024datacentric,
    title={Towards Data-Centric Automatic R&D},
    author={Haotian Chen and Xinjie Shen and Zeqi Ye and Wenjun Feng and Haoxue Wang and Xiao Yang and Xu Yang and Weiqing Liu and Jiang Bian},
    year={2024},
    eprint={2404.11276},
    archivePrefix={arXiv},
    primaryClass={cs.AI}
}

🔍 Research

In a data mining expert's daily research and development process, they propose a hypothesis (e.g., a model structure like RNN can capture patterns in time-series data), design experiments (e.g., finance data contains time-series and we can verify the hypothesis in this scenario), implement the experiment as code (e.g., Pytorch model structure), and then execute the code to get feedback (e.g., metrics, loss curve, etc.). The experts learn from the feedback and improve in the next iteration.

Based on the principles above, we have established a basic method framework that continuously proposes hypotheses, verifies them, and gets feedback from the real-world practice. This is the first scientific research automation framework that supports linking with real-world verification.

For more detail, please refer to our 🖥️ Live Demo page.

🛠️ Development

• Collaborative Evolving Strategy for Automatic Data-Centric Development

@misc{yang2024collaborative,
    title={Collaborative Evolving Strategy for Automatic Data-Centric Development},
    author={Xu Yang and Haotian Chen and Wenjun Feng and Haoxue Wang and Zeqi Ye and Xinjie Shen and Xiao Yang and Shizhao Sun and Weiqing Liu and Jiang Bian},
    year={2024},
    eprint={2407.18690},
    archivePrefix={arXiv},
    primaryClass={cs.AI}
}

Deep Application in Diverse Scenarios

• FT-Dojo: Towards Autonomous LLM Fine-Tuning with Language Agents

@misc{li2026ftdojo,
  title={FT-Dojo: Towards Autonomous LLM Fine-Tuning with Language Agents},
  author={Qizheng Li and Yifei Zhang and Xiao Yang and Xu Yang and Zhuo Wang and Weiqing Liu and Jiang Bian},
  year={2026},
  eprint={2603.01712},
  archivePrefix={arXiv},
  primaryClass={cs.AI},
  url={https://arxiv.org/abs/2603.01712}
}

FT-Agent, the autonomous LLM fine-tuning scenario from this paper, is available through the LLM fine-tuning guide.

• R&D-Agent-Quant: A Multi-Agent Framework for Data-Centric Factors and Model Joint Optimization

@misc{li2025rdagentquantmultiagentframeworkdatacentric,
      title={R&D-Agent-Quant: A Multi-Agent Framework for Data-Centric Factors and Model Joint Optimization}, 
      author={Yuante Li and Xu Yang and Xiao Yang and Minrui Xu and Xisen Wang and Weiqing Liu and Jiang Bian},
      year={2025},
      eprint={2505.15155},
      archivePrefix={arXiv},
      primaryClass={q-fin.CP},
      url={https://arxiv.org/abs/2505.15155}, 
}

• Reasoning as Gradient: Scaling MLE Agents Beyond Tree Search

@article{zhang2026reasoning,
  title={Reasoning as Gradient: Scaling MLE Agents Beyond Tree Search},
  author={Zhang, Yifei and Yang, Xu and Yang, Xiao and Xian, Bowen and Li, Qizheng and Fang, Shikai and Li, Jingyuan and Wang, Jian and Xu, Mingrui and Liu, Weiqing and others},
  journal={arXiv preprint arXiv:2603.01692},
  year={2026}
}

You can check the detailed execution traces online at Gome GPT-5 Traces.

🤝 Contributing

We welcome contributions and suggestions to improve R&D-Agent. Please refer to the Contributing Guide for more details on how to contribute.

Before submitting a pull request, ensure that your code passes the automatic CI checks.

📝 Guidelines

This project welcomes contributions and suggestions. Contributing to this project is straightforward and rewarding. Whether it's solving an issue, addressing a bug, enhancing documentation, or even correcting a typo, every contribution is valuable and helps improve R&D-Agent.

To get started, you can explore the issues list, or search for TODO: comments in the codebase by running the command grep -r "TODO:".

Before we released R&D-Agent as an open-source project on GitHub, it was an internal project within our group. Unfortunately, the internal commit history was not preserved when we removed some confidential code. As a result, some contributions from our group members, including Haotian Chen, Wenjun Feng, Haoxue Wang, Zeqi Ye, Xinjie Shen, and Jinhui Li, were not included in the public commits.

⚖️ Legal disclaimer