# Subagenten und parallele Arbeit in Claude Code: So führen Sie mehrere Aufgaben gleichzeitig aus

> Umfassender Leitfaden zur Parallelisierung von Aufgaben in Claude Code: Subagent-Architektur, gemeinsamer und isolierter Kontext, Fan-Out- und Swarm-Muster, CLI-Nutzung mit dem Flag -p sowie Token-Optimierung.

## 1. Was sind Subagenten in Claude Code: vom sequenziellen zum parallelen Denken

Eine Standard-Arbeitssitzung von **Claude Code** funktioniert in einem streng sequenziellen Modus (Single-Threaded Event Loop). Der Benutzer sendet eine Anfrage, der Agent liest den Kontext, führt eine Suche durch, bearbeitet Dateien, startet Linter oder Tests und erst nach Abschluss der gesamten Kette geht er zur nächsten Aufgabe über. Wenn ein Projekt skaliert wird und der Entwickler vor Dutzenden voneinander unabhängigen Aufgaben steht, führt dieser sequenzielle Ansatz zu unnötigen Zeitverzögerungen und einer schnellen Überlastung des Kontextfensters.

Um diese Einschränkung zu überwinden, wurde das Konzept der **Subagenten** in die Architektur von Claude Code integriert – isolierte, autonome Arbeitsinstanzen des Modells, denen unabhängige Fragmente der Gesamtaufgabe delegiert werden.

```mermaid
flowchart TD
    subgraph Sequential ["Послідовний режим (Single Session)"]
        S1["Завдання 1"] --> S2["Завдання 2"] --> S3["Завдання 3"] --> S4["Фінальний результат"]
    end

    subgraph Parallel ["Паралельний режим (Subagent Orchestration)"]
        P_Parent["Батьківська сесія Claude Code"] --> P1["Субагент 1: Auth"]
        P_Parent --> P2["Субагент 2: Validation"]
        P_Parent --> P3["Субагент 3: Formatting"]
        P1 --> P_Join{"Агрегація результатів"}
        P2 --> P_Join
        P3 --> P_Join
        P_Join --> P_Done["Готовий pull request / звіт"]
    end
```

### Schlüsselmerkmale eines autonomen Subagenten

- **Eigenes isoliertes Kontextfenster:** Der Subagent ist nicht mit der langen Dialoghistorie der Hauptsitzung belastet und konzentriert sich ausschließlich auf die zugewiesene Task.
- **Gemeinsamer Zugriff auf das Dateisystem:** Der Subagent kann die Verzeichnisstruktur, Projektkonfigurationen und Quellcodedateien mit denselben Rechten wie der Hauptprozess lesen.
- **Asynchrone Ausführung:** Mehrere Subagenten arbeiten gleichzeitig und verkürzen die gesamte Ausführungszeit (Wall-Clock Time) proportional zur Anzahl der parallelen Threads.
- **Automatische Aggregation:** Nach Abschluss der Arbeit erstellt der Subagent eine strukturierte Zusammenfassung, gibt sie an die Elternsitzung zurück und gibt die reservierten Ressourcen frei.

> [!NOTE]
> Das einfachste mentale Modell für Subagenten ist effizientes Entwicklungsmanagement. Anstatt dass ein Senior-Ingenieur die Dokumentation für fünf Mikroservices nacheinander selbst schreibt, erstellt er 5 separate Tasks und übergibt sie parallel arbeitenden Ausführenden, wobei er nur das Endergebnis jedes einzelnen überprüft.

---

## 2. Kriterien für Parallelisierung: Wann Aufgaben aufteilen und wann sequenziell arbeiten

Parallelisierung ist kein universelles Allheilmittel. Ihre Effizienz hängt direkt vom Grad der gegenseitigen Unabhängigkeit der Aufgaben ab. Der Versuch, miteinander verbundene Schritte parallel auszuführen, führt unvermeidlich zu Race Conditions und logischen Kollisionen.

