> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide/training-ai-agents-with-rl.md).

# KI-Agenten mit RL trainieren

Erfahre, wie du KI-Agenten für reale Aufgaben mit Reinforcement Learning (RL) trainierst.

„Agentic“-KI wird mit der Zeit immer beliebter. In diesem Zusammenhang ist ein „Agent“ ein LLM, dem ein übergeordnetes Ziel und eine Reihe von Werkzeugen zu dessen Erreichung gegeben werden. Agents sind zudem typischerweise „multi-turn“ – sie können eine Aktion ausführen, sehen, welche Wirkung sie auf die Umgebung hatte, und dann wiederholt eine weitere Aktion ausführen, bis sie ihr Ziel erreichen oder es dabei scheitern.

Leider können selbst sehr leistungsfähige LLMs Schwierigkeiten haben, komplexe mehrstufige agentische Aufgaben zuverlässig auszuführen. Interessanterweise haben wir festgestellt, dass das Training von Agents mit einem RL-Algorithmus namens [GRPO (Group Relative Policy Optimization)](https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide/tutorial-train-your-own-reasoning-model-with-grpo.md) sie weitaus zuverlässiger machen kann! In diesem Leitfaden lernst du, wie du mit Open-Source-Tools zuverlässige KI-Agents aufbaust.

## 🎨 RL-Agents mit ART trainieren

