# Parallele Coding-Agenten: Claude Code und Codex zusammen

URL: https://agentvera.dev/de/blog/parallel-coding-agents/ · Veröffentlicht: 2026-09-20

Claude Code und Codex als parallele Coding-Agenten nebeneinander betreiben: Arbeit aufteilen, Dateikonflikte mit Worktrees vermeiden, Ausgaben weitergeben.

**Kurz gesagt:**

- Teile die Arbeit entlang von Dateigrenzen auf, gib jedem Agenten ein messbares Ziel und lege vorab fest, wohin die Ausgabe jedes Agenten geht.
- Ein Beispiel-Layout nutzt Claude Code als Architekten, Codex als Tester, der nur in tests/ arbeitet, und ein Terminal für den Dev-Server.
- Flows reichen die letzte Antwort eines Agenten über eine {{output}}-Vorlage an den nächsten weiter, ein Turn-Limit stoppt Schleifen; fang mit zwei Agenten an.

**Parallele Coding-Agenten bedeutet, mehr als einen KI-Coding-Agenten gleichzeitig am selben Projekt laufen zu lassen.** Ein Agent schreibt ein Feature, ein zweiter die Tests, ein dritter aktualisiert die Doku. Gut aufgesetzt teilst du Arbeit auf, die du sonst Schritt für Schritt erledigt hast. Schlecht aufgesetzt überschreiben Agenten dieselben Dateien, der Kontext bläht sich auf, und du verlierst den Überblick, wer was getan hat.

Dieser Beitrag zeigt einen praktischen Weg, Claude Code und Codex nebeneinander zu betreiben: wie du die Arbeit aufteilst, Dateikonflikte vermeidest und Ausgaben von einem Agenten zum nächsten weiterreichst.

## Warum parallele Coding-Agenten?

Der Engpass bei einem einzelnen Agenten ist das Warten. Während er denkt, Dateien liest und Tests ausführt, wartest du entweder oder wechselst zu etwas anderem. Parallele Agenten nutzen diese Wartezeit.

Am meisten lohnen sie sich bei:

- **Unabhängiger Arbeit:** ein Backend-Endpunkt und ein Frontend-Formular, die sich nicht berühren.
- **Schreiben und Prüfen:** ein Agent schreibt den Code, ein anderer die Tests für dieselbe Änderung.
- **Recherche und Umsetzung:** ein Agent vergleicht Bibliotheksoptionen, während ein anderer bestehenden Code bearbeitet.
- **Unterschiedlichen Stärken:** Claude Code und Codex bringen verschiedene Modelle und Werkzeuge mit; beide Ansätze am selben Problem auszuprobieren kann schneller ans Ziel führen. Wie sich die beiden unterscheiden, steht in [Claude Code vs. Codex](/de/blog/claude-code-vs-codex/ "Claude Code vs. Codex: ein ehrlicher Vergleich").

## Drei Regeln für die Aufteilung der Arbeit

Ob parallele Arbeit gelingt, hängt davon ab, wie du sie aufteilst.

### 1. Ziehe Dateigrenzen vorab

Zwei Agenten, die dieselbe Datei bearbeiten, sind der häufigste Fehler. Schreib in die Rolle jedes Agenten, welche Ordner er anfassen darf. Zum Beispiel arbeitet ein Agent nur unter `src/api/`, der andere nur unter `tests/`.

### 2. Gib jedem Agenten ein Ziel

Statt „verbessere das Auth-Modul“ gib ein messbares Ziel wie „stelle die Sitzungsverwaltung auf Refresh-Tokens um“. Ein klares Ziel lässt den Agenten früh aufhören und macht seine Ausgabe leicht überprüfbar.

### 3. Lege fest, wohin die Ausgabe geht

Wenn das Ergebnis eines Agenten in einen anderen einfließt, plane das vorab. Schreibt er eine Plan-Datei, committet er oder schickt er seine Antwort direkt an den nächsten Agenten?

## Dateikonflikte mit Git-Worktrees verhindern

Reichen Ordnergrenzen nicht aus, ist ein eigener Arbeitsbaum pro Agent die robusteste Option. Git-Worktrees öffnen getrennte Ordner auf verschiedenen Branches desselben Repositorys:

```bash
git worktree add ../acme-web-auth -b auth-refactor
git worktree add ../acme-web-tests -b auth-tests
```

Jeder Agent arbeitet in seinem eigenen Ordner und fasst die Dateien des anderen nie an. Sind sie fertig, mergst du die Branches über einen normalen Pull Request. Ausführlich behandle ich das in [Git-Worktrees für parallele Agenten](/de/blog/git-worktree-parallel-agents/).

