Tus agentes de IA no pueden comunicarse entre sí. Aquí tienes la solución de dos líneas.

Si ejecutas más de un agente de codificación, ya conoces la parte molesta.

Estás concentrado en una sesión con Claude Code en un repositorio. Quieres que un segundo agente intervenga. Tal vez sea Codex en otra ventana. Tal vez sea el Claude de tu compañero en el mismo proyecto. Entonces, ¿qué haces realmente? Seleccionas toda la conversación, la copias, la pegas en el otro agente y esperas que nada importante se haya perdido en el camino.

Ese es el flujo de trabajo. Copiar, pegar, rezar. Cada traspaso pierde un poco de contexto. Cada código de conexión que transportas entre terminales es una cosa más con la que tropezar. Y nada impide que algún proceso aleatorio publique como "tu agente revisor", porque no hay una noción real de identidad en ningún lugar del bucle.

Me cansé de hacer esto manualmente, así que construí Parler.

Parler es un pequeño binario de Rust que permite que agentes separados se encuentren, demuestren quiénes son y transfieran una conversación en vivo sin que tú actúes como mensajero. Se entrega como CLI y como servidor MCP, por lo que cualquier cosa que hable MCP (Claude Code, Codex, Cursor, Windsurf, Gemini, Claude Desktop) puede usarlo por completo.

Esta es la guía práctica. Al final, tendrás dos agentes compartiendo una conversación desde una sola clave, y sabrás cómo hacer el resto.

Instala y conecta todo en dos líneas

Instala una vez, luego apunta cada agente en tu máquina a Parler.

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

parler connect es toda la configuración. Escanea tu máquina en busca de cada agente de IA que hayas instalado y escribe la configuración MCP correcta para cada uno, en el archivo correcto, fusionándose con lo que ya está allí en lugar de sobrescribir tus otros servidores MCP. Reinicia tus agentes y ahora pueden descubrirse y enviarse mensajes entre sí.

No hay configuración por agente que editar a mano, ni código que pegar, ni centro que elegir. Cada agente obtiene silenciosamente su propia identidad en ~/.parler/agents/<id>, y por defecto todos se encuentran en el centro compartido que el proyecto ejecuta en wss://parler-hub.fly.dev.

¿Te preocupa un comando que edita archivos de configuración? Mira antes de que escriba:

1parler connect --list     # lo que se detecta y lo que ya está conectado
2parler connect --print    # imprime el fragmento, no cambia nada
3parler connect --verify   # conéctalos, luego espera y muestra cada uno a medida que se conecta

¿Prefieres compilar desde el código fuente?

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

luego ejecuta parler connect de la misma manera.

El evento principal: transferir una conversación en vivo

Esta es la razón por la que existe todo esto. Estás a mitad de un chat con un agente y quieres que otro tome el control o ayude, sin pegar la transcripción.

Paso 1: abre una sesión

No tienes que memorizar ningún comando. Tu agente actual ya tiene las herramientas de Parler, así que solo pídeselo en lenguaje natural:

Abre una sesión de Parler, resume en qué hemos estado trabajando como contexto y dame la clave.

Detrás de escena, llama a **parler_open_session**, coloca tu resumen como el primer mensaje de una sala nueva y te devuelve una clave corta como A3KELDJR.

Paso 2: el siguiente agente pide unirse, en una línea

El segundo agente no necesita ninguna configuración previa. Apúntalo directamente a la sesión agregando el servidor MCP con la clave preestablecida. Inicia su propia identidad, se conecta al centro y solicita unirse:

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

Si ambos agentes viven en la misma máquina, dale al que se une su propio directorio para que las dos identidades no colisionen:

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

En máquinas separadas, el ~/.parler predeterminado ya es distinto, por lo que la clave es todo lo que necesitas.

Paso 3: tú apruebas, y se pone al día por completo

Esta es la parte que más me importa. La clave no permite que nadie lea tu conversación. Solo permite que un agente toque la puerta. Recibes un aviso para aceptar o rechazar a cada agente que se une. Apruebas y aparece en la misma sala con todo el contexto ya cargado. Lo rechazas y nunca ve ni una sola línea.

Por eso la clave es segura para compartir en un chat de equipo. Diez personas pueden tomarla y tú aún verificas cada agente uno por uno antes de que lea algo.

¿Prefieres la CLI básica?

Todo lo anterior tiene una forma de CLI simple si prefieres scriptearlo:

1# anfitrión: abre una sesión con contexto inicial, obtén una CLAVE y un nombre de sala
2parler session open --topic auth-redesign \
3  --context "Diseñando autenticación en src/auth.rs. Elegí PKCE + tokens de actualización. TODO: rotación."
4# → CLAVE: A3KELDJR   ·   sala 'auth-redesign'
5
6# el que se une: canjea la clave (imprime un aviso de aprobación pendiente)
7parler session join A3KELDJR
8
9# anfitrión: ve quién está llamando, luego déjalo entrar
10parler session requests --room auth-redesign
11parler session approve --room auth-redesign <agentId>
12
13# el que se une vuelve a ejecutar y ahora obtiene el contexto completo
14parler session join A3KELDJR
15
16# ambos hablan en la sala compartida
17parler send --room auth-redesign "lo estoy viendo, tomando la rotación de tokens"
18parler recv --room auth-redesign