| Entwicklungsszenario | Optimaler Modus | Begründung der Wahl |
| :--- | :---: | :--- |
| **Generierung von Unit-Tests für verschiedene Utilities** | Parallel | Module sind unabhängig voneinander, keine gemeinsamen Abhängigkeiten |
| **Multidimensionaler Audit von Sicherheit, SEO und UI** | Parallel | Jeder Bereich analysiert das System unter einem eigenen Blickwinkel, nur lesend |
| **Entwurf des DB-Schemas und Generierung von Migrationen** | Sequenziell | Eine Migration kann nicht geschrieben werden, bevor das Datenmodell finalisiert ist |
| **Bearbeitung derselben Konfigurationsdatei** | Sequenziell | Gleichzeitiges Schreiben durch mehrere Agenten führt zu Merge-Konflikten |
| **Batch-Refactoring unabhängiger Komponenten** | Parallel | Jede Komponente befindet sich in einer separaten Datei ohne Cross-Imports |

### Wann Parallelisierung kontraindiziert ist

1. **Kaskadierende Ergebnisabhängigkeiten:** Wenn Schritt B die Ausgabedaten von Schritt A verwendet. Beispiel: Erst das Datenbank-Schema auditieren, die neue Struktur entwerfen und erst danach die Prisma-Migration generieren.
2. **Gemeinsame Punkte der Dateimodifikation:** Wenn Agent 1 und Agent 2 gleichzeitig versuchen, Änderungen in dieselbe Datei `app.ts` oder `package.json` einzufügen, wird einer der Schreibvorgänge überschrieben oder beschädigt.
3. **Aufgaben, die iteratives menschliches Feedback erfordern:** Wenn die Anforderungen nicht endgültig festgelegt sind und der Entwickler ständig den Kurs über Klärungsfragen korrigieren muss, sollte die Aufgabe in einer interaktiven Einzelsitzung verbleiben.

> [!WARNING]
> Die goldene Regel der Parallelisierung: Bevor Sie einen Pool von Agenten starten, geben Sie eine klare Antwort auf die Frage: **„Kann jeder Agent seine Aufgabe von Anfang bis Ende erfüllen, ohne auf Zwischenergebnisse anderer zu warten?“**. Wenn die Antwort „Nein“ lautet – arbeiten Sie ausschließlich sequenziell.

---

## 3. Architektur und Mechanik des Starts von Subagenten über das Task Tool

Im Inneren der Claude Code Engine erfolgt die Orchestrierung der Subagenten über das systemweite **Task Tool**. Wenn das Modell in der Hauptsitzung erkennt, dass die Aufgabe aus isolierten Komponenten besteht, initiiert es untergeordnete Hintergrundprozesse.

Der Benutzer muss normalerweise nicht manuell systemweite JSON-Anweisungen für das Task Tool aufrufen – es reicht aus, die Aufteilung in der Anfrage klar zu formulieren oder Claude Code die Aufgabe selbstständig dekomponieren zu lassen.

![Architektur des Starts von Claude Code Subagenten und Aggregation der Ergebnisse in die Hauptsitzung](/api/guides-media/ai_agents/claude-code-subagents-and-parallel-work/images/claude-code-subagents-and-parallel-work-step-01.webp)

### Lebenszyklus der parallelen Ausführung

1. **Task-Disposition:** Die Hauptsitzung erhält einen komplexen Prompt (z. B. das Schreiben von Tests für fünf Utilities: `auth.ts`, `validation.ts`, `formatting.ts`, `api-client.ts`, `cache.ts`).
2. **Bildung untergeordneter Kontexte:** Es werden separate Subagenten erstellt, jeder erhält eine persönliche Aufgabe und den Pfad zur Zieldatei.
3. **Autonome Arbeit:** Jeder Agent liest parallel den Quellcode seines Moduls, untersucht Datentypen, generiert den entsprechenden Testsatz und prüft dessen Ausführung.
4. **Rückführung (Aggregation):** Die Hauptsitzung wartet auf den Abschluss aller Threads, erhält die finalen Ausführungsstatus und präsentiert dem Entwickler einen konsolidierten Bericht.

---

## 4. Gemeinsamer vs. isolierter Kontext: Was sehen Subagenten

Die häufigste Fehlerquelle bei Einsteiger-Entwicklern ist die Annahme, dass Subagenten eine telepathische Verbindung untereinander haben oder alles wissen, was im 50. Schritt des Hauptdialogs besprochen wurde. Tatsächlich hält sich das Modell an eine klare Politik der Gedächtnistrennung.

![Gemeinsamer und isolierter Kontext von Subagenten: Was allen Agenten zugänglich ist und was privat bleibt](/api/guides-media/ai_agents/claude-code-subagents-and-parallel-work/images/claude-code-subagents-and-parallel-work-extra-02.webp)

