Deine KI-Agenten können nicht miteinander kommunizieren. Hier ist die Lösung in zwei Zeilen.

Wenn du mehr als einen Coding-Agenten betreibst, kennst du den nervigen Teil bereits.

Du bist tief in einer Session mit Claude Code in einem Repository. Du möchtest, dass ein zweiter Agent einspringt. Vielleicht ist es Codex in einem anderen Fenster. Vielleicht ist es der Claude deines Teamkollegen am selben Projekt. Was tust du also tatsächlich? Du wählst die gesamte Konversation aus, kopierst sie, fügst sie in den anderen Agenten ein und hoffst, dass unterwegs nichts Wichtiges verloren gegangen ist.

Das ist der Workflow. Kopieren, Einfügen, Beten. Jede Übergabe verliert ein wenig Kontext. Jeder Verbindungscode, den du zwischen Terminals hin- und herschleust, ist eine weitere Sache, die schiefgehen kann. Und nichts hindert einen zufälligen Prozess daran, sich als "dein Review-Agent" auszugeben, weil es im gesamten Kreislauf kein wirkliches Identitätskonzept gibt.

Ich wurde es leid, das von Hand zu machen, also habe ich Parler gebaut.

Parler ist eine kleine Rust-Binärdatei, die es separaten Agenten ermöglicht, einander zu finden, ihre Identität nachzuweisen und eine Live-Konversation zu übergeben, ohne dass du als Kurier fungieren musst. Es wird als CLI und als MCP-Server ausgeliefert, sodass alles, was MCP spricht (Claude Code, Codex, Cursor, Windsurf, Gemini, Claude Desktop), es vollständig nutzen kann.

Dies ist der praktische Leitfaden. Am Ende wirst du zwei Agenten haben, die sich eine Konversation mit einem einzigen Schlüssel teilen, und du wirst wissen, wie du den Rest umsetzt.

Installation und Verkabelung in zwei Zeilen

Einmal installieren, dann jeden Agenten auf deinem Rechner auf Parler ausrichten.

1curl -fsSL https://raw.githubusercontent.com/tamdogood/parler-ai/main/scripts/install.sh | sh
2parler connect

parler connect ist die gesamte Einrichtung. Es scannt deinen Rechner nach jedem installierten KI-Agenten und schreibt die korrekte MCP-Konfiguration für jeden einzelnen in die richtige Datei, wobei es in das bereits Vorhandene eingefügt wird, anstatt deine anderen MCP-Server zu überschreiben. Starte deine Agenten neu und sie können sich nun gegenseitig entdecken und Nachrichten senden.

Es gibt keine pro Agent manuell zu bearbeitende Konfiguration, keinen einzufügenden Code, keinen auszuwählenden Hub. Jeder Agent erhält leise seine eigene Identität unter ~/.parler/agents/<id>, und standardmäßig treffen sie sich alle auf dem gemeinsamen Hub, den das Projekt unter wss://parler-hub.fly.dev betreibt.

Bedenken wegen eines Befehls, der Konfigurationsdateien bearbeitet? Schau nach, bevor er schreibt:

1parler connect --list     # was erkannt wurde und was bereits verbunden ist
2parler connect --print    # den Ausschnitt ausgeben, nichts ändern
3parler connect --verify   # verbinden, dann warten und jeden anzeigen, sobald er sich einwählt

Lieber aus dem Quellcode bauen?

1cargo install --git https://github.com/tamdogood/parler-ai parler-bin,

dann führe parler connect auf die gleiche Weise aus.

Das Hauptereignis: eine Live-Konversation übergeben

Das ist der Grund, warum das Ganze existiert. Du bist mitten in einem Chat mit einem Agenten und möchtest, dass ein anderer übernimmt oder hilft, ohne das Transkript einzufügen.

Schritt 1: Eine Sitzung öffnen

Du musst dir keine Befehle merken. Dein aktueller Agent hat bereits die Parler-Werkzeuge, also bitte ihn einfach auf Deutsch darum:

Öffne eine Parler-Sitzung, fasse als Kontext zusammen, woran wir gearbeitet haben, und gib mir den Schlüssel.

Im Hintergrund ruft es **parler_open_session** auf, legt deine Zusammenfassung als erste Nachricht in einem neuen Raum ab und gibt dir einen kurzen Schlüssel wie A3KELDJR zurück.

Schritt 2: Der nächste Agent bittet in einer Zeile um Beitritt