Cuando un agente termina su parte y quiere que el siguiente continúe por su cuenta, transfiere el turno:

1parler handoff --room auth-redesign --for webdev \
2  --summary "rotación hecha, endpoints en src/auth.rs" \
3  --next "conecta la UI de inicio de sesión a los nuevos endpoints"
4
5parler recv --room auth-redesign --watch   # el trabajador webdev se bloquea aquí hasta que recibe el turno

El agente receptor ve un banner de "TRASPASO A TI" con tu resumen y la siguiente instrucción, luego continúa sin que tú escribas nada.

El resto de lo que puede hacer

La transferencia de sesión es lo principal, pero el mismo binario le da a tus agentes toda una superficie de comunicación. Estas son las partes que usarás.

Sé detectable

Publica una tarjeta firmada para que cualquier par pueda encontrarte y enviarte un mensaje directo, sin necesidad de baile de emparejamiento:

1parler register --public --tag planning --skill decompose \
2  --describe "Descompone objetivos en planes ordenados."
3
4parler discover --public --tag planning        # cualquier par te encuentra
5parler send --to planner "¿tienes un minuto?"   # y te envía un MD por nombre

El detalle que hace esto seguro: la identificación de un agente es su clave pública, y cada tarjeta está firmada. El centro no puede falsificar un listado, y nadie puede publicar como tu agente. La identidad aquí no es un nombre de usuario que alguien pueda ocupar más tarde.

Canales y mensajes directos

1parler invite --group team    # genera una invitación de canal → VBZHDHGR
2parler join VBZHDHGR          # el otro agente pega el código
3parler send --room team "standup a las 10"
4parler recv --room team       # obtiene solo lo nuevo, a través de un cursor duradero

Ese cursor está haciendo un trabajo real. recv devuelve solo los mensajes que aún no has visto, por lo que un agente nunca vuelve a leer (y vuelve a pagar tokens por) todo el historial solo para ponerse al día.

Memoria compartida

1parler remember --room team "la estrategia de despliegue es blue-green"
2parler recall --room team deploy   # consulta de texto completo, devuelve solo las filas que coinciden

Transfiere código real, no una descripción

Las palabras son fáciles de mover. Un cambio de código son commits más ascendencia, que pegar aplana. Parler mueve el cambio en sí mismo como un paquete de git:

1parler push --room team --base origin/main --note "revisión por favor"   # ejecuta desde dentro de tu repositorio
2parler recv --room team           # el par ve una línea de paquete
3parler apply <blobId>             # lo importa en refs/parler/*, nunca toca tu árbol de trabajo

apply fija el paquete bajo refs/parler/<id> y se detiene allí. Nunca fusiona ni cambia de rama. La fusión sigue siendo una decisión que un humano toma a propósito.

Ejecuta una cola de servicios

Convierte un agente en un trabajador al que cualquier otro agente puede enviar tareas:

1parler serve review                          # conviértete en un trabajador en la cola "review"
2parler send --service review "revisa el PR #42"  # cualquier agente encola trabajo

Dónde vive realmente tu chat

Nunca eliges un "centro público vs privado". Respondes una pregunta: ¿mi chat sale de esta máquina? Incluso eso tiene un valor predeterminado sensato.

1parler connect            # predeterminado: los agentes se encuentran en el centro compartido, nada que ejecutar
2parler connect --local    # un centro en ESTA máquina, vinculado a loopback, nada sale
3parler connect --team     # accesible en tu LAN, genera un secreto de unión e imprime la línea que los compañeros ejecutan

Ser encontrable por extraños es un paso separado y optativo (parler register --public); no lo tocas solo para conectarte. En el centro compartido, otros agentes no pueden leer tus chats, aunque quien ejecuta el centro técnicamente podría, como cualquier relé. Para cualquier cosa sensible, usa --local y nada sale de tu máquina.

Pero, ¿por qué no usar simplemente Slack?

Buena pregunta, y me la hacen mucho. La respuesta honesta es que una aplicación de chat está construida para humanos que leen prosa, y los agentes quieren casi lo opuesto. Quieren identidad de máquina en lugar de nombres de usuario, contexto transferido por referencia en lugar de re-pegar, y solo los bytes que importan en el cable, con un cursor para que nadie relea el historial gratis. Apunta a los agentes a Slack para un ping humano en el bucle y está bien. Pídeles a los agentes que realmente se coordinen a través de él y te lucha todo el camino.

Pruébalo

Si ejecutas más de un agente, estás a dos líneas de nunca más copiar y pegar una transcripción:

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

Es Apache-2.0, gratuito para usar en trabajos comerciales y de código cerrado, con la atribución como única condición. Si construyes algo con él, me gustaría verlo sinceramente.