ART (Agent Reinforcement Trainer) Cheatsheet

ART (Agent Reinforcement Trainer) Cheatsheet

ART (Agent Reinforcement Trainer) von OpenPipe ist ein Open-Source-Framework zum Trainieren von LLM-basierten Agenten mit Reinforcement Learning, hauptsächlich GRPO. Die definitive Idee ist eine Split-Architektur: Ein leichtgewichtiger Client führt die Rollouts deines Agenten in deinem eigenen Code durch einen OpenAI-kompatiblen Endpoint aus, während ein Server/Backend die Inferenz (vLLM) und das Training (Unsloth-basiertes GRPO) handhabt, optional auf einer separaten GPU-Maschine. Dies macht es gut geeignet für mehrstufige, Tool-nutzende Agenten, die „On-the-Job”-Training gegen eine Belohnung benötigen.

Reinforcement Learning kann instabil und rechenintensiv sein. Beginne klein, protokolliere alles und validiere eine Belohnungsfunktion an einer Handvoll von Rollouts, bevor du skalierst.

Installation

Schritt	Befehl
Installieren	pip install openpipe-art
Mit Extras (Backend)	pip install "openpipe-art[backend]"
uv	uv add openpipe-art
Anforderungen	Eine CUDA-GPU für das Backend (Training/Inferenz)

Kernkonzepte

Begriff	Bedeutung
Model	Ein trainierbarer Modell-Handle (art.TrainableModel) registriert bei einem Backend
Backend	Wo Inferenz + Training laufen (lokale GPU oder remote)
Rollout	Eine Agent-Episode, die eine Trajektorie und eine Belohnung produziert
Trajectory	Die Nachrichten/Tool-Aufrufe/Wahlmöglichkeiten, die ART bewertet und lernt
GRPO	Group Relative Policy Optimization — der Standard-RL-Algorithmus
Reward	Ein Skalar, den dein Code einer Trajektorie zuweist (höher = besser)

Ein Modell definieren

import art

model = art.TrainableModel(
    name="agent-001",
    project="my-agent",
    base_model="Qwen/Qwen2.5-7B-Instruct",
)

backend = art.LocalBackend()          # or a remote backend
await model.register(backend)

Objekt	Zweck
art.TrainableModel(...)	Die Policy, die du trainierst
art.LocalBackend()	Führe Inferenz + Training auf der lokalen GPU aus
model.register(backend)	Binde ein Modell an ein Backend
model.openai_client()	OpenAI-kompatible Client für Rollouts

Einen Rollout schreiben

import art, weave

@weave.op
async def rollout(model: art.Model, scenario) -> art.Trajectory:
    client = model.openai_client()
    traj = art.Trajectory(messages_and_choices=[], reward=0.0)

    messages = [{"role": "user", "content": scenario.prompt}]
    completion = await client.chat.completions.create(
        model=model.name, messages=messages,
    )
    choice = completion.choices[0]
    traj.messages_and_choices.append(choice)

    traj.reward = score(choice.message.content, scenario)  # your reward fn
    return traj

Training-Schleife

for step in range(NUM_STEPS):
    groups = await art.gather_trajectory_groups(
        (art.TrajectoryGroup(rollout(model, s) for _ in range(GROUP_SIZE))
         for s in scenarios)
    )
    await model.train(groups, config=art.TrainConfig(learning_rate=1e-5))

Aufruf	Beschreibung
art.TrajectoryGroup(...)	Eine Gruppe von Rollouts, die untereinander verglichen werden (GRPO)
art.gather_trajectory_groups(...)	Führe Rollouts gleichzeitig aus und sammle Gruppen
model.train(groups, config=...)	Ein GRPO-Update aus den gesammelten Gruppen
art.TrainConfig(...)	Learning Rate und Training-Hyperparameter
model.get_step()	Aktueller Training-Schritt (für Checkpointing/Wiederaufnahme)

Tipps zum Reward-Design

Richtlinie	Warum
Halten Sie Belohnungen begrenzt	Stabilisiert GRPO-Vorteilsschätzungen
Belohnen Sie das Ergebnis, nicht die Formulierung	Vermeidet Reward Hacking bei Formulierung
Fügen Sie kleine Shaping für Tool-Erfolg hinzu	Hilft bei mehrstufiger Credit-Zuordnung
Verwende RULER für relative Bewertung	ARTs Helfer zum Ranking von Trajektorien in einer Gruppe, wenn es keine saubere Metrik gibt

Observability

Tool	Integration
Weights & Biases	Native Protokollierung von Belohnungs-/Verlust-Kurven
Weave	Dekoriere Rollouts mit @weave.op für Trace-Erfassung
LangfuseTracing	Unterstützt für Trajektorie-Inspektion

ART vs Andere RL-Trainer

Aspekt	ART	OpenRLHF	verl
Fokus	Mehrstufige Agenten	Skalierbare RLHF	Hochdurchsatz-RL
Architektur	Split-Client/Server	Ray + vLLM	Ray + vLLM
Backend	vLLM + Unsloth	vLLM	vLLM
Beste für	Agenten trainiert in deinem eigenen Code	Großskalige RLHF-Pipelines	Forschungs-Durchsatz

Ressourcen

• GitHub-Repository
• Launch-Beitrag: ART Trainer
• PyPI-Paket