> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Agent-Versionierung

Mit der Agent-Versionierung können Sie mit verschiedenen Konfigurationen Ihres Agenten experimentieren, ohne Ihre Produktionsumgebung zu gefährden. Erstellen Sie isolierte Branches, testen Sie Änderungen und führen Sie Updates schrittweise über die Traffic-Bereitstellung nach Prozentanteil ein.

> **Note**
>
> Möchten Sie A/B-Tests durchführen? Unter [Experimente](/docs/de/eleven-agents/operate/experiments) finden Sie den empfohlenen Workflow zum Testen von Agentenänderungen mit Live-Traffic.

## Überblick

Das Versionierungssystem bietet:

* **Unveränderliche Snapshots** Ihrer Agentenkonfiguration zu jedem Zeitpunkt
* **Isolierte Branches** zum Testen von Änderungen vor der Live-Schaltung
* **Traffic-Aufteilung**, um Änderungen schrittweise für einen Prozentsatz der Nutzer einzuführen
* **Merging**, um Änderungen aus einem beliebigen Branch in einen anderen zu übernehmen
* **Rebasing**, um die neuesten Änderungen des Main-Branches in einen Branch zu übernehmen

> **Note**
>
> Sobald die Versionierung für einen Agenten aktiviert ist, kann sie nicht mehr deaktiviert werden. Berücksichtigen Sie dies, bevor Sie die
> Versionierung für bestehende Agenten aktivieren.

## Grundkonzepte

### Versionen

Eine Version ist ein unveränderlicher Snapshot der Konfiguration eines Agenten zu einem bestimmten Zeitpunkt. Jede Version hat eine eindeutige ID (Format: `agtvrsn_xxxx`) und enthält:

* `conversation_config` – System-Prompt, LLM-Einstellungen, Stimmenkonfiguration, Tools, Wissensdatenbank
* `platform_settings` – Versionierte Teilmenge mit Einstellungen für Auswertung, Widget, Datenerfassung und Sicherheit
* `workflow` – Vollständige Workflow-Definition mit Knoten und Kanten

Versionen werden automatisch erstellt, wenn Sie Änderungen an einem versionierten Agenten speichern. Nach der Erstellung kann eine Version nicht mehr geändert werden.

### Branches

Branches sind benannte Entwicklungszweige, ähnlich wie Git-Branches. Sie ermöglichen es Ihnen, isoliert an Änderungen zu arbeiten, bevor Sie sie zurück in den Main-Branch mergen.

* Jeder versionierte Agent hat einen **Main**-Branch, der nicht gelöscht oder archiviert werden kann
* Zusätzliche Branches können von jeder Version eines bestehenden Branches erstellt werden, nicht nur von Main
* Branches können in jeden anderen Branch gemergt werden. Nicht-Main-Branches können auf Main rebasiert werden, um dessen neueste Änderungen zu übernehmen
* Jeder Branch hat: ID (`agtbrch_xxxx`), Name, Beschreibung und eine Liste von Versionen
* Branch-Namen können Buchstaben, Zahlen und `() [] {} - / .` enthalten (max. 140 Zeichen)

### Traffic-Bereitstellung

Traffic kann prozentual auf mehrere Branches aufgeteilt werden. Das ermöglicht schrittweise Rollouts und A/B-Tests.

* Die Prozentwerte müssen immer genau **100 %** ergeben
* Das Traffic-Routing ist anhand der Konversations-ID **deterministisch** (derselbe Nutzer wird konsistent zum selben Branch geleitet)
* Nur nicht archivierte Branches mit 0 % Traffic können archiviert werden

### Entwürfe

Nicht gespeicherte Änderungen werden als Entwürfe gespeichert, sodass Sie an Änderungen arbeiten können, ohne sofort eine neue Version zu erstellen.

* Entwürfe sind **pro Nutzer und pro Branch** (jedes Teammitglied hat einen eigenen Entwurf)
* Entwürfe werden automatisch verworfen, wenn eine neue Version festgeschrieben wird
* Entwürfe werden auch beim Mergen in einen Branch verworfen

