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

# Wersjonowanie agentów

Wersjonowanie agentów pozwala testować różne konfiguracje agenta bez ryzyka dla środowiska produkcyjnego. Twórz odizolowane gałęzie, testuj zmiany i stopniowo wdrażaj aktualizacje, rozdzielając ruch procentowo.

> **Note**
>
> Chcesz przeprowadzać testy A/B? Zobacz [Eksperymenty](/docs/pl/eleven-agents/operate/experiments), aby poznać zalecany sposób testowania zmian agenta na rzeczywistym ruchu.

## Omówienie

System wersjonowania oferuje:

* **Niezmienne migawki** konfiguracji agenta w dowolnym momencie
* **Odizolowane gałęzie** do testowania zmian przed wdrożeniem
* **Podział ruchu**, który pozwala stopniowo wdrażać zmiany dla części użytkowników
* **Scalanie**, aby przenosić zmiany z dowolnej gałęzi do innej gałęzi
* **Rebase**, aby pobierać najnowsze zmiany z głównej gałęzi do gałęzi

> **Note**
>
> Po włączeniu wersjonowania dla agenta nie można go wyłączyć. Weź to pod uwagę przed włączeniem
> wersjonowania dla istniejących agentów.

## Kluczowe pojęcia

### Wersje

Wersja to niezmienna migawka konfiguracji agenta w określonym momencie. Każda wersja ma unikalny identyfikator (format: `agtvrsn_xxxx`) i zawiera:

* `conversation_config` - prompt systemowy, ustawienia LLM, konfigurację głosu, narzędzia, bazę wiedzy
* `platform_settings` - wersjonowany podzbiór obejmujący ustawienia ewaluacji, widżetu, zbierania danych i zabezpieczeń
* `workflow` - pełną definicję workflow z węzłami i krawędziami

Wersje są tworzone automatycznie, gdy zapisujesz zmiany w wersjonowanym agencie. Po utworzeniu wersji nie można jej zmodyfikować.

### Gałęzie

Gałęzie to nazwane linie rozwoju, podobne do gałęzi git. Pozwalają pracować nad zmianami w izolacji przed scaleniem ich z powrotem z główną gałęzią.

* Każdy wersjonowany agent ma gałąź **Main**, której nie można usunąć ani zarchiwizować
* Dodatkowe gałęzie można tworzyć z dowolnej wersji na dowolnej istniejącej gałęzi, nie tylko z main
* Gałęzie można scalać z dowolną inną gałęzią, a gałęzie inne niż main można rebase'ować na main, aby pobrać najnowsze zmiany
* Każda gałąź ma: id (`agtbrch_xxxx`), nazwę, opis i listę wersji
* Nazwy gałęzi mogą zawierać: litery, cyfry oraz `() [] {} - / .` (maks. 140 znaków)

### Wdrażanie ruchu

Ruch można dzielić procentowo między wiele gałęzi, co umożliwia stopniowe wdrożenia i testy A/B.

* Suma procentów musi zawsze wynosić dokładnie **100%**
* Kierowanie ruchu jest **deterministyczne** na podstawie identyfikatora rozmowy (ten sam użytkownik jest zawsze kierowany do tej samej gałęzi)
* Można archiwizować tylko niezarchiwizowane gałęzie z 0% ruchu

### Wersje robocze

Niezapisane zmiany są przechowywane jako wersje robocze, dzięki czemu możesz nad nimi pracować bez natychmiastowego tworzenia nowej wersji.

* Wersje robocze są **na użytkownika i gałąź** (każdy członek zespołu ma własną wersję roboczą)
* Wersje robocze są automatycznie odrzucane po zatwierdzeniu nowej wersji
* Wersje robocze są też odrzucane podczas scalania z gałęzią

## Włączanie wersjonowania

Wersjonowanie jest opcjonalne i trzeba je wyraźnie włączyć. Możesz je włączyć podczas tworzenia nowego agenta lub dla istniejącego agenta.

> **Warning**
>
> Po włączeniu wersjonowania nie można go wyłączyć. To trwała zmiana w agencie.

### Włączanie podczas tworzenia agenta

#### Włącz w panelu