[ART (Agent Reinforcement Trainer)](https://github.com/openpipe/art) aufgebaut auf [Unsloth](https://github.com/unslothai/unsloth)’s GRPOTrainer ist ein Tool, das das Training mehrstufiger Agents möglich und einfach macht. Wenn du Unsloth bereits für GRPO verwendest und Agents trainieren musst, die komplexe mehrstufige Interaktionen bewältigen können, vereinfacht ART den Prozess.

<div align="left"><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-c97e63a69ecd17685c6e09cb41fd625d43a3545d%2FScreenshot_2025-07-19_at_1.23.18_PM.webp?alt=media" alt="" width="375"><figcaption><p>Mit Unsloth+ART trainierte Agentenmodelle können bei agentischen Workflows oft besser abschneiden als per Prompt gesteuerte Modelle.</p></figcaption></figure></div>

### ART + Unsloth

ART baut auf Unsloths speicher- und recheneffizienter GRPO-Implementierung auf. Außerdem fügt es die folgenden Fähigkeiten hinzu:

#### 1. Mehrstufiges Agent-Training

ART führt das Konzept einer „Trajectory“ ein, die sich aufbaut, während dein Agent ausgeführt wird. Diese Trajektorien können dann bewertet und für GRPO verwendet werden. Trajektorien können komplex sein und sogar nichtlineare Verläufe, Aufrufe von Sub-Agents usw. enthalten. Sie unterstützen außerdem Tool-Aufrufe und Antworten.

#### 2. Flexible Integration in bestehende Codebasen

Wenn du bereits einen Agenten hast, der mit einem per Prompt gesteuerten Modell arbeitet, versucht ART, die Anzahl der Änderungen, die du vornehmen musst, um deine bestehende Agenten-Schleife einzubinden und für das Training zu verwenden, zu minimieren.

Architektonisch ist ART in einen „Frontend“-Client aufgeteilt, der in deiner Codebasis lebt und per API mit einem „Backend“ kommuniziert, in dem das eigentliche Training stattfindet (diese können auch auf demselben Rechner zusammengelegt werden, wenn du lieber ARTs `LocalBackend`). Das bringt einige wichtige Vorteile mit sich:

* **Minimaler Einrichtungsaufwand**: Das ART-Frontend hat nur minimale Abhängigkeiten und lässt sich leicht in bestehende Python-Codebasen integrieren.
* **Von überall aus trainieren**: Du kannst den ART-Client auf deinem Laptop ausführen und den ART-Server eine flüchtige GPU-fähige Umgebung starten lassen oder auf einer lokalen GPU ausführen
* **OpenAI-kompatible API**: Das ART-Backend stellt dein trainierendes Modell über eine OpenAI-kompatible API bereit, die mit den meisten bestehenden Codebasen kompatibel ist.

#### 3. RULER: Zero-Shot-Agent-Belohnungen

ART bietet außerdem eine integrierte allgemeine Belohnungsfunktion namens [RULER](https://art.openpipe.ai/fundamentals/ruler) (Relative Universal LLM-Elicited Rewards), die die Notwendigkeit handgefertigter Belohnungsfunktionen beseitigen kann. Überraschenderweise erreichen per RL mit der automatischen Belohnungsfunktion von RULER trainierte Agents oft die Leistung von Agents, die mit handgeschriebenen Belohnungsfunktionen trainiert wurden, oder übertreffen sie sogar. Das macht den Einstieg in RL einfacher.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-b4168c3c380f6c8258c31083dcb65a5fcd2308b8%2FScreenshot_2025-07-19_at_1.21.08_PM.webp?alt=media" alt="" width="375"><figcaption></figcaption></figure>

```python
# Vorher: Stundenlanges Reward Engineering
def complex_reward_function(trajectory):
    # 50+ Zeilen sorgfältiger Scoring-Logik...
    pass

# Nachher: Eine Zeile mit RULER
judged_group = await ruler_score_group(group, "openai/o3")
```

### Wann man ART wählen sollte

ART könnte gut zu Projekten passen, die Folgendes benötigen:

1. **Agentenfähigkeiten mit mehreren Schritten**: Wenn dein Anwendungsfall Agents umfasst, die mehrere Aktionen ausführen, Werkzeuge verwenden oder längere Gespräche führen müssen
2. **Schnelles Prototyping ohne Reward Engineering**: Die automatische Reward-Bewertung von RULER kann die Entwicklungszeit deines Projekts um das 2- bis 3-Fache verkürzen
3. **Integration mit bestehenden Systemen**: Wenn du einer bestehenden agentischen Codebasis mit minimalen Änderungen RL-Fähigkeiten hinzufügen musst

### Code-Beispiel: ART in Aktion

```python
import art
from art.rewards import ruler_score_group

# Modell mit einem von Unsloth unterstützten Basismodell initialisieren
model = art.TrainableModel(
    name="agent-001",
    project="my-agentic-task",
    base_model="Qwen/Qwen2.5-14B-Instruct",  # Jedes von Unsloth unterstützte Modell
)

# Deine Rollout-Funktion definieren
async def rollout(model: art.Model, scenario: Scenario) -> art.Trajectory:
    openai_client = model.openai_client()
    trajectory = art.Trajectory(
        messages_and_choices=[
            {"role": "system", "content": "..."},
            {"role": "user", "content": "..."}
        ]
    )
    # Deine Agentenlogik hier...    
    return trajectory

# Mit RULER für automatische Belohnungen trainieren
groups = await art.gather_trajectory_groups(
    (
        art.TrajectoryGroup(rollout(model, scenario) for _ in range(8))
        for scenario in scenarios
    ),
    after_each=lambda group: ruler_score_group(
        group,
        "openai/o3",
        swallow_exceptions=True
    )
)

await model.train(groups)
```

### Erste Schritte

Um ART zu deinem auf Unsloth basierenden Projekt hinzuzufügen:

```bash
pip install openpipe-art # oder `uv add openpipe-art`
```

Schau dir dann die [Beispiel-Notebooks](https://art.openpipe.ai/getting-started/notebooks) an, um ART in Aktion bei Aufgaben wie diesen zu sehen:

* E-Mail-Retrieval-Agents, die o3 übertreffen
* Spielende Agents (2048, Tic Tac Toe, Codenames)
* Komplexe Denkaufgaben (Temporal Clue)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/de/loslegen/reinforcement-learning-rl-guide/training-ai-agents-with-rl.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
