> 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.

# Versionshantering för agenter

Versionshantering för agenter gör att du kan experimentera med olika konfigurationer för din agent utan att riskera din produktionskonfiguration. Skapa isolerade grenar, testa ändringar och rulla gradvis ut uppdateringar med trafikdistribution baserad på procentandelar.

> **Note**
>
> Vill du köra A/B-tester? Se [Experiment](/docs/sv/eleven-agents/operate/experiments) för det rekommenderade arbetsflödet för att testa agentändringar mot aktiv trafik.

## Översikt

Versionshanteringssystemet erbjuder:

* **Oföränderliga ögonblicksbilder** av din agentkonfiguration vid varje tidpunkt
* **Isolerade grenar** för att testa ändringar innan de går live
* **Trafikdelning** för att gradvis rulla ut ändringar till en andel av användarna
* **Sammanslagning** för att föra in ändringar från valfri gren i valfri annan gren
* **Rebase** för att hämta de senaste ändringarna från huvudgrenen till en gren

> **Note**
>
> När versionshantering har aktiverats för en agent kan den inte inaktiveras. Tänk på detta innan du aktiverar
> versionshantering för befintliga agenter.

## Grundläggande begrepp

### Versioner

En version är en oföränderlig ögonblicksbild av en agents konfiguration vid en specifik tidpunkt. Varje version har ett unikt ID (format: `agtvrsn_xxxx`) och innehåller:

* `conversation_config` - Systemprompt, LLM-inställningar, röstkonfiguration, verktyg, kunskapsbas
* `platform_settings` - Versionshanterad delmängd som omfattar inställningar för utvärdering, widget, datainsamling och säkerhet
* `workflow` - Fullständig workflow-definition med noder och kanter

Versioner skapas automatiskt när du sparar ändringar i en versionshanterad agent. När en version har skapats kan den inte ändras.

### Grenar

Grenar är namngivna utvecklingslinjer, liknande git-grenar. De låter dig arbeta med ändringar isolerat innan du slår samman dem tillbaka till huvudgrenen.

* Varje versionshanterad agent har en **Main**-gren som inte kan tas bort eller arkiveras
* Ytterligare grenar kan skapas från valfri version på valfri befintlig gren, inte bara huvudgrenen
* Grenar kan slås samman med valfri annan gren, och andra grenar än huvudgrenen kan rebasas på huvudgrenen för att hämta dess senaste ändringar
* Varje gren har: id (`agtbrch_xxxx`), namn, beskrivning och en lista över versioner
* Grennamn kan innehålla: bokstäver, siffror och `() [] {} - / .` (högst 140 tecken)

### Trafikdistribution

Trafik kan delas mellan flera grenar efter procentandel, vilket möjliggör gradvisa utrullningar och A/B-testning.

* Procentandelarna måste alltid uppgå till exakt **100 %**
* Trafikdirigeringen är **deterministisk** baserat på konversations-ID:t (samma användare dirigeras konsekvent till samma gren)
* Endast icke-arkiverade grenar med 0 % trafik kan arkiveras

### Utkast

Osparade ändringar lagras som utkast, så att du kan arbeta med ändringar utan att omedelbart skapa en ny version.

* Utkast är **per användare, per gren** (varje teammedlem har sitt eget utkast)
* Utkast kasseras automatiskt när en ny version sparas
* Utkast kasseras också när de slås samman till en gren

## Aktivera versionshantering

Versionshantering är valfri och måste aktiveras uttryckligen. Du kan aktivera den när du skapar en ny agent eller för en befintlig agent.

> **Warning**
>
> När versionshantering har aktiverats kan den inte inaktiveras. Detta är en permanent ändring av din agent.

### Aktivera när du skapar en agent

#### Aktivera via instrumentpanelen

Öppna din agent på instrumentpanelen, gå till **Settings** och aktivera versionshantering. När den har aktiverats blir fliken **Versioning** tillgänglig för att hantera grenar, utkast, versioner och trafikdistribution.

#### Aktivera via API:et

```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}`);
```

### Aktivera för en befintlig agent

#### Aktivera via instrumentpanelen

Öppna din agent på instrumentpanelen, gå till **Settings** och aktivera versionshantering.

#### Aktivera via API:et

```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,
});
```

När du aktiverar versionshantering skapas den första grenen "Main" med den första versionen som innehåller den aktuella agentkonfigurationen.

## Arbeta med grenar

### Skapa en gren

Grenar kan skapas från valfri version på valfri gren, inte bara huvudgrenen. Du kan valfritt inkludera konfigurationsändringar som tillämpas på den nya grenens första version.

```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}`);

```