| Ressource oder Systemzustand | Gemeinsam für alle Agenten? | Technische Beschreibung des Zugriffs |
| :--- | :---: | :--- |
| **Projektdateien auf der Disk** | **Ja** | Alle Agenten haben Lese- und Schreibzugriff auf das Arbeitsverzeichnis |
| **Regeln in CLAUDE.md** | **Ja** | Jeder Agent wird automatisch mit den Projekt- und Stack-Regeln initialisiert |
| **Historie des vorherigen Dialogs** | **Nein** | Isoliertes Fenster; der Subagent sieht nur seinen unmittelbaren Prompt |
| **Änderungen in offenen Dateien** | **Erfordert Vorsicht** | Keine automatischen File-Locking-Mechanismen; Risiko von Kollisionen beim Schreiben |

### Sicherstellung der Sicherheit beim Dateischreiben (Write Ownership)

Um Beschädigungen der Codebasis bei paralleler Arbeit zu vermeiden, halten Sie sich an das Prinzip des **einzelnen Dateibesitzers**:

```text
Правильний розподіл зон відповідальності:
Субагент 1 ──► src/utils/auth.test.ts        (створює новий тестовий файл)
Субагент 2 ──► src/utils/validation.test.ts  (створює новий тестовий файл)
Субагент 3 ──► src/utils/formatting.test.ts  (створює новий тестовий файл)

Неприпустимий розподіл (колізія):
Субагент 1 ──► src/index.ts  (модифікує рядок експорту)
Субагент 2 ──► src/index.ts  (модифікує рядок експорту)
Субагент 3 ──► src/index.ts  (модифікує рядок експорту)
```

> [!IMPORTANT]
> Wenn mehrere parallele Agenten erstellte Module in einer einzigen Indexdatei (`src/index.ts` oder `src/routes.ts`) registrieren müssen, **überlassen Sie dies nicht** den Subagenten. Lassen Sie die Agenten nur ihre isolierten Dateien erstellen, während die Registrierung der Imports in der Indexdatei von der Elternsitzung nach Rückkehr aller Ergebnisse durchgeführt wird.

---

## 5. Muster für die Formulierung von Prompts zum Start paralleler Agenten

Obwohl Claude Code Heuristiken zur Erkennung paralleler Aufgaben besitzt, beseitigt eine explizite Anweisung zur gleichzeitigen Ausführung jede Mehrdeutigkeit und optimiert die Dispositionszeit.

### Beispiele für effektive Anfragenformulierung

:::tabs
@tab Basisverteilung
```markdown
Виконай наступні три завдання паралельно через окремих субагентів:

1. Реалізуй валідацію полів у компоненті форми реєстрації (src/components/RegisterForm.tsx).
2. Створи компонент скелетної анімації завантаження для дашборду (src/components/DashboardSkeleton.tsx).
3. Додай підтримку пагінації у хук завантаження користувачів (src/hooks/useUsers.ts).

Переконайся, що кожен агент працює лише зі своїм файлом і не змінює спільні конфігурації.
```
@tab Fan-Out Analyse
```markdown
Працюй паралельно через субагентів:

- Агент 1: Досліди офіційну документацію Stripe API щодо обробки webhook-подій підписок.
- Агент 2: Проаналізуй нашу поточну реалізацію в модулі src/services/billing.ts на предмет вразливостей.
- Агент 3: Спроєктуй TypeScript-інтерфейси для нових вхідних DTO об'єктів у src/types/stripe.ts.

Після завершення зведи результати в єдиний план рефакторингу в головній сесії.
```
@tab Batch-Audit
```markdown
Проведи паралельний аудит кодової бази за чотирма напрямками:

- Напрямок А (Безпека): Сканування на предмет витоку секретів у git-історії та безпеки запитів до бази даних.
- Напрямок Б (Швидкодія): Пошук N+1 запитів у контролерах та виявлення важких імпортів у клієнтських бандлах.
- Напрямок В (Типізація): Перевірка наявності небезпечних типів "any" та пропущених обов'язкових полів інтерфейсів.
- Напрямок Г (Accessibility): Аудит наявності атрибутів aria-label та контрастності кольорів у Tailwind-класах.
```
:::

---

