MCP•RL enables you to train agents to effectively use any MCP (Model Context Protocol) server with minimal setup. Simply provide a server URL and MCP•RL will:
- Automatically discover server tools
- Design input tasks that utilize those tools
- Train the model to improve performance on the MCP server using RULER
- Test on new tasks to validate the trained model
✨ Key Features:
- No labeled data - MCP•RL learns what tasks a server will be used for by analyzing its tools
- General-purpose - Optimizes models for any MCP server
- Strong performance - Matches or exceeds SOTA performance in 2/3 benchmarks
- Easy integration - No customization of your MCP server required!
from art.rewards import ruler_score_group
# Specialize a model for NWS MCP server
MCP_SERVER_URL = "https://server.smithery.ai/@smithery-ai/national-weather-service/mcp"
# Generate training scenarios based on MCP tools
scenarios = await generate_scenarios(
num_scenarios=24,
server_url=MCP_SERVER_URL,
)
# ...run the agent...
# Use RULER to assign relative scores to each trajectory
scored_groups = []
for group in groups:
judged_group = await ruler_score_group(group)
scored_groups.append(judged_group)
# Train the model to improve performance on the MCP server
await model.train(scored_groups)ART is an open-source RL framework that improves agent reliability by allowing LLMs to learn from experience. ART provides an ergonomic harness for integrating GRPO into any python application. For a quick hands-on introduction, run one of the notebooks below. When you're ready to learn more, check out the docs.
| Agent Task | Example Notebook | Description | Comparative Performance |
|---|---|---|---|
| MCP•RL | 🏋️ Train agent | Qwen 2.5 3B masters the NWS MCP server | [Link coming soon] |
| ART•E [RULER] | 🏋️ Train agent | Qwen 2.5 7B learns to search emails using RULER |  benchmarks |
| 2048 | 🏋️ Train agent | Qwen 2.5 3B learns to play 2048 |  benchmarks |
| Temporal Clue | 🏋️ Train agent | Qwen 2.5 7B learns to solve Temporal Clue | [Link coming soon] |
| Tic Tac Toe | 🏋️ Train agent | Qwen 2.5 3B learns to play Tic Tac Toe |  benchmarks |
| Codenames | 🏋️ Train agent | Qwen 2.5 3B learns to play Codenames |  benchmarks |
| AutoRL [RULER] | 🏋️ Train agent | Train Qwen 2.5 7B to master any task | [Link coming soon] |
Explore our latest research and updates on building SOTA agents.
- 🗞️ AutoRL: Zero-Data Training for Any Task - Train custom AI models without labeled data using automatic input generation and RULER evaluation.
- 🗞️ RULER: Easy Mode for RL Rewards is now available for automatic reward generation in reinforcement learning.
- 🗞️ ART·E: How We Built an Email Research Agent That Beats o3 demonstrates a Qwen 2.5 14B email agent outperforming OpenAI's o3.
- 🗞️ ART Trainer: A New RL Trainer for Agents enables easy training of LLM-based agents using GRPO.
- ART provides convenient wrappers for introducing RL training into existing applications. We abstract the training server into a modular service that your code doesn't need to interface with.
- Train from anywhere. Run the ART client on your laptop and let the ART server kick off an ephemeral GPU-enabled environment, or run on a local GPU.
- Integrations with hosted platforms like W&B, Langfuse, and OpenPipe provide flexible observability and simplify debugging.
- ART is customizable with intelligent defaults. You can configure training parameters and inference engine configurations to meet specific needs, or take advantage of the defaults, which have been optimized for training efficiency and stability.
ART agents can be trained from any client machine that runs python. To add to an existing project, run this command:
pip install openpipe-art
Curious about how to use ART for a real-world task? Check out the ART•E Agent blog post, where we detail how we trained Qwen 2.5 14B to beat o3 at email retrieval!
ART's functionality is divided into a client and a server. The OpenAI-compatible client is responsible for interfacing between ART and your codebase. Using the client, you can pass messages and get completions from your LLM as it improves. The server runs independently on any machine with a GPU. It abstracts away the complexity of the inference and training portions of the RL loop while allowing for some custom configuration. An outline of the training loop is shown below:
-
Inference
- Your code uses the ART client to perform an agentic workflow (usually executing several rollouts in parallel to gather data faster).
- Completion requests are routed to the ART server, which runs the model's latest LoRA in vLLM.
- As the agent executes, each
system,user, andassistantmessage is stored in a Trajectory. - When a rollout finishes, your code assigns a
rewardto its Trajectory, indicating the performance of the LLM.
-
Training
- When each rollout has finished, Trajectories are grouped and sent to the server. Inference is blocked while training executes.
- The server trains your model using GRPO, initializing from the latest checkpoint (or an empty LoRA on the first iteration).
- The server saves the newly trained LoRA to a local directory and loads it into vLLM.
- Inference is unblocked and the loop resumes at step 1.
This training loop runs until a specified number of inference and training iterations have completed.
ART should work with most vLLM/HuggingFace-transformers compatible causal language models, or at least the ones supported by Unsloth. Gemma 3 does not appear to be supported for the time being. If any other model isn't working for you, please let us know on Discord or open an issue on GitHub!
ART is in active development, and contributions are most welcome! Please see the CONTRIBUTING.md file for more information.
@misc{hilton2025art,
author = {Brad Hilton and Kyle Corbitt and David Corbitt and Saumya Gandhi and Angky William and Bohdan Kovalenskyi and Andie Jones},
title = {ART: Agent Reinforcement Trainer},
year = {2025},
publisher = {GitHub},
journal = {GitHub repository},
howpublished = {\url{https://github.com/openpipe/art}}
}This repository's source code is available under the Apache-2.0 License.
ART stands on the shoulders of giants. While we owe many of the ideas and early experiments that led to ART's development to the open source RL community at large, we're especially grateful to the authors of the following projects:
Finally, thank you to our partners who've helped us test ART in the wild! We're excited to see what you all build with it.