In AgentVera liegen Worktrees im rechten Panel: Lege einen aus einem neuen oder bestehenden Branch an, sieh die Zahl der Änderungen und wie weit er dem Hauptbranch voraus oder hinterher ist, und starte direkt darin einen Agenten.

## Beispiel-Setup: Claude Code schreibt, Codex testet

Ein einfaches, wirksames Start-Layout:

| Agent | Tool | Rolle | Arbeitet in |
| --- | --- | --- | --- |
| Architect | Claude Code | Plant und implementiert das Feature | Worktree `auth-refactor` |
| Tester | Codex | Schreibt Integrationstests für die Änderung | Derselbe Worktree, nur `tests/` |
| Dev-Server | Terminal | Führt `pnpm dev` aus | Hauptordner |

Die Schritte:

1. Füge den Projektordner zu AgentVera hinzu.
2. Wähle im Dialog „New agent“ Claude Code, nenne den Agenten „Architect“ und schreibe die Dateigrenzen in seine Rolle.
3. Mach dasselbe für Codex als „Tester“.
4. Starte den Dev-Server in einem Terminal-Agenten.
5. Gib Architect seine Aufgabe; wenn er seinen Turn beendet, übergib seine Ausgabe an Tester.

Statt den letzten Schritt von Hand zu erledigen, baust du einen Flow. [Flows](/de/features/flows/) senden die letzte Antwort eines Agenten über eine `{{output}}`-Vorlage an einen anderen und warten, bis der Zielagent seinen Turn beendet hat, falls er beschäftigt ist.

## Parallele Agenten im Blick behalten

Mit der Zahl der Agenten besteht die eigentliche Arbeit darin, ihnen zu folgen. Achte auf:

- **Status:** Welcher Agent arbeitet, welcher wartet auf dich, welcher hat einen Fehler?
- **Kontextgröße:** Lange Unterhaltungen kosten in jedem Turn mehr Tokens.
- **Freigabeanfragen:** Ein Agent, der auf eine Erlaubnis wartet, bleibt stehen, während die anderen weiterlaufen.

Der [Workspace](/de/features/workspace/) von AgentVera zeigt Agenten nebeneinander in einem Raster. Jedes Pane hat seinen Status, die aktuelle Kontextgröße und ein Nachrichtenfeld. Agenten, die auf eine Freigabe warten, stehen in der Statusleiste, und ⇧⌘A springt zu dem, der am längsten wartet.

## Kontext und Kosten

Parallel zu arbeiten vervielfacht auch den Token-Verbrauch. Die erste Anfrage jedes Agenten trägt Tool-Definitionen, den System-Prompt und Plugins. In langen Unterhaltungen wird diese Grundlast in jedem Turn neu gelesen.

So hältst du die Kosten im Rahmen:

- Starte Agenten für einfache Aufgaben mit einem engeren Tool-Set.
- Verdichte lange Unterhaltungen mit `/compact`.
- Wenn du Ausgaben zwischen Agenten weitergibst, sende nur den nötigen Teil.

Gemessene Zahlen findest du unter [Token-Verbrauch von Claude Code senken](/de/blog/claude-code-token-usage/).

## Häufige Fehler

**Zwei Agenten an einer Datei.** Am schnellsten hilft ein Worktree oder eine strikte Ordnergrenze.

**Vage Aufgaben.** Offene Aufgaben wie „repariere den Code“ lassen den Agenten endlos Dateien lesen und blähen den Kontext auf.

**Mergen ohne Prüfung.** Führe die Tests aus und prüfe die Diffs, bevor du mergst, was parallele Agenten erzeugt haben. Automatisches Code-Review spart hier Zeit.

**Alles auf einmal starten.** Fang mit zwei Agenten an und füge einen dritten hinzu, sobald die Aufteilung funktioniert.

## Ein Beispiel von Anfang bis Ende: Umstellung auf Refresh-Tokens

Arbeit aufzuteilen sieht auf dem Papier leicht aus; hier siehst du, wie es bei einer echten Aufgabe abläuft. Das Ziel: die Sitzungsverwaltung einer Web-App auf kurzlebige Access-Tokens mit rotierenden Refresh-Tokens umstellen.

### Die Aufgabe aufteilen

Zerlege die Arbeit zuerst in unabhängige Teile. Diese Aufgabe hat drei:

- **Serverseite:** Token ausstellen, validieren und rotieren (`src/auth/`).
- **Tests:** Integrationstests für den neuen Ablauf (`tests/api/`).
- **Doku:** die API-Änderungen in der README abbilden.

Serverseite und Tests betrachten dasselbe Verhalten, liegen aber in verschiedenen Ordnern. Die Doku ergibt erst Sinn, wenn die Serverseite steht. Also laufen die ersten beiden parallel und der dritte danach.

### Rollenanweisungen

Halte die Rolle jedes Agenten kurz und streng. Für Architect:

```text
Work only under src/auth/. Don't change tests.
Run pnpm test auth after every change.
When you're done, summarize your changes as a bullet list.
```

Für Tester:

```text
Work only under tests/. Don't touch application code.
Write integration tests for the behaviors in the summary you receive.
```

Die letzte Zeile der Rolle von Architect ist wichtig: Seine Zusammenfassung wird über den Flow zur Eingabe von Tester. Je ordentlicher die Zusammenfassung, desto weniger Dateien muss Tester lesen.

### Übergabe und Nachbereitung

Wenn Architect seinen Turn beendet, sendet der Flow seine letzte Antwort über eine Vorlage an Tester. Ist Tester beschäftigt, wartet der Flow, bis dessen Turn endet, und das Turn-Limit der Verbindung hindert die beiden Agenten daran, endlos zu pendeln. Währenddessen kannst du die Dev-Server-Logs im Terminal-Agenten beobachten oder einen dritten Agenten die Doku vorbereiten lassen.

### Wann du nicht parallelisieren solltest

Nicht jede Aufgabe lässt sich parallelisieren. Bleib bei einem Agenten, der Schritt für Schritt arbeitet, wenn:

- die Änderung auf eine Datei oder wenige eng gekoppelte Dateien konzentriert ist.
- die Aufgabe noch nicht klar ist; Recherche und Plan kommen zuerst.
- die Ausgabe eines Agenten Voraussetzung für den anderen ist und die zweite Aufgabe kurz ist.

In diesen Fällen funktioniert eine gestufte Pipeline besser als Parallelität. Das behandle ich in [KI-Agenten-Workflow](/de/blog/ai-agent-workflow-pipeline/).

## Checkliste

Vor einer parallelen Sitzung:

- [ ] Ist das Ziel jedes Agenten in einem Satz aufgeschrieben?
- [ ] Stehen die Dateigrenzen in der Rolle?
- [ ] Hat bei wahrscheinlichen Konflikten jeder Agent seinen eigenen Worktree?
- [ ] Sind Flow oder Plan-Datei bereit, wenn die Ausgabe eines Agenten in einen anderen einfließt?
- [ ] Gibt es einen Agenten oder ein Terminal, das die Tests ausführt?

## Zum Schluss

Parallele Coding-Agenten sparen bei Arbeit, die sich sauber aufteilen lässt, echte Zeit. Der Schlüssel ist, Agenten voneinander zu trennen und die Übergabe zwischen ihnen zu definieren. Worktrees trennen Dateien, Flows tragen Ausgaben, und gut geschriebene Rollen trennen Verantwortlichkeiten.

AgentVera ist dafür gebaut, das in einem Fenster einzurichten: Claude Code, Codex und andere CLIs laufen nebeneinander mit ihren eigenen Anmeldungen. Du kannst [im kostenlosen Plan starten](/de/) und die [Pläne](/de/pricing/) ansehen, wenn du mehr brauchst.

## Häufige Fragen

**Können Claude Code und Codex gleichzeitig am selben Projekt arbeiten?** Ja. Jeder läuft in seiner eigenen Terminal-Sitzung. Am sichersten teilst du die Arbeit nach Ordnern auf oder gibst jedem Agenten einen eigenen Git-Worktree, damit sie nie dieselben Dateien bearbeiten.

**Brauchen parallele Agenten getrennte Konten?** Nein. Jede CLI nutzt ihre eigene Anmeldung. Du kannst mehrere Agenten mit einem Konto öffnen; Nutzungslimits füllen sich pro Konto.

**Wie viele Agenten sollte ich gleichzeitig laufen lassen?** So viele, wie du im Blick behalten kannst. Zwei bis vier Agenten sind für die meisten Projekte gut zu handhaben; darüber hinaus helfen Flows und Benachrichtigungen.

**Können Agenten die Ausgabe der anderen nutzen?** Mit AgentVera-Flows wird die letzte Antwort eines Agenten über eine Vorlage an einen anderen gesendet, sodass du nicht von Hand kopieren und einfügen musst.

---

**Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/