## 6. Vier Schlüsselarchitekturen für parallele Arbeit: Fertige Patterns

Die praktische Erfahrung der Teamautomatisierung mit Claude Code hat vier hocheffiziente architektonische Patterns für die parallele Orchestrierung kristallisiert.

```mermaid
flowchart LR
    subgraph P1 ["1. Research Fan-Out"]
        RF_Q["Архітектурне питання"] --> RF1["PostgreSQL"]
        RF_Q --> RF2["MongoDB"]
        RF_Q --> RF3["SQLite"]
        RF1 & RF2 & RF3 --> RF_M["Порівняльна матриця"]
    end

    subgraph P2 ["2. Audit Swarm"]
        AS_Code["Репозиторій"] --> AS1["Security"]
        AS_Code --> AS2["Performance"]
        AS_Code --> AS3["A11y"]
        AS_Code --> AS4["Code Quality"]
        AS1 & AS2 & AS3 & AS4 --> AS_R["Загальний аудит-звіт"]
    end
```

### Research Fan-Out (Paralleles Recherchieren)

Wird verwendet, wenn für eine technische Entscheidung mehrere alternative Bibliotheken, Technologien oder Architekturansätze gleichzeitig analysiert werden müssen. Jeder Agent recherchiert einen spezifischen Stack nach standardisierten Kriterien (Pro, Contra, Lizenzkompatibilität, Bundle-Größe), woraufhin die Hauptsitzung eine Vergleichsmatrix synthetisiert.

### Audit Swarm (Multidisziplinäres Audit)

Eines der ressourcenschonendsten Patterns hinsichtlich der Zeitersparnis. Anstatt dass ein Agent das gesamte Repository viermal hintereinander für verschiedene Prüfungen liest, werden vier spezialisierte Agenten gleichzeitig gestartet. Da das Audit ausschließlich im Read-only-Modus erfolgt, besteht kein Risiko von Konflikten beim Dateischreiben.

### Batch Processor (Batch-Refactoring)

Wird bei großen Migrationen angewendet, wenn eine identische Transformation auf einem großen Array unabhängiger Dateien durchgeführt werden muss:
- Konvertierung veralteter React Class-Komponenten in Functional Hooks im Verzeichnis `src/components/`.
- Umschreiben von Tests von Jest auf Vitest.
- Aktualisierung der Imports alter Utilities nach deren Auslagerung in ein Monorepo.

### Feature Sprint (Parallele Entwicklung unabhängiger Features)

Die gleichzeitige Entwicklung mehrerer autarker UI-Module oder API-Endpunkte. Zum Beispiel:
- Agent 1 implementiert den Dark-Mode-Toggle (`ThemeToggle.tsx` + entsprechender Context).
- Agent 2 entwickelt das globale Suchformular (`SearchBar.tsx` + Search-Hook).
- Agent 3 erstellt das Dropdown-Menü für Benachrichtigungen (`NotificationsDropdown.tsx`).

---

## 7. Paralleler Start über CLI: Headless-Modus und Flag `-p`

Neben der interaktiven Claude Code Sitzung existiert ein mächtiges Werkzeug für die Systemautomatisierung – der Start von Claude im **Headless-Modus (nicht-interaktiv)** über das Flag `-p` (`--print`). In diesem Modus erhält der Agent den Prompt als Kommandozeilenargument, führt die Aufgabe in einem isolierten Terminalprozess aus und druckt das Ergebnis.

Dies ermöglicht die Nutzung der Standard-Funktionen für Hintergrundprozesse in Unix-ähnlichen Shells (`&`) sowie des Synchronisations-Utilities `wait`.

```bash
# Одночасний запуск трьох фонових процесів Claude Code у bash/zsh
claude -p "Write unit tests for src/utils/auth.ts using Vitest" &
PID_AUTH=$!

claude -p "Write unit tests for src/utils/validation.ts using Vitest" &
PID_VAL=$!

claude -p "Write unit tests for src/utils/formatting.ts using Vitest" &
PID_FMT=$!

# Очікуємо завершення всіх паралельних фонових завдань
echo "Запущено фонові агенти з PID: $PID_AUTH, $PID_VAL, $PID_FMT. Очікування..."
wait $PID_AUTH $PID_VAL $PID_FMT

echo "Всі тести згенеровано успішно! Запуск перевірки..."
npm test
```