## Versionierung aktivieren

Die Versionierung ist optional und muss ausdrücklich aktiviert werden. Sie können sie beim Erstellen eines neuen Agenten oder für einen bestehenden Agenten aktivieren.

> **Warning**
>
> Nach der Aktivierung kann die Versionierung nicht mehr deaktiviert werden. Dies ist eine dauerhafte Änderung an Ihrem Agenten.

### Beim Erstellen eines Agenten aktivieren

#### Über das Dashboard aktivieren

Öffnen Sie Ihren Agenten im Dashboard, wechseln Sie zu **Einstellungen** und aktivieren Sie die Versionierung. Nach der Aktivierung steht der Tab **Versionierung** zur Verwaltung von Branches, Entwürfen, Versionen und der Traffic-Bereitstellung zur Verfügung.

#### Über die API aktivieren

```python
from elevenlabs.client import ElevenLabs
from elevenlabs.types import *

client = ElevenLabs(api_key="your-api-key")

agent = client.conversational_ai.agents.create(
    conversation_config=ConversationalConfig(
        agent=AgentConfig(
            first_message="Hello! How can I help you today?",
            prompt={"prompt": "You are a helpful assistant."},
        )
    ),
    enable_versioning=True
)

print(f"Agent created with versioning: {agent.agent_id}")
```

```javascript
import { ElevenLabsClient } from '@elevenlabs/elevenlabs-js';

const client = new ElevenLabsClient({ apiKey: 'your-api-key' });

const agent = await client.conversationalAi.agents.create({
  conversationConfig: {
    agent: {
      firstMessage: 'Hello! How can I help you today?',
      prompt: {
        prompt: 'You are a helpful assistant.',
      },
    },
  },
  enableVersioning: true,
});

console.log(`Agent created with versioning: ${agent.agentId}`);
```

### Für einen bestehenden Agenten aktivieren

#### Über das Dashboard aktivieren

Öffnen Sie Ihren Agenten im Dashboard, navigieren Sie zu **Einstellungen** und aktivieren Sie die Versionierung.

#### Über die API aktivieren

```python
agent = client.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    enable_versioning_if_not_enabled=True
)
```

```javascript
const agent = await client.conversationalAi.agents.update('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  enableVersioningIfNotEnabled: true,
});
```

Durch das Aktivieren der Versionierung wird der erste Branch „Main“ mit der ersten Version erstellt, die die aktuelle Agentenkonfiguration enthält.

## Mit Branches arbeiten

### Einen Branch erstellen

Branches können von jeder Version eines beliebigen Branches erstellt werden, nicht nur von Main. Optional können Sie Konfigurationsänderungen einbeziehen, die auf die erste Version des neuen Branches angewendet werden.

```python
branch = client.conversational_ai.agents.branches.create(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    parent_version_id="agtvrsn_xxxx",
    name="experiment-v2",
    description="Testing new prompt and voice settings"
)

print(f"Created branch: {branch.created_branch_id}")
print(f"Initial version: {branch.created_version_id}")
```

```javascript
const branch = await client.conversationalAi.agents.branches.create('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  parentVersionId: 'agtvrsn_xxxx',
  name: 'experiment-v2',
  description: 'Testing new prompt and voice settings',
});

console.log(`Created branch: ${branch.createdBranchId}`);
console.log(`Initial version: ${branch.createdVersionId}`);

```

### Branches auflisten

```python
branches = client.conversational_ai.agents.branches.list(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6"
)

for branch in branches.branches:
print(f"{branch.name}: {branch.id}")

```

```javascript
const branches = await client.conversationalAi.agents.branches.list('agent_7101k5zvyjhmfg983brhmhkd98n6');

for (const branch of branches.branches) {
  console.log(`${branch.name}: ${branch.id}`);
}

```

### Branch-Details abrufen

```python
branch = client.conversational_ai.agents.branches.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)

print(f"Branch: {branch.name}")
print(f"Versions: {len(branch.versions)}")

```

