The Problem

ART addresses the pain of training multi-step LLM agents for real-world tasks. Without a structured RL harness, practitioners face manual reward engineering, fragile episode loops, and infrastructure overhead that separates code from experimentation. The framework promises GRPO integration "out of the box" but the collected-project structure means integration effort varies significantly across the four sub-projects.

What This Does

ART is a collection of 4 self-contained projects rather than a single monorepo: src (162 files, the core framework), examples (79 files with notebooks and code demos), dev (26 files with prototypes and benchmarks), and scripts (9 utility scripts). The src layer provides the RL harness—src/art/model.py defines TrainableModel and is called from 54 other files, while src/art/trajectories.py manages TrajectoryGroup and Trajectory objects called from 48 files. GRPO training hooks live in the backend services; src/art/local/backend.py handles GPU cost resolution and automatic training steps, and src/art/megatron/service.py manages rollout weight modes and vLLM base URL configuration. The framework supports Qwen3.5, GPT-OSS, Llama, and unsloth variants through model-specific service files under src/art/*/service.py.

Serverless RL is the standout capability: examples/just-the-facts/main.py is the primary entry point, reaching 399 functions and itself called from 1 place. A typical workflow instantiates art.TrainableModel, registers a ServerlessBackend with a W&B API key, then iterates edits via the backend. The examples/mcp-rl directory adds tool-use servers (Alpha Vantage, Google Maps, Balldontlie) that agents learn to call, extending the task horizon beyond text completion.

How It Is Wired

Execution starts at main in examples/just-the-facts/main.py (1 call site). From there, control flows to register (27 calls), train (21 calls), and rollout (20 calls). The rollout function triggers Trajectory (25 calls) and create (22 calls). The internal call graph contains 3250 resolved edges; list is called from 95 places, TrajectoryGroup from 57, and Model from 56.

Two significant structural patterns affect maintainability. First, 25 modules live in circular dependencies—src/art/__init__ (instability 0.41, in cycle), src/art/trajectories (instability 0.11, in cycle), and src/art/model (instability 0.5, in cycle) are the primary members. Second, src/art/types has 13 dependents and 0 outgoing imports, making it a high-blast-radius hub: any change ripples across 17 dependent modules. The call graph shows main -> get_step -> gather_trajectory_groups -> register as a representative path, and chat_completions -> build_generation_prompt -> render_message -> image_to_chunk as a path that leaves the process via network (urllib.request.urlopen) and filesystem (Image.open).

How To Use It

Setup: No root-level Dockerfile or Makefile. The package uses pnpm as package manager (evidenced by docs/package.json and pyproject.toml files across examples). Install with pip install -e . from the repo root, or pnpm install if working in the docs or an example directory.

Configuration: Required environment variables are not explicitly documented in the root, but the README snippet shows a ServerlessBackend instantiation accepting api_key="your_wandb_api_key". The .env.example at root level likely contains additional vars (WANDB_PROJECT, base model names). The examples/just-the-facts/pyproject.toml and examples/mcp-rl/pyproject.toml define per-example dependencies.

Running it: Invoke the primary entry point with python examples/just-the-facts/main.py. For the MCP-RL tool-use demos, start individual server scripts under examples/mcp-rl/servers/python/. The Colab notebooks (linked from the README) provide the lowest-friction on-ramp.

Real-World Use

A practical scenario: your team needs an agent that can retrieve current stock prices. You instantiate art.TrainableModel(project="finance", name="price-agent", base_model="OpenPipe/Qwen3-14B-Instruct"), register a ServerlessBackend with your W&B key, and define a reward function that checks whether the agent's tool call to Alpha Vantage returned the correct price. The agent runs GRPO across multiple episodes, learning when and how to call mcp_alphavantage versus when to respond from cached knowledge. Each checkpoint becomes instantly available via W&B Inference for downstream product use.

Code Health & Issues

The static analysis produced 172 findings across 55 high, 116 medium, and 1 low severity issues. The 7 SDLC health findings are:

  • HIGH - Pin third-party GitHub Actions to a commit SHA: .github/workflows references pypa/gh-action-pypi-publish@release/v1; a tag move changes which code runs with your secrets.
  • HIGH - Open a pull request instead of pushing to the default branch: create-draft-release.yml pushes with git push origin release/v${{ steps.bump.outputs.NEW_VERSION }}; automated commits deploy without test validation.
  • MEDIUM - Enable Dependabot or Renovate: 2 manifest(s) exist but no update bot is configured.
  • MEDIUM - Gate pull requests on a dependency vulnerability scan: no dependency scan is in CI.
  • MEDIUM - Move large binaries to Git LFS or out of the repository: examples/data/temporal-clue/puzzles.json is 13.7MB, dictionary.json 7.8MB.
  • MEDIUM - Set persist-credentials: false on checkout: the default checkout step keeps the token available to all later steps.
  • LOW - Set timeout-minutes on workflow jobs: 4 jobs declare no timeout, risking overlap on a two-hourly schedule.

Beyond the measured block: the repo contains no Dockerfile, but LICENSE and lockfile are present. No committed secrets were detected. The four-project collection means "getting started" depends on which sub-project you target—src for framework extension, examples for immediate demos.

The Bottom Line

ART delivers a functional GRPO harness with serverless RL infrastructure that dramatically reduces the DevOps overhead of agent training. The four-project layout gives breadth (email agents, 2048, MCP tool use, just-the-facts) but requires mapping the right sub-project to your use case. Health is decent—license and lockfile are present, CI runs—but the GitHub Actions pinning and PR gating issues should be fixed before any production deployment. Use the Colab notebooks for quick experimentation; commit to src/ modifications only if you need to extend the framework itself.