### Vorteile der CLI-Parallelisierung

- **Null menschliche Aufsicht:** Ideal für nächtliche CI/CD-Skripte, die Vorbereitung von Testsätzen oder die Vorabgenerierung von Dokumentation.
- **Echte OS-Isolation:** Jeder `claude`-Prozess läuft in einem separaten Adressraum des Betriebssystems.
- **Logging in Dateien:** Die Ausgabe jedes Prozesses kann leicht in eine eigene Log-Datei umgeleitet werden: `claude -p "..." > logs/auth.log 2>&1 &`.

> [!TIP]
> Im Terminal schickt der Operator `&` am Ende eines Befehls den Prozess in den Hintergrund und gibt das Terminal für den sofortigen Start des nächsten Befehls frei. Der eingebettete Befehl `wait` blockiert die Skriptausführung, bis alle angegebenen Hintergrund-PIDs ihre Arbeit beendet haben und Exit-Codes zurückgeben.

---

## 8. Token-Ökonomie, API-Limits und Kostenoptimierung

Parallele Arbeit spart drastisch Ingenieurszeit, erfordert jedoch strenge finanzielle Kontrolle. Jeder Subagent erstellt sein eigenes Kontextfenster, daher erhöht der parallele Start von $N$ Agenten den Tokenverbrauch ungefähr um den Faktor $N$.

```text
Послідовна сесія (1 контекстне вікно):
[Системний промпт] + [Задача 1] ──► [Задача 2] ──► [Задача 3]
Загальна кількість токенів: Базовий контекст + ΔT1 + ΔT2 + ΔT3

Паралельні субагенти (3 незалежні контекстні вікна):
Субагент 1: [Базовий контекст + Задача 1]
Субагент 2: [Базовий контекст + Задача 2]
Субагент 3: [Базовий контекст + Задача 3]
Загальна кількість токенів: (3 × Базовий контекст) + ΔT1 + ΔT2 + ΔT3
```

### Vier Regeln zur Kontrolle des Token-Budgets

1. **Eng definiertes Scope:** Geben Sie dem Agenten keinen allgemeinen Auftrag wie „Mach Ordnung in den Projekttests“. Formulieren Sie konkret: „Schreibe 3 Unit-Tests für die Funktion parseJwt in src/utils/auth.ts“.
2. **Dateifilterung:** Wenn das Projekt große Verzeichnisse enthält (z. B. generierte Typen oder Mocks), stellen Sie sicher, dass sie in `.gitignore` oder `.claudeignore` aufgenommen sind, damit Subagenten keine unnötigen Megabytes Text lesen.
3. **Nutzung von `-p` für triviale Aufgaben:** Der nicht-interaktive Start verhindert die Ansammlung von Gesprächshistorie und gibt das Ergebnis ohne unnötigen Dialogballast aus.
4. **Zusammenlegung zu kleiner Tasks:** Einen separaten Subagenten für die Änderung einer einzigen CSS-Zeile zu erstellen, ist unwirtschaftlich – die Initialisierungskosten der Sitzung übersteigen den Nutzen.

---

## 9. Praktischer Workshop: Schrittweise Implementierung von Tests bis zum Audit Swarm

Festigen wir das erworbene Wissen in einem realen praktischen Workshop mit schrittweiser Ausführung.

### Schritt 1. Auswahl isolierter Module und Vorbereitung

Wählen Sie in Ihrem Repository drei Utility-Module aus, die keine zyklischen oder gegenseitigen Imports haben:
- `src/utils/auth.ts`
- `src/utils/validation.ts`
- `src/utils/formatting.ts`

Stellen Sie sicher, dass die entsprechenden Testdateien fehlen oder aktualisiert werden müssen.

### Schritt 2. Formulierung und Start des parallelen Prompts

Öffnen Sie eine interaktive Claude Code Sitzung im Terminal des Projekts und geben Sie eine strukturierte Anfrage ein:

```markdown
Згенеруй модульні тести для наступних трьох файлів паралельно через субагентів:

1. src/utils/auth.ts -> тести збережи у src/utils/auth.test.ts
2. src/utils/validation.ts -> тести збережи у src/utils/validation.test.ts
3. src/utils/formatting.ts -> тести збережи у src/utils/formatting.test.ts

Вимоги до тестів:
- Використовуй Vitest та розширені перевірки expect.
- Покрий граничні випадки (null, undefined, порожні рядки).
- Не змінюй оригінальні файли утиліт.
```