```javascript
const branch = await client.conversationalAi.agents.branches.get('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');

console.log(`Branch: ${branch.name}`);
console.log(`Versions: ${branch.versions.length}`);

```

## Änderungen festschreiben

Wenn Sie einen Agenten mit aktivierter Versionierung aktualisieren, geben Sie `branch_id` an, um eine neue Version in diesem Branch zu erstellen.

#### Über das Dashboard aktualisieren

Öffnen Sie den Tab **Versionierung** Ihres Agenten, wechseln Sie zum Ziel-Branch, bearbeiten Sie die Konfiguration und speichern Sie sie, um eine neue Version zu erstellen.

#### Über die CLI aktualisieren

Übergeben Sie das Flag `--branch`, um per Name oder ID in einen bestimmten Branch zu pushen. Der Branch muss bereits existieren.

```bash
elevenlabs agents push --agent "<agent-name>" --branch "<branch-name>"
```

#### Über die API aktualisieren

```python
agent = client.conversational_ai.agents.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    conversation_config=ConversationalConfig(
        agent=AgentConfig(
            prompt={"prompt": "You are a friendly customer support agent."},
        )
    )
)
```

```javascript
const agent = await client.conversationalAi.agents.update(
  'agent_7101k5zvyjhmfg983brhmhkd98n6',
  {
    conversationConfig: {
      agent: {
        prompt: {
          prompt: 'You are a friendly customer support agent.',
        },
      },
    },
  },
  { branchId: 'agtbrch_xxxx' }
);
```

Im angegebenen Branch wird automatisch eine neue Version erstellt. Ein vorhandener Entwurf dieses Nutzers in diesem Branch wird verworfen.

## Traffic bereitstellen

Verwenden Sie den Deployments-Endpunkt, um Traffic auf Branches zu verteilen. Dies ermöglicht schrittweise Rollouts und A/B-Tests.

```python
deployment = client.conversational_ai.agents.deployments.create(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    deployments=[
        {"branch_id": "agtbrch_main", "percentage": 90},
        {"branch_id": "agtbrch_xxxx", "percentage": 10}
    ]
)
```

```javascript
const deployment = await client.conversationalAi.agents.deployments.create('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  deployments: [
    { branchId: 'agtbrch_main', percentage: 90 },
    { branchId: 'agtbrch_xxxx', percentage: 10 },
  ],
});
```

> **Warning**
>
> Alle Prozentwerte müssen zusammen genau 100 % ergeben. Andernfalls schlägt die Bereitstellung fehl.

Das Traffic-Routing ist anhand der Konversations-ID deterministisch. Dadurch erreicht derselbe Nutzer über verschiedene Sitzungen hinweg konsistent denselben Branch.

## Branches mergen

Wenn Sie mit den Änderungen in einem Branch zufrieden sind, mergen Sie sie in einen anderen Branch. Jeder nicht archivierte Branch kann in jeden anderen nicht archivierten Branch gemergt werden, nicht nur in Main.

> **Note**
>
> Wenn Änderungen eines Branches vor dem Mergen geprüft werden sollen oder Sie einen Branch erreichen möchten, für den Sie keine
> Schreibberechtigung haben, erstellen Sie einen [Merge-Vorschlag](/docs/de/eleven-agents/operate/merge-proposals), statt direkt zu
> mergen.

```python
merge = client.conversational_ai.agents.branches.merge(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    source_branch_id="agtbrch_xxxx",
    target_branch_id="agtbrch_main",
    archive_source_branch=True,  # Default: true
    force=False  # Default: false
)
```

```javascript
const merge = await client.conversationalAi.agents.branches.merge('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  targetBranchId: 'agtbrch_main',
  archiveSourceBranch: true, // Default: true
  force: false, // Default: false
});
```

Beim Mergen:

* Wird eine neue Version im Ziel-Branch mit der Konfiguration des Quell-Branches erstellt
* Wird der Quell-Branch optional archiviert (Standardverhalten)
* Wird Traffic automatisch vom Quell-Branch auf den Ziel-Branch übertragen