### Lista grenar

```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}`);
}

```

### Hämta grendetaljer

```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}`);

```

## Spara ändringar

När du uppdaterar en agent med versionshantering aktiverad anger du `branch_id` för att skapa en ny version på den grenen.

#### Uppdatera via instrumentpanelen

Öppna fliken **Versioning** för din agent, växla till målgrenen, redigera konfigurationen och spara för att skapa en ny version.

#### Uppdatera via CLI

Skicka flaggan `--branch` för att pusha till en specifik gren efter namn eller ID. Grenen måste redan finnas.

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

#### Uppdatera via API:et

```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' }
);
```

En ny version skapas automatiskt på den angivna grenen och eventuella befintliga utkast för den användaren på den grenen kasseras.

## Distribuera trafik

Använd distributionsändpunkten för att fördela trafik mellan grenar. Det möjliggör gradvisa utrullningar och A/B-testning.

```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**
>
> Alla procentandelar måste tillsammans bli exakt 100 %. Distributionen misslyckas annars.

Trafikdirigeringen är deterministisk baserat på konversations-ID:t, vilket säkerställer att samma användare konsekvent når samma gren mellan sessioner.

## Sammanfoga grenar

När du är nöjd med ändringarna i en gren kan du sammanfoga dem med en annan gren. Alla icke-arkiverade grenar kan sammanfogas med andra icke-arkiverade grenar, inte bara med main.

> **Note**
>
> Om du vill att en grens ändringar ska granskas innan de sammanfogas, eller om du vill nå en gren som du inte har
> skrivåtkomst till, öppnar du i stället ett [sammanfogningsförslag](/docs/sv/eleven-agents/operate/merge-proposals)
> i stället för att sammanfoga direkt.

```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
});
```

Sammanfogning:

* Skapar en ny version på målgrenen med källgrenens konfiguration
* Arkiverar valfritt källgrenen (standardbeteende)
* Överför automatiskt trafik från källgrenen till målgrenen

> **Note**
>
> Sammanfogning misslyckas med `no_new_changes_to_merge` om källgrenen skapades från (och inte har
> några nya commits utöver) målgrenen, och med `branch_already_merged` om den redan har sammanfogats
> med det målet.

### Lösa sammanfogningskonflikter

Om en inställning har ändrats på både käll- och målgrenen sedan de delades upp behålls som standard värdet från
den gren som uppdaterades senast. Ange `force=True` för att alltid använda
källgrenens värde i stället, oavsett tidsstämplar.

Förhandsgranska resultatet av en sammanfogning, inklusive eventuella fält som skulle åsidosättas, innan du bekräftar den:

```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);
```

## Rebase av grenar på main

En rebase hämtar de senaste ändringarna från main-grenen till en annan gren, ungefär som git rebase. Det håller en långlivad gren uppdaterad med main utan att ännu sammanfoga grenens egna ändringar tillbaka.

```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');
```

Rebase:

* Skapar en ny version på grenen som innehåller mains senaste ändringar
* Bevarar grenens egna ändringar: om en inställning har redigerats både på grenen och i main behålls alltid grenens värde
* Misslyckas med `branch_already_up_to_date` om grenen redan innehåller alla ändringar från main

> **Note**
>
> Endast andra grenar än main kan rebasa, och endast på main. En rebase av själva main-grenen
> returnerar felet `cannot_rebase_main`.

Förhandsgranska resultatet av en rebase innan du bekräftar den:

```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);
```

## Arkivera grenar

Arkivera grenar som du inte längre behöver. Det hjälper dig att hålla grenlistan organiserad.

```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**
>
> Du kan inte arkivera en gren som har tilldelad trafik. Ta bort all trafik före arkivering.

Arkiverade grenar kan avarkiveras genom att ange `archived=False`.

## Hämta specifika versioner

Du kan hämta en agent vid en specifik version eller vid en grentopp.

### Hämta agent vid specifik version

```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',
});
```

### Hämta agent vid grentopp

```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',
});
```

### Inkludera utkaständringar

```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,
});
```

## Inställningsreferens

### Versionshanterade inställningar