### Schritt 3. Monitoring und Überprüfung der Ergebnisse

Beobachten Sie die Konsolenausgabe. Sie werden sehen, wie Claude Code untergeordnete Tasks initiiert, den Code jedes Moduls unabhängig verarbeitet und die Beendigung jedes Unterprozesses signalisiert.

Nach Abschluss führen Sie die Prüfung in Ihrem Terminal aus:

```bash
npm run test:run
```

Alle drei neuen Testsätze sollten die Validierung erfolgreich bestehen, ohne Konflikte in der Codebasis.

### Schritt 4. Start des Audit Swarm zur Qualitätsbewertung

Der nächste Schritt ist das Testen des analytischen Patterns Audit Swarm. Senden Sie folgende Anfrage:

```markdown
Проведи комплексний аудит репозиторію через чотирьох паралельних субагентів:

- Агент Безпеки: перевірка на XSS, CSRF, уразливі npm-пакети та хардкод секретів.
- Агент Продуктивності: аналіз розміру бандла, непотрібних ререндерів та важких бібліотек.
- Агент Доступності (a11y): перевірка семантичних HTML-тегів, фокус-пасток та ARIA-параметрів.
- Агент Якості коду: виявлення мертвого коду, дублювання та невиправданого використання any.

Сформуй зведений підсумковий звіт із пріоритетами виправлення (High / Medium / Low).
```

---

## 10. Zusammenfassende Cheatsheet und Checkliste für die Bereitschaft zur Parallelisierung

Speichern Sie diese Checkliste vor dem Start umfangreicher paralleler Pipelines in Claude Code.

### Checkliste für die Bereitschaft zum parallelen Start

- [ ] **Unabhängigkeit der Tasks:** Keine Aufgabe wartet auf ein Zwischenergebnis eines anderen parallelen Agenten.
- [ ] **Isolation des Dateischreibens:** Jeder Agent schreibt Daten in seine eigene neue oder isolierte Datei; kein Kampf um gemeinsame Konfigurationsdateien.
- [ ] **Enge Formulierung der Prompts:** Klare Eingabe- und Ausgabedateien, Technologie-Stack und Erfolgskriterien sind definiert.
- [ ] **Wirtschaftliche Rechtfertigung:** Der Vorteil durch verkürzte Ausführungszeit übersteigt die Kosten für die Duplizierung des Basiskontexts.
- [ ] **Vorbereitung der Umgebung:** Alle externen schweren Verzeichnisse sind über `.claudeignore` aus dem Kontext ausgeschlossen.

### Schnelle Matrix zur Werkzeugwahl

| Aufgabe | Empfohlener Ansatz | Befehl / Methode |
| :--- | :--- | :--- |
| **Homogene Tests für 5+ Module** | Interaktives Claude Code oder CLI `-p` | `claude -p "..." &` |
| **Multiprofessioneller Projekt-Audit** | Audit Swarm in der Sitzung | Interaktiver Prompt mit 4 Agenten |
| **Vergleich von Bibliotheken/Technologien** | Research Fan-Out | Zusammenfassung in einer Tabelle |
| **Tiefgreifendes Refactoring des Systemkerns** | Sequenzielle Sitzung (Single Session) | Normale interaktive Sitzung mit Mensch |

---

## 11. Empfohlene weiterführende Materialien

Um Ihr Wissen über die Arbeit mit dem Claude-Ökosystem und der Prozessautomatisierung zu vertiefen, empfehlen wir unsere neuen Guides:

- 🚀 [Claude Code Projects: Wie ein KI-Agent ein Team autonomer Agenten koordiniert →](/uk/guides/ai_agents/claude-code-projects-multi-agent)
- 📊 [Claude + Excel für Logistiker: 10 fertige Szenarien für Tarif- und Kostenaudits →](/uk/guides/ai_base/claude-excel-logistics-playbook)
- ⚡ [Claude + Notion für Business: Automatisierung von CRM und Aufgaben in 30 Minuten →](/uk/guides/ai_base/claude-notion-business-automation)
- 🤖 [Autonomer KI-Operator in Telegram 24/7: Architektur und 10 funktionierende Szenarien →](/uk/guides/ai_base/telegram-ai-operator-24-7)