> **Note**
>
> Das Mergen schlägt mit `no_new_changes_to_merge` fehl, wenn der Quell-Branch vom Ziel-Branch erstellt wurde (und keine
> neuen Commits darüber hinaus enthält), und mit `branch_already_merged`, wenn er bereits in dieses Ziel
> gemergt wurde.

### Merge-Konflikte auflösen

Wenn eine Einstellung seit der Abspaltung sowohl im Quell- als auch im Ziel-Branch geändert wurde, wird standardmäßig der Wert des zuletzt aktualisierten Branches beibehalten. Setzen Sie `force=True`, um unabhängig von Zeitstempeln immer den Wert des Quell-Branches zu übernehmen.

Sehen Sie sich das Ergebnis eines Merges einschließlich aller Felder, die überschrieben würden, an, bevor Sie ihn festschreiben:

```python
preview = client.conversational_ai.agents.branches.preview_merge(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    source_branch_id="agtbrch_xxxx",
    target_branch_id="agtbrch_main",
    force=False
)

print(preview.overridden_fields)
print(preview.conflicts)
```

```javascript
const preview = await client.conversationalAi.agents.branches.previewMerge('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  targetBranchId: 'agtbrch_main',
  force: false,
});

console.log(preview.overriddenFields);
console.log(preview.conflicts);
```

## Branches auf Main rebasen

Beim Rebasing werden die neuesten Änderungen aus dem Main-Branch in einen anderen Branch übernommen, ähnlich wie bei einem Git-Rebase. So bleibt ein langfristig genutzter Branch auf dem Stand von Main, ohne die eigenen Änderungen des Branches bereits zurückzumergen.

```python
client.conversational_ai.agents.branches.rebase(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)
```

```javascript
await client.conversationalAi.agents.branches.rebase('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');
```

Beim Rebasing:

* Wird eine neue Version im Branch erstellt, die die neuesten Änderungen von Main enthält
* Bleiben die eigenen Änderungen des Branches erhalten: Wenn eine Einstellung sowohl im Branch als auch in Main bearbeitet wurde, bleibt immer der Wert des Branches erhalten
* Schlägt der Vorgang mit `branch_already_up_to_date` fehl, wenn der Branch bereits alle Änderungen von Main enthält

> **Note**
>
> Nur Nicht-Main-Branches können und nur auf Main rebasiert werden. Ein Rebase des Main-Branches selbst
> gibt den Fehler `cannot_rebase_main` zurück.

Sehen Sie sich das Ergebnis eines Rebase an, bevor Sie ihn festschreiben:

```python
preview = client.conversational_ai.agents.branches.preview_rebase(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)

print(preview.overridden_fields)
```

```javascript
const preview = await client.conversationalAi.agents.branches.previewRebase('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx');

console.log(preview.overriddenFields);
```

## Branches archivieren

Archivieren Sie Branches, die Sie nicht mehr benötigen. So bleibt Ihre Branch-Liste übersichtlich.

```python
client.conversational_ai.agents.branches.update(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    archived=True
)
```

```javascript
await client.conversationalAi.agents.branches.update('agent_7101k5zvyjhmfg983brhmhkd98n6', 'agtbrch_xxxx', {
  archived: true,
});
```

> **Warning**
>
> Sie können keinen Branch archivieren, dem Traffic zugewiesen ist. Entfernen Sie vor dem Archivieren den gesamten Traffic.

Archivierte Branches können durch Setzen von `archived=False` wiederhergestellt werden.

## Einen versionierten Agenten duplizieren

Beim Duplizieren eines Agenten wird ein neuer Agent erstellt, der eine Kopie jedes nicht archivierten Branches des Quell-Agenten enthält, nicht nur des Main-Branches.

```python
duplicate = client.conversational_ai.agents.duplicate(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    name="Copy of my agent"
)

print(duplicate.agent_id)
```

```javascript
const duplicate = await client.conversationalAi.agents.duplicate('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  name: 'Copy of my agent',
});

console.log(duplicate.agentId);
```