Dessa inställningar kan skilja sig mellan versioner och grenar:

| Kategori                                      | Inställningar                                                                                                                                                                                                                                                                                                                            |
| --------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Konfiguration för konversationer**          | Systemprompt, agentpersonlighet, val av LLM och parametrar, röstinställningar (TTS-modell, röst-ID), verktygskonfiguration, kunskapsbas, första meddelande, språkinställningar, turdetektering, avbrottsinställningar                                                                                                                    |
| **Versionshanterade plattformsinställningar** | `evaluation` – utvärderingskriterier, `widget` – widgetens utseende och beteende, `data_collection` – extrahering av strukturerade data, `overrides` – åsidosättningar för konversationsstart, `workspace_overrides` – konfiguration av webhooks, `testing` – testkonfigurationer, `safety` – skyddsräcken (IVC-/icke-IVC-inställningar) |
| **Workflow**                                  | Fullständig workflow-definition (noder och kanter)                                                                                                                                                                                                                                                                                       |

### Inställningar per agent

Dessa inställningar delas mellan alla versioner:

| Inställning    | Beskrivning                                                          |
| -------------- | -------------------------------------------------------------------- |
| `name`, `tags` | Agentnamn och taggar (uppdateras endast vid commit till main-grenen) |
| `auth`         | Autentiseringsinställningar och tillåtelselista                      |
| `call_limits`  | Samtidighets- och dagliga gränser                                    |
| `privacy`      | Lagringsinställningar och läge utan lagring                          |
| `ban`          | Banstatus (endast administratörer)                                   |

> **Note**
>
> Ändringar av namn och taggar på grenar som inte är main sparas inte för agenten förrän de har sammanfogats med main.

## Bästa praxis

#### Skapa tester innan du skapar en gren

Konfigurera [automatiserade tester](/docs/sv/eleven-agents/customization/agent-testing) som fångar
det förväntade beteendet innan du skapar en ny gren. Det ger dig en baslinje och hjälper dig att hitta
regressioner tidigt när du itererar på experimentet.

#### Använd beskrivande namn på grenar

Välj grensnamn som tydligt beskriver syftet med experimentet. Inkludera funktions-
namnet, hypotesen eller ärendenumret för enkel referens (t.ex. `feature/new-greeting-flow` eller
`experiment/shorter-responses`).

#### Dokumentera grenarnas syfte

Använd fältet för grenbeskrivning för att förklara vilken hypotes du testar, vilka mått som avgör
framgång och eventuella beroenden eller överväganden. Det hjälper teammedlemmar att förstå aktiva
experiment.

#### Använd utkast för pågående arbete

Spara utkast ofta medan du itererar på ändringar. Det bevarar ditt arbete utan att skapa
onödiga versioner. Gör commit först när du är redo att testa eller driftsätta.

#### Börja med små trafikandelar

När du driftsätter en ny gren börjar du med 5–10 % av trafiken. Det begränsar exponeringen om problem uppstår
och ger samtidigt användbar data.

#### Övervaka nyckeltal innan du ökar trafiken

Använd [analysdashboarden](/docs/sv/eleven-agents/dashboard) för att jämföra grenarnas prestanda.
Titta på samtalsfrekvens för slutförande, genomsnittlig konversationslängd, poäng för framgångsutvärdering och
frekvens för verktygskörning. Öka bara trafiken när måtten når eller överträffar
baslinjen för main-grenen.

#### Öka trafiken gradvis

Skala upp trafiken stegvis (10 % → 25 % → 50 % → 100 %) när förtroendet ökar. Detta tillvägagångssätt
minimerar risken samtidigt som prestandan valideras i varje steg.

#### Håll grenarna kortlivade

Sammanfoga lyckade experiment snabbt för att undvika att konfigurationer glider isär. För grenar som behöver
vara öppna längre bör du regelbundet rebasa dem på main så att de inte glider för långt isär och blir
svårare att sammanfoga.

## Nästa steg

#### [Experiment](/docs/sv/eleven-agents/operate/experiments)

Kör A/B-tester med grenar och trafikdriftsättning

#### [Testning](/docs/sv/eleven-agents/customization/agent-testing)

Konfigurera automatiserade tester för dina agentversioner

#### [Analys](/docs/sv/eleven-agents/dashboard)

Övervaka prestanda mellan olika grenar

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

Hantera versionshantering från kommandoraden