Otwórz agenta w panelu, przejdź do **Ustawień** i włącz wersjonowanie. Po włączeniu pojawi się karta **Wersjonowanie**, w której możesz zarządzać gałęziami, wersjami roboczymi, wersjami i wdrażaniem ruchu.

#### Włącz przez API

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

### Włączanie dla istniejącego agenta

#### Włącz w panelu

Otwórz agenta w panelu, przejdź do **Ustawień** i włącz wersjonowanie.

#### Włącz przez API

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

Włączenie wersjonowania tworzy początkową gałąź „Main” z pierwszą wersją zawierającą bieżącą konfigurację agenta.

## Praca z gałęziami

### Tworzenie gałęzi

Gałęzie można tworzyć z dowolnej wersji na dowolnej gałęzi, nie tylko z main. Opcjonalnie możesz dodać zmiany konfiguracji, które zostaną zastosowane w początkowej wersji nowej gałęzi.

```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 gałęzi

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

```

### Pobieranie szczegółów gałęzi

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

```

## Zatwierdzanie zmian

Gdy aktualizujesz agenta z włączonym wersjonowaniem, podaj `branch_id`, aby utworzyć nową wersję w tej gałęzi.

#### Aktualizuj w panelu

Otwórz kartę **Wersjonowanie** agenta, przełącz się na docelową gałąź, edytuj konfigurację i zapisz ją, aby utworzyć nową wersję.

#### Aktualizuj przez CLI

Przekaż flagę `--branch`, aby wysłać zmiany do konkretnej gałęzi według nazwy lub ID. Gałąź musi już istnieć.

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

#### Aktualizuj przez API

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

Nowa wersja jest automatycznie tworzona w podanej gałęzi, a istniejąca wersja robocza tego użytkownika w tej gałęzi zostaje odrzucona.

## Wdrażanie ruchu

Użyj endpointu wdrożeń, aby rozdzielić ruch między gałęzie. Umożliwia to stopniowe wdrożenia i testy A/B.

```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**
>
> Suma wszystkich wartości procentowych musi wynosić dokładnie 100%. Wdrożenie się nie powiedzie, jeśli tak nie będzie.

Kierowanie ruchu jest deterministyczne na podstawie identyfikatora rozmowy, więc ten sam użytkownik zawsze trafia do tej samej gałęzi w różnych sesjach.

## Scalanie gałęzi

Gdy zmiany w gałęzi są gotowe, scal je z inną gałęzią. Każdą niezarchiwizowaną gałąź można scalić z dowolną inną niezarchiwizowaną gałęzią, nie tylko z main.

> **Note**
>
> Aby zmiany w gałęzi zostały sprawdzone przed scaleniem lub aby dotrzeć do gałęzi, do której nie masz
> uprawnień do zapisu, otwórz [propozycję scalenia](/docs/pl/eleven-agents/operate/merge-proposals) zamiast
> scalać bezpośrednio.

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

Scalanie:

* Tworzy nową wersję w docelowej gałęzi z konfiguracją gałęzi źródłowej
* Opcjonalnie archiwizuje gałąź źródłową (domyślne zachowanie)
* Automatycznie przenosi ruch z gałęzi źródłowej do docelowej

> **Note**
>
> Scalanie kończy się błędem `no_new_changes_to_merge`, jeśli gałąź źródłowa została utworzona z gałęzi
> docelowej (i nie ma żadnych nowych commitów poza nią), oraz błędem `branch_already_merged`, jeśli została
> już scalona z tą gałęzią docelową.

### Rozwiązywanie konfliktów scalenia

Jeśli ustawienie zostało zmienione zarówno w gałęzi źródłowej, jak i docelowej od czasu ich rozdzielenia, domyślnie zachowana zostanie wartość z gałęzi aktualizowanej później. Ustaw `force=True`, aby zawsze wybrać wartość z gałęzi źródłowej, niezależnie od znaczników czasu.

Przed zatwierdzeniem podejrzyj wynik scalenia, w tym pola, które zostałyby nadpisane:

```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 gałęzi na main

Rebase pobiera najnowsze zmiany z głównej gałęzi do innej gałęzi, podobnie jak git rebase. Dzięki temu długotrwała gałąź pozostaje aktualna względem main bez scalania z powrotem jej własnych zmian.

```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:

* Tworzy nową wersję w gałęzi, która uwzględnia najnowsze zmiany z main
* Zachowuje własne zmiany gałęzi: jeśli ustawienie edytowano zarówno w gałęzi, jak i w main, zawsze zostaje wartość z gałęzi
* Kończy się błędem `branch_already_up_to_date`, jeśli gałąź zawiera już wszystkie zmiany z main

> **Note**
>
> Rebase można wykonać tylko dla gałęzi innych niż main i wyłącznie na main. Próba wykonania rebase
> dla samej gałęzi main zwraca błąd `cannot_rebase_main`.

Przed zatwierdzeniem podejrzyj wynik rebase:

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

## Archiwizowanie gałęzi

Archiwizuj gałęzie, których już nie potrzebujesz. Dzięki temu lista gałęzi pozostaje uporządkowana.

```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**
>
> Nie możesz zarchiwizować gałęzi, do której przypisano ruch. Przed archiwizacją usuń cały ruch.

Zarchiwizowane gałęzie można przywrócić, ustawiając `archived=False`.

## Duplikowanie wersjonowanego agenta

Duplikowanie agenta tworzy nowego agenta zawierającego kopię każdej niezarchiwizowanej gałęzi agenta źródłowego, a nie tylko głównej gałęzi.

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

W zduplikowanym agencie:

* Główna gałąź jest tworzona z najnowszej wersji na głównej gałęzi agenta źródłowego
* Każda inna niezarchiwizowana gałąź jest odtwarzana z tą samą nazwą i opisem, zaczynając od najnowszej wersji w tej gałęzi
* Każda gałąź zaczyna z jedną wersją, ponieważ historia wersji nie jest kopiowana
* Zarchiwizowane gałęzie i wersje robocze nie są kopiowane
* Wdrożenia ruchu nie są kopiowane, więc cały ruch trafia do głównej gałęzi, dopóki nie [wdrożysz ruchu](#deploying-traffic) do innych gałęzi

Identyfikatory gałęzi i wersji w duplikacie są nowe, więc zaktualizuj wszelkie odwołania do identyfikatorów agenta źródłowego.

## Pobieranie konkretnych wersji

Możesz pobrać agenta w konkretnej wersji lub na końcu gałęzi.

### Pobieranie agenta w konkretnej wersji

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

### Pobieranie agenta na końcu gałęzi

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

### Uwzględnianie zmian z wersji roboczej

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

## Dokumentacja ustawień

### Ustawienia wersjonowane

Te ustawienia mogą różnić się między wersjami i gałęziami:

| Kategoria                             | Ustawienia                                                                                                                                                                                                                                                                                                              |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Konfiguracja rozmowy**              | Prompt systemowy, osobowość agenta, wybór i parametry LLM, ustawienia głosu (model TTS, ID głosu), konfiguracja narzędzi, baza wiedzy, pierwsza wiadomość, ustawienia języka, wykrywanie tur, ustawienia przerwań                                                                                                       |
| **Wersjonowane ustawienia platformy** | `evaluation` - kryteria ewaluacji, `widget` - wygląd i działanie widżetu, `data_collection` - ekstrakcja uporządkowanych danych, `overrides` - nadpisania rozpoczęcia rozmowy, `workspace_overrides` - konfiguracja webhooków, `testing` - konfiguracje testów, `safety` - mechanizmy ochronne (ustawienia IVC/non-IVC) |
| **Workflow**                          | Pełna definicja workflow (węzły i krawędzie)                                                                                                                                                                                                                                                                            |

### Ustawienia na poziomie agenta

Te ustawienia należą do agenta, a nie do wersji, więc są wspólne dla wszystkich gałęzi:

| Ustawienie                              | Opis                                                                                |
| --------------------------------------- | ----------------------------------------------------------------------------------- |
| `name`, `tags`                          | Nazwa i tagi agenta                                                                 |
| `auth`                                  | Ustawienia uwierzytelniania i lista dozwolonych                                     |
| `call_limits`                           | Limity współbieżności i dzienne                                                     |
| `queueing_config`                       | Kolejka oczekiwania i dźwięk oczekiwania dla dzwoniących ponad limit współbieżności |
| `privacy`                               | Ustawienia przechowywania, tryb bez przechowywania i pamięć użytkownika             |
| `analysis_llm`                          | LLM używany do analizy po rozmowie                                                  |
| `topic_discovery`, `sentiment_analysis` | Ustawienia analizy na poziomie agenta                                               |
| `simulation_library`                    | Ustawienia biblioteki symulacji                                                     |
| `alerting`                              | Webhooki alertów i progi monitorowania                                              |
| `ban`                                   | Status blokady (tylko administrator)                                                |

> **Warning**
>
> Ustawienia na poziomie agenta można zmieniać tylko w głównej gałęzi. W innych gałęziach panel pokazuje
> je jako tylko do odczytu, a opublikowanie wersji w gałęzi innej niż main odrzuca wszelkie ich zmiany.
> Późniejsze scalenie gałęzi z main również ich nie zastosuje. Przełącz się na główną gałąź, aby je
> zmienić; po opublikowaniu tam zmiana zostanie zastosowana w każdej gałęzi.

## Dobre praktyki

#### Twórz testy przed utworzeniem gałęzi

Skonfiguruj [automatyczne testy](/docs/pl/eleven-agents/customization/agent-testing), które opisują
oczekiwane zachowanie przed utworzeniem nowej gałęzi. Ustanowisz w ten sposób punkt odniesienia i łatwiej wykryjesz
regresje na wczesnym etapie podczas pracy nad eksperymentem.

#### Używaj opisowych nazw gałęzi

Wybieraj nazwy gałęzi, które jasno określają cel eksperymentu. Dodaj nazwę funkcji,
hipotezę lub numer zgłoszenia, aby łatwo je rozpoznać (np. `feature/new-greeting-flow` lub
`experiment/shorter-responses`).

#### Dokumentuj cele gałęzi

W polu opisu gałęzi wyjaśnij, jaką hipotezę testujesz, jakie metryki definiują
sukces oraz jakie są zależności i kwestie do uwzględnienia. Pomoże to członkom zespołu zrozumieć aktywne
eksperymenty.

#### Używaj wersji roboczych podczas pracy

Często zapisuj wersje robocze podczas pracy nad zmianami. Zachowasz dzięki temu swoją pracę bez tworzenia
niepotrzebnych wersji. Zatwierdzaj zmiany dopiero, gdy są gotowe do testów lub wdrożenia.

#### Zacznij od małego procentu ruchu

Wdrażając nową gałąź, zacznij od 5–10% ruchu. Ograniczy to ryzyko w razie problemów,
a jednocześnie zapewni miarodajne dane.

#### Monitoruj kluczowe metryki przed zwiększeniem ruchu

Użyj [panelu analitycznego](/docs/pl/eleven-agents/dashboard), aby porównać wydajność gałęzi.
Sprawdzaj wskaźniki ukończenia rozmów, średni czas rozmowy, wyniki ewaluacji sukcesu i
wskaźniki wykonania narzędzi. Zwiększaj ruch tylko wtedy, gdy metryki osiągają lub przewyższają
poziom bazowy głównej gałęzi.

#### Zwiększaj ruch stopniowo

Zwiększaj ruch etapami (10% → 25% → 50% → 100%), gdy rośnie twoja pewność. Takie podejście
minimalizuje ryzyko i pozwala potwierdzić wydajność na każdym etapie.

#### Nie utrzymuj gałęzi zbyt długo

Szybko scalaj udane eksperymenty, aby uniknąć rozbieżności konfiguracji. W przypadku gałęzi, które muszą
pozostać otwarte dłużej, okresowo wykonuj rebase na main, aby nie oddaliły się zbyt mocno i nie stały się
trudniejsze do scalenia.

## Kolejne kroki

#### [Eksperymenty](/docs/pl/eleven-agents/operate/experiments)

Przeprowadzaj testy A/B za pomocą gałęzi i wdrażania ruchu

#### [Testowanie](/docs/pl/eleven-agents/customization/agent-testing)

Skonfiguruj automatyczne testy dla wersji agenta

#### [Analityka](/docs/pl/eleven-agents/dashboard)

Monitoruj wydajność w różnych gałęziach

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

Zarządzaj wersjonowaniem z wiersza poleceń