Im duplizierten Agenten:

* Wird der Main-Branch aus der neuesten Version im Main-Branch des Quell-Agenten erstellt
* Wird jeder andere nicht archivierte Branch mit demselben Namen und derselben Beschreibung neu erstellt, ausgehend von der neuesten Version in diesem Branch
* Beginnt jeder Branch mit einer einzelnen Version, da der Versionsverlauf nicht kopiert wird
* Werden archivierte Branches und Entwürfe nicht kopiert
* Werden Traffic-Bereitstellungen nicht kopiert. Daher wird der gesamte Traffic an den Main-Branch geleitet, bis Sie Traffic für andere Branches [bereitstellen](#deploying-traffic)

Branch- und Versions-IDs im Duplikat sind neu. Aktualisieren Sie daher alle Verweise auf die IDs des Quell-Agenten.

## Bestimmte Versionen abrufen

Sie können einen Agenten mit einer bestimmten Version oder an der Spitze eines Branches abrufen.

### Agenten mit bestimmter Version abrufen

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    version_id="agtvrsn_xxxx"
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  versionId: 'agtvrsn_xxxx',
});
```

### Agenten an der Branch-Spitze abrufen

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx"
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  branchId: 'agtbrch_xxxx',
});
```

### Entwurfsänderungen einbeziehen

```python
agent = client.conversational_ai.agents.get(
    agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6",
    branch_id="agtbrch_xxxx",
    include_draft=True
)
```

```javascript
const agent = await client.conversationalAi.agents.get('agent_7101k5zvyjhmfg983brhmhkd98n6', {
  branchId: 'agtbrch_xxxx',
  includeDraft: true,
});
```

## Einstellungsreferenz

### Versionierte Einstellungen

Diese Einstellungen können sich zwischen Versionen und Branches unterscheiden:

| Kategorie                               | Einstellungen                                                                                                                                                                                                                                                                                                                                             |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Konversationskonfiguration**          | System-Prompt, Agentenpersönlichkeit, LLM-Auswahl und -Parameter, Stimmeneinstellungen (TTS-Modell, Stimmen-ID), Tool-Konfiguration, Wissensdatenbank, erste Nachricht, Spracheinstellungen, Sprecherwechselerkennung, Unterbrechungseinstellungen                                                                                                        |
| **Versionierte Plattformeinstellungen** | `evaluation` – Auswertungskriterien, `widget` – Erscheinungsbild und Verhalten des Widgets, `data_collection` – Extraktion strukturierter Daten, `overrides` – Überschreibungen für die Gesprächsinitiierung, `workspace_overrides` – Webhook-Konfiguration, `testing` – Testkonfigurationen, `safety` – Schutzmechanismen (IVC-/Nicht-IVC-Einstellungen) |
| **Workflow**                            | Vollständige Workflow-Definition (Knoten und Kanten)                                                                                                                                                                                                                                                                                                      |

### Einstellungen pro Agent

Diese Einstellungen gehören zum Agenten und nicht zu einer Version. Daher teilen sie sich alle Branches:

| Einstellung                             | Beschreibung                                                            |
| --------------------------------------- | ----------------------------------------------------------------------- |
| `name`, `tags`                          | Agentenname und Tags                                                    |
| `auth`                                  | Authentifizierungseinstellungen und Allowlist                           |
| `call_limits`                           | Parallelitäts- und Tageslimits                                          |
| `queueing_config`                       | Warteschlange und Warteton für Anrufer über dem Parallelitätslimit      |
| `privacy`                               | Aufbewahrungseinstellungen, Zero-Retention-Modus und Nutzererinnerungen |
| `analysis_llm`                          | LLM für die Analyse nach dem Anruf                                      |
| `topic_discovery`, `sentiment_analysis` | Analyse-Einstellungen auf Agentenebene                                  |
| `simulation_library`                    | Einstellungen der Simulationsbibliothek                                 |
| `alerting`                              | Alert-Webhooks und Überwachungsschwellenwerte                           |
| `ban`                                   | Sperrstatus (nur Admins)                                                |