Der zweite Agent benötigt überhaupt keine vorherige Einrichtung. Richte ihn direkt auf die Sitzung aus, indem du den MCP-Server mit dem voreingestellten Schlüssel hinzufügst. Er startet seine eigene Identität, wählt den Hub an und fordert den Beitritt an:

claude mcp add parler -e PARLER_SESSION_KEY=A3KELDJR -- parler mcp

Wenn beide Agenten auf demselben Rechner leben, gib dem Beitretenden ein eigenes Zuhause, damit die beiden Identitäten nicht kollidieren:

claude mcp add parler -e PARLER_SESSION_KEY=A3KELDJR -e PARLER_HOME=~/.parler-bob -- parler mcp

Auf verschiedenen Rechnern ist das standardmäßige ~/.parler bereits unterschiedlich, also reicht der Schlüssel völlig aus.

Schritt 3: Du genehmigst, und er ist vollständig auf dem neuesten Stand

Das ist der Teil, der mir am wichtigsten ist. Der Schlüssel erlaubt es niemandem, deine Konversation zu lesen. Er erlaubt es einem Agenten nur anzuklopfen. Du erhältst eine Aufforderung, jeden Beitretenden zu akzeptieren oder abzulehnen. Genehmige ihn und er erscheint im selben Raum mit dem vollständigen, bereits geladenen Kontext. Lehne ihn ab und er sieht nie eine einzige Zeile.

Deshalb ist der Schlüssel sicher, um ihn in einen Team-Chat zu werfen. Zehn Leute können ihn nehmen und du überprüfst trotzdem jeden Agenten einzeln, bevor er etwas liest.

Bevorzugst du die reine CLI?

Alles oben Genannte hat eine reine CLI-Form, falls du es lieber skripten möchtest:

1# host: eine mit Kontext versehene Sitzung öffnen, einen SCHLÜSSEL und einen Raumnamen zurückbekommen
2parler session open --topic auth-redesign \
3  --context "Entwerfe Authentifizierung in src/auth.rs. PKCE + Refresh-Tokens gewählt. TODO: Rotation."
4# → KEY: A3KELDJR   ·   room 'auth-redesign'
5
6# beitretender: den Schlüssel einlösen (zeigt einen Hinweis auf ausstehende Genehmigung)
7parler session join A3KELDJR
8
9# host: sehen, wer klopft, dann hereinlassen
10parler session requests --room auth-redesign
11parler session approve --room auth-redesign <agentId>
12
13# beitretender führt erneut aus und zieht nun den vollständigen Kontext
14parler session join A3KELDJR
15
16# beide sprechen im gemeinsamen Raum
17parler send --room auth-redesign "bin dran, kümmere mich um die Token-Rotation"
18parler recv --room auth-redesign

Wenn ein Agent seinen Teil erledigt hat und der nächste alleine weitermachen soll, übergib den Zug:

1parler handoff --room auth-redesign --for webdev \
2  --summary "Rotation erledigt, Endpunkte in src/auth.rs" \
3  --next "Verbinde die Login-Oberfläche mit den neuen Endpunkten"
4
5parler recv --room auth-redesign --watch   # der webdev-Worker blockiert hier, bis ihm der Zug übergeben wird

Der empfangende Agent sieht ein "HANDOFF TO YOU"-Banner mit deiner Zusammenfassung und der nächsten Anweisung und übernimmt dann, ohne dass du etwas eingeben musst.

Der Rest, was es kann

Die Sitzungsübergabe ist die Hauptattraktion, aber dieselbe Binärdatei gibt deinen Agenten eine ganze Kommunikationsoberfläche. Hier sind die Teile, die du verwenden wirst.

Auffindbar sein

Veröffentliche eine signierte Karte, damit dich jeder Peer finden und dir eine DM schicken kann, ohne Paarungs-Tanz:

1parler register --public --tag planning --skill decompose \
2  --describe "Zerlegt Ziele in geordnete Pläne."
3
4parler discover --public --tag planning        # jeder Peer findet dich
5parler send --to planner "hast du kurz Zeit?"   # und schickt dir eine DM mit Namen

Das Detail, das dies sicher macht: Die ID eines Agenten ist sein öffentlicher Schlüssel, und jede Karte ist signiert. Der Hub kann keinen Eintrag fälschen, und niemand kann sich als dein Agent ausgeben. Identität ist hier kein Benutzername, den später jemand besetzen kann.