> **Warning**
>
> Einstellungen pro Agent können nur im Main-Branch geändert werden. In anderen Branches zeigt das Dashboard
> sie schreibgeschützt an. Wenn Sie eine Version in einem Nicht-Main-Branch veröffentlichen, werden Änderungen daran verworfen.
> Auch ein anschließendes Mergen des Branches in Main übernimmt sie nicht. Wechseln Sie zum Main-Branch, um
> sie zu ändern. Nach der Veröffentlichung dort gilt die Änderung für jeden Branch.

## Best Practices

#### Tests vor dem Erstellen eines Branches anlegen

Richten Sie [automatisierte Tests](/docs/de/eleven-agents/customization/agent-testing) ein, die das
erwartete Verhalten abbilden, bevor Sie einen neuen Branch erstellen. Dadurch entsteht eine Ausgangsbasis und Sie erkennen
Regressionen früh, wenn Sie Ihr Experiment weiterentwickeln.

#### Aussagekräftige Branch-Namen verwenden

Wählen Sie Branch-Namen, die den Zweck des Experiments klar vermitteln. Fügen Sie den Funktions-
namen, die Hypothese oder die Ticketnummer zur einfachen Referenz hinzu, z. B. `feature/new-greeting-flow` oder
`experiment/shorter-responses`.

#### Zweck von Branches dokumentieren

Verwenden Sie das Beschreibungsfeld des Branches, um zu erläutern, welche Hypothese Sie testen, welche Metriken
Erfolg definieren und welche Abhängigkeiten oder Aspekte zu beachten sind. So verstehen Teammitglieder aktive
Experimente besser.

#### Entwürfe für laufende Arbeiten verwenden

Speichern Sie Entwürfe regelmäßig, während Sie Änderungen weiterentwickeln. Dadurch bleibt Ihre Arbeit erhalten, ohne
unnötige Versionen zu erstellen. Schreiben Sie Änderungen erst fest, wenn Sie bereit zum Testen oder Bereitstellen sind.

#### Mit kleinen Traffic-Anteilen beginnen

Wenn Sie einen neuen Branch bereitstellen, beginnen Sie mit 5–10 % des Traffics. Das begrenzt die Auswirkungen bei Problemen,
liefert aber dennoch aussagekräftige Daten.

#### Wichtige Metriken vor der Erhöhung des Traffics überwachen

Verwenden Sie das [Analytics-Dashboard](/docs/de/eleven-agents/dashboard), um die Performance von Branches zu vergleichen.
Achten Sie auf Anrufabschlussraten, durchschnittliche Konversationsdauer, Erfolgsbewertungen und
Tool-Ausführungsraten. Erhöhen Sie den Traffic nur, wenn die Metriken Ihre Main-Branch-
Ausgangsbasis erreichen oder übertreffen.

#### Traffic schrittweise erhöhen

Erhöhen Sie den Traffic stufenweise (10 % → 25 % → 50 % → 100 %), wenn das Vertrauen wächst. Dieser Ansatz
minimiert Risiken und validiert die Performance in jeder Phase.

#### Branches nur kurz offen halten

Mergen Sie erfolgreiche Experimente zeitnah, um Konfigurationsabweichungen zu vermeiden. Bei Branches, die
länger offen bleiben müssen, rebasen Sie sie regelmäßig auf Main, damit sie nicht zu stark abweichen und
schwieriger zu mergen werden.

## Nächste Schritte

#### [Experimente](/docs/de/eleven-agents/operate/experiments)

Führen Sie A/B-Tests mit Branches und Traffic-Bereitstellung durch

#### [Tests](/docs/de/eleven-agents/customization/agent-testing)

Richten Sie automatisierte Tests für Ihre Agentenversionen ein

#### [Analytics](/docs/de/eleven-agents/dashboard)

Überwachen Sie die Performance verschiedener Branches

#### [CLI](/docs/de/eleven-agents/operate/cli)

Verwalten Sie die Versionierung über die Befehlszeile