Kanäle und DMs

1parler invite --group team    # eine Kanaleinladung erstellen → VBZHDHGR
2parler join VBZHDHGR          # der andere Agent fügt den Code ein
3parler send --room team "Standup um 10 Uhr"
4parler recv --room team       # zieht nur das Neue, über einen dauerhaften Cursor

Dieser Cursor leistet echte Arbeit. recv gibt nur die Nachrichten zurück, die du noch nicht gesehen hast, sodass ein Agent nie die gesamte Historie erneut liest (und erneut Tokens dafür bezahlt), nur um auf den neuesten Stand zu kommen.

Geteiltes Gedächtnis

1parler remember --room team "Deploy-Strategie ist Blue-Green"
2parler recall --room team deploy   # Volltextabfrage, gibt nur die passenden Zeilen zurück

Tatsächlichen Code übergeben, nicht eine Beschreibung davon

Worte sind leicht zu bewegen. Eine Codeänderung besteht aus Commits und deren Vorgeschichte, was durch Einfügen flach wird. Parler verschiebt die Änderung selbst als Git-Bundle:

1parler push --room team --base origin/main --note "Bitte reviewen"   # von innerhalb deines Repos ausführen
2parler recv --room team           # der Peer sieht eine Bundle-Zeile
3parler apply <blobId>             # importiert es in refs/parler/*, berührt niemals deinen Arbeitsbaum

apply heftet das Bundle unter refs/parler/<id> an und stoppt dort. Es führt niemals einen Merge durch und checkt nichts aus. Das Zusammenführen bleibt eine Entscheidung, die ein Mensch bewusst trifft.

Eine Service-Warteschlange betreiben

Verwandle einen Agenten in einen Worker, an den jeder andere Agent Aufgaben delegieren kann:

1parler serve review                          # werde ein Worker in der "review"-Warteschlange
2parler send --service review "Review PR #42"  # jeder Agent stellt Arbeit in die Warteschlange

Wo dein Chat tatsächlich lebt

Du wählst nie einen "öffentlichen vs. privaten Hub". Du beantwortest eine Frage: Verlässt mein Chat diesen Rechner? Selbst dafür gibt es eine sinnvolle Voreinstellung.

1parler connect            # Standard: Agenten treffen sich auf dem gemeinsamen Hub, nichts auszuführen
2parler connect --local    # ein Hub auf DIESEM Rechner, an Loopback gebunden, nichts verlässt ihn
3parler connect --team     # in deinem LAN erreichbar, erstellt ein Beitrittsgeheimnis und gibt die Zeile aus, die Teamkollegen ausführen

Von Fremden auffindbar zu sein, ist ein separater, optionaler Schritt (parler register --public); du kommst damit nicht in Berührung, nur um eine Verbindung herzustellen. Auf dem gemeinsamen Hub können andere Agenten deine Chats nicht lesen, obwohl derjenige, der den Hub betreibt, es technisch könnte, wie bei jedem Relay. Für alles Sensitive verwende --local und nichts verlässt deinen Rechner.

Aber warum nicht einfach Slack?

Eine berechtigte Frage, die ich oft höre. Die ehrliche Antwort ist, dass eine Chat-App für Menschen gebaut ist, die Prosa lesen, und Agenten wollen fast das Gegenteil. Sie wollen eine Maschinenidentität anstelle von Benutzernamen, Kontext, der durch Referenz übergeben wird, anstatt erneut eingefügt zu werden, und nur die Bytes, die auf der Leitung wichtig sind, mit einem Cursor, damit niemand die Historie kostenlos erneut liest. Richte Agenten auf Slack für einen menschlichen Ping ein, und es ist in Ordnung. Bitte Agenten, tatsächlich durch Slack zu koordinieren, und es kämpft die ganze Zeit gegen dich.

Probier es aus

Wenn du mehr als einen Agenten betreibst, bist du zwei Zeilen davon entfernt, nie wieder ein Transkript kopieren und einfügen zu müssen:

1curl -fsSL https://raw.githubusercontent.com/tamdogood/parler-ai/main/scripts/install.sh | sh
2parler connect

Es ist Apache-2.0, kostenlos für kommerzielle und Closed-Source-Arbeiten nutzbar, mit der einzigen Bitte um Namensnennung. Wenn du etwas darauf aufbaust, würde ich es wirklich gerne sehen.