{"id":9561,"date":"2026-09-08T11:23:27","date_gmt":"2026-09-08T09:23:27","guid":{"rendered":"https:\/\/www.hostingtg.com\/blog\/?p=9561"},"modified":"2026-09-08T11:23:29","modified_gmt":"2026-09-08T09:23:29","slug":"instalar-claude-en-un-servidor-con-hermes","status":"publish","type":"post","link":"https:\/\/www.hostingtg.com\/blog\/instalar-claude-en-un-servidor-con-hermes\/","title":{"rendered":"C\u00f3mo instalar Claude en un servidor con Hermes y hacer que trabajen juntos"},"content":{"rendered":"\n

Llevo tiempo utilizando Hermes Agent<\/strong> y, de todas las mejoras que he ido introduciendo en mi forma de trabajar, una de las decisiones que m\u00e1s diferencia ha marcado ha sido tener tambi\u00e9n Claude en el mismo entorno de servidor<\/strong>.<\/p>\n\n\n\n

No me refiero simplemente a tener dos herramientas de inteligencia artificial instaladas en la misma m\u00e1quina. Eso, por s\u00ed solo, aporta bastante poco.<\/p>\n\n\n\n

\"hermes<\/a><\/figure>\n\n\n\n

Lo interesante empieza cuando Claude y Hermes pueden trabajar sobre el mismo proyecto, conocer lo que est\u00e1 haciendo el otro, repartirse tareas y ayudarse sin modificar simult\u00e1neamente las mismas partes del c\u00f3digo<\/strong>.<\/p>\n\n\n\n

En mi caso trabajo de forma remota con la m\u00e1quina, lo que me permite utilizar Claude mientras Hermes contin\u00faa trabajando en otra parte del proyecto. Despu\u00e9s de probar distintas formas de organizarlos, la soluci\u00f3n que mejor resultado me ha dado ha sido adem\u00e1s sorprendentemente sencilla: ficheros Markdown compartidos<\/strong>.<\/p>\n\n\n\n

Por ejemplo:<\/p>\n\n\n\n

proyecto\/\n\u251c\u2500\u2500 proyecto-hermes.md\n\u251c\u2500\u2500 proyecto-claude.md\n\u251c\u2500\u2500 src\/\n\u251c\u2500\u2500 tests\/\n\u2514\u2500\u2500 ...<\/code><\/pre>\n\n\n\n
Hermes registra en proyecto-hermes.md<\/code> qu\u00e9 est\u00e1 haciendo, qu\u00e9 ha cambiado y qu\u00e9 tiene pendiente. Claude hace exactamente lo mismo en proyecto-claude.md<\/code>.<\/p>\n\n\n\n
Pero hay una segunda parte que es todav\u00eda m\u00e1s importante: cada uno puede leer el fichero del otro<\/strong>.<\/p>\n\n\n\n
Esto crea una especie de canal de comunicaci\u00f3n persistente dentro del propio proyecto.<\/p>\n\n\n\n
Si Hermes est\u00e1 modificando una parte del backend, Claude puede saberlo antes de empezar. Si Claude detecta un problema de arquitectura, puede dejar una recomendaci\u00f3n para Hermes. Si uno necesita una segunda opini\u00f3n o una subtarea, puede ped\u00edrsela al otro.<\/p>\n\n\n\n
El resultado es un sistema bastante m\u00e1s potente que utilizar un \u00fanico agente de IA de forma aislada.<\/p>\n\n\n\n
En esta gu\u00eda voy a explicar c\u00f3mo planteo esta configuraci\u00f3n, c\u00f3mo instalar y preparar Claude junto a Hermes Agent en un servidor<\/strong>, y sobre todo c\u00f3mo consigo que ambos trabajen de forma coordinada.<\/p>\n\n\n\n
Qu\u00e9 vamos a conseguir con Claude y Hermes en el mismo servidor<\/h2>\n\n\n\n
El objetivo no es que Claude y Hermes hagan exactamente lo mismo al mismo tiempo.<\/p>\n\n\n\n
De hecho, esa probablemente sea una de las peores formas de utilizar dos agentes.<\/p>\n\n\n\n
Si damos a los dos la orden de modificar la misma funcionalidad, con acceso a los mismos ficheros y sin ning\u00fan mecanismo de coordinaci\u00f3n, tendremos bastantes posibilidades de acabar con cambios contradictorios, contexto duplicado o directamente con un agente deshaciendo parte del trabajo del otro.<\/p>\n\n\n\n
La configuraci\u00f3n que utilizo busca precisamente lo contrario.<\/p>\n\n\n\n
Quiero tener dos agentes con acceso al mismo entorno, pero con responsabilidades diferenciadas y suficiente conocimiento del estado del proyecto como para colaborar<\/strong>.<\/p>\n\n\n\n
Conceptualmente, la arquitectura es bastante sencilla:<\/p>\n\n\n\n
                  YO\n                   \u2502\n                   \u25bc\n          SERVIDOR \/ VPS REMOTO\n                   \u2502\n          \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n          \u2502                 \u2502\n          \u25bc                 \u25bc\n      HERMES              CLAUDE\n          \u2502                 \u2502\n          \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n                   \u25bc\n             MISMO PROYECTO\n                   \u2502\n          \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n          \u25bc                 \u25bc\n proyecto-hermes.md   proyecto-claude.md<\/code><\/pre>\n\n\n\n
Mientras Hermes trabaja en una tarea, Claude puede estar revisando otra \u00e1rea, analizando una posible soluci\u00f3n o preparando una segunda parte del proyecto.<\/p>\n\n\n\n
Los dos comparten el repositorio, pero no trabajan a ciegas.<\/p>\n\n\n\n
Este enfoque tiene adem\u00e1s bastante sentido dentro de la propia filosof\u00eda multiagente que se est\u00e1 desarrollando alrededor de Hermes. Uno de los referentes que analic\u00e9 describe perfiles de Hermes ejecut\u00e1ndose en paralelo y comunic\u00e1ndose mediante archivos, adem\u00e1s de un modo MCP que puede exponer informaci\u00f3n de Hermes a clientes compatibles como Claude Desktop.<\/p>\n\n\n\n
Mi enfoque es deliberadamente m\u00e1s sencillo.<\/p>\n\n\n\n
En lugar de empezar creando una arquitectura compleja de orquestaci\u00f3n, utilizo algo que cualquier agente capaz de trabajar con ficheros entiende perfectamente:<\/p>\n\n\n\n
Markdown.<\/strong><\/p>\n\n\n\n
Esto permite empezar con una infraestructura m\u00ednima y evolucionarla despu\u00e9s si realmente hace falta.<\/p>\n\n\n\n
Qu\u00e9 necesitas antes de instalar Claude junto a Hermes<\/h2>\n\n\n\n
Antes de empezar conviene tener clara una cosa: instalar Claude y Hermes no es todav\u00eda integrarlos<\/strong>.<\/p>\n\n\n\n
La instalaci\u00f3n nos proporciona las herramientas. La coordinaci\u00f3n la construiremos posteriormente.<\/p>\n\n\n\n
Servidor o VPS<\/h3>\n\n\n\n
Yo prefiero este tipo de configuraci\u00f3n en una m\u00e1quina remota porque me permite centralizar el proyecto y mantener Hermes disponible independientemente del ordenador desde el que est\u00e9 trabajando.<\/p>\n\n\n\n
Hermes puede ejecutarse en local, en Docker, en un VPS o en otros entornos persistentes. Para tareas que deben continuar disponibles, un VPS tiene bastante m\u00e1s sentido que depender de un port\u00e1til que puede suspenderse o apagarse.<\/p>\n\n\n\n
No necesitas necesariamente una m\u00e1quina gigantesca para empezar.<\/p>\n\n\n\n
Lo importante para este flujo es que tengas:<\/p>\n\n\n\n
    \n
  • acceso estable al servidor;<\/li>\n\n\n\n
  • espacio para el proyecto;<\/li>\n\n\n\n
  • permisos para instalar y ejecutar las herramientas necesarias;<\/li>\n\n\n\n
  • conexi\u00f3n a Internet;<\/li>\n\n\n\n
  • acceso mediante SSH o tu sistema remoto habitual;<\/li>\n\n\n\n
  • una estrategia razonable de copias de seguridad.<\/li>\n<\/ul>\n\n\n\n
    La seguridad tambi\u00e9n importa.<\/p>\n\n\n\n
    Si Hermes puede ejecutar herramientas y Claude puede trabajar sobre el mismo proyecto, estamos dando bastante capacidad a ambos agentes. No expondr\u00eda interfaces de administraci\u00f3n, dashboards o puertos innecesarios directamente a Internet. El propio material de referencia de Hermes recomienda proteger estos componentes mediante autenticaci\u00f3n, HTTPS o redes privadas cuando se utilizan en un servidor.<\/p>\n\n\n\n
    Hermes Agent funcionando<\/h3>\n\n\n\n
    Si ya tienes Hermes operativo, puedes saltarte esta parte.<\/p>\n\n\n\n
    En caso contrario, uno de los m\u00e9todos actuales recogidos por la documentaci\u00f3n analizada para Linux y macOS utiliza:<\/p>\n\n\n\n
    curl -fsSL https:\/\/hermes-agent.nousresearch.com\/install.sh | bash<\/code><\/pre>\n\n\n\n
    Despu\u00e9s puedes comprobar la instalaci\u00f3n mediante:<\/p>\n\n\n\n
    hermes --version<\/code><\/pre>\n\n\n\n
    Y revisar el estado general con:<\/p>\n\n\n\n
    hermes doctor<\/code><\/pre>\n\n\n\n
    La gu\u00eda de referencia tambi\u00e9n propone hacer una prueba sencilla mediante hermes chat<\/code> despu\u00e9s de configurar el proveedor de modelo.<\/p>\n\n\n\n
    No avanzar\u00eda con Claude hasta tener esta parte funcionando correctamente.<\/p>\n\n\n\n
    Cuando estoy montando sistemas de este tipo prefiero comprobar cada capa por separado. Primero Hermes. Despu\u00e9s Claude. Despu\u00e9s el proyecto compartido. Finalmente la comunicaci\u00f3n entre ambos.<\/p>\n\n\n\n
    Si intentas solucionar las cuatro cosas simult\u00e1neamente, cuando algo falle ser\u00e1 mucho m\u00e1s dif\u00edcil saber d\u00f3nde est\u00e1 el problema.<\/p>\n\n\n\n
    Acceso remoto al servidor<\/h3>\n\n\n\n
    En mi caso, precisamente una de las ventajas de esta configuraci\u00f3n es poder conectarme a la m\u00e1quina de forma remota y trabajar con Claude mientras Hermes contin\u00faa ejecutando su parte<\/strong>.<\/p>\n\n\n\n
    Puedes utilizar SSH, terminal remota, tu IDE habitual o el sistema que ya tengas establecido.<\/p>\n\n\n\n
    Lo importante no es tanto la herramienta de acceso como que ambos agentes terminen viendo el mismo proyecto.<\/p>\n\n\n\n
    C\u00f3mo instalar Claude en el servidor donde tienes Hermes<\/h2>\n\n\n\n
    Aqu\u00ed conviene separar dos conceptos que a menudo se mezclan: Claude Code y Claude Desktop no son exactamente lo mismo<\/strong>.<\/p>\n\n\n\n
    Claude Code es la herramienta orientada al trabajo desde terminal. Claude Desktop es una aplicaci\u00f3n de escritorio y puede formar parte de arquitecturas donde interact\u00faa con informaci\u00f3n externa, por ejemplo mediante MCP.<\/p>\n\n\n\n
    Para trabajar directamente dentro de un servidor y ejecutar tareas sobre su sistema de archivos, Claude Code es normalmente la pieza que interesa en el lado de terminal<\/strong>.<\/p>\n\n\n\n
    Claude Desktop puede seguir formando parte de tu flujo remoto, como ocurre en el m\u00edo, pero no deber\u00edamos utilizar \u201cClaude Desktop\u201d y \u201cClaude Code\u201d como si fueran dos nombres para el mismo producto.<\/p>\n\n\n\n
    Instalar Claude Code<\/h3>\n\n\n\n
    El procedimiento concreto puede variar seg\u00fan el sistema operativo.<\/p>\n\n\n\n
    Uno de los referentes analizados documenta para macOS el instalador:<\/p>\n\n\n\n
    curl -fsSL https:\/\/claude.ai\/install.sh | bash<\/code><\/pre>\n\n\n\n
    y posteriormente inicia la herramienta con:<\/p>\n\n\n\n
    claude<\/code><\/pre>\n\n\n\n
    En Windows documenta un instalador mediante PowerShell.<\/p>\n\n\n\n
    Como nuestro escenario principal es un servidor<\/strong>, probablemente Linux, comprobar\u00eda siempre el m\u00e9todo de instalaci\u00f3n vigente para la distribuci\u00f3n concreta antes de ejecutar un instalador descargado mediante curl<\/code>. Las herramientas de IA cambian bastante r\u00e1pido y no merece la pena convertir un comando que hoy funciona en una instrucci\u00f3n eterna dentro de un tutorial.<\/p>\n\n\n\n
    El punto que s\u00ed deber\u00edamos comprobar al terminar es que el comando est\u00e9 disponible:<\/p>\n\n\n\n
    claude --version<\/code><\/pre>\n\n\n\n
    Despu\u00e9s:<\/p>\n\n\n\n
    claude<\/code><\/pre>\n\n\n\n
    Completa la autenticaci\u00f3n y verifica que Claude puede iniciarse correctamente antes de darle acceso a nuestro proyecto.<\/p>\n\n\n\n
    Comprobar que Claude funciona correctamente<\/h3>\n\n\n\n
    No empezar\u00eda prob\u00e1ndolo directamente sobre un proyecto importante.<\/p>\n\n\n\n
    Crear\u00eda primero un directorio temporal:<\/p>\n\n\n\n
    mkdir prueba-claude\ncd prueba-claude<\/code><\/pre>\n\n\n\n
    Y comprobar\u00eda que puede:<\/p>\n\n\n\n
      \n
    1. leer un fichero;<\/li>\n\n\n\n
    2. crear otro;<\/li>\n\n\n\n
    3. modificar contenido;<\/li>\n\n\n\n
    4. interpretar correctamente la estructura del directorio.<\/li>\n<\/ol>\n\n\n\n
      Cuando esa prueba funcione, ya podemos movernos al repositorio real.<\/p>\n\n\n\n
      Acceder al mismo proyecto que utiliza Hermes<\/h3>\n\n\n\n
      Supongamos que tenemos:<\/p>\n\n\n\n
      \/home\/usuario\/proyectos\/mi-proyecto\/<\/code><\/pre>\n\n\n\n
      Hermes y Claude necesitan poder trabajar dentro de ese directorio.<\/p>\n\n\n\n
      Eso no significa que debamos lanzar a los dos inmediatamente con una instrucci\u00f3n como:<\/p>\n\n\n\n
      \n
      Mejora todo el proyecto.<\/p>\n<\/blockquote>\n\n\n\n
      Primero vamos a crear una forma de coordinaci\u00f3n.<\/p>\n\n\n\n
      Porque tener dos agentes inteligentes trabajando simult\u00e1neamente sin reglas no es realmente un sistema multiagente.<\/p>\n\n\n\n
      Es simplemente tener dos procesos con capacidad para estorbarse.<\/p>\n\n\n\n
      C\u00f3mo configurar Claude y Hermes para trabajar sobre el mismo proyecto<\/h2>\n\n\n\n
      La idea que mejor me funciona consiste en separar acceso compartido<\/strong> de responsabilidad compartida<\/strong>.<\/p>\n\n\n\n
      Ambos pueden ver el mismo proyecto.<\/p>\n\n\n\n
      Pero eso no significa que ambos deban modificar las mismas cosas.<\/p>\n\n\n\n
      Separar responsabilidades entre los dos agentes<\/h3>\n\n\n\n
      Supongamos que estoy trabajando en una aplicaci\u00f3n.<\/p>\n\n\n\n
      Podr\u00eda decir a Hermes:<\/p>\n\n\n\n
      Tu responsabilidad actual es backend y tests.\n\nNo modifiques frontend salvo que sea imprescindible.\nConsulta proyecto-claude.md antes de comenzar una tarea nueva.\nRegistra en proyecto-hermes.md lo que est\u00e1s haciendo.<\/code><\/pre>\n\n\n\n
      Y a Claude:<\/p>\n\n\n\n
      Tu responsabilidad actual es arquitectura, frontend y revisi\u00f3n.\n\nConsulta proyecto-hermes.md antes de modificar c\u00f3digo relacionado\ncon backend.\n\nRegistra tus cambios y decisiones en proyecto-claude.md.<\/code><\/pre>\n\n\n\n
      Esto es solo un ejemplo.<\/p>\n\n\n\n
      En otro proyecto podr\u00eda ser exactamente al rev\u00e9s.<\/p>\n\n\n\n
      Lo importante es que exista una divisi\u00f3n expl\u00edcita del trabajo<\/strong>.<\/p>\n\n\n\n
      Dar acceso a ambos al mismo directorio<\/h3>\n\n\n\n
      Una estructura b\u00e1sica podr\u00eda ser:<\/p>\n\n\n\n
      mi-proyecto\/\n\u251c\u2500\u2500 proyecto-hermes.md\n\u251c\u2500\u2500 proyecto-claude.md\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 src\/\n\u251c\u2500\u2500 tests\/\n\u2514\u2500\u2500 docs\/<\/code><\/pre>\n\n\n\n
      Los dos agentes pueden leer el repositorio completo.<\/p>\n\n\n\n
      Pero antes de empezar una tarea relevante tienen una instrucci\u00f3n adicional:<\/p>\n\n\n\n
      leer el estado del otro agente.<\/strong><\/p>\n\n\n\n
      Ese peque\u00f1o detalle cambia bastante el comportamiento del sistema.<\/p>\n\n\n\n
      Hermes deja de trabajar \u00fanicamente con mi \u00faltimo prompt y empieza a disponer tambi\u00e9n de informaci\u00f3n acerca de Claude.<\/p>\n\n\n\n
      Claude hace exactamente lo mismo.<\/p>\n\n\n\n
      Qu\u00e9 tareas dejar\u00eda a Claude y cu\u00e1les a Hermes<\/h3>\n\n\n\n
      No tengo una regla universal.<\/p>\n\n\n\n
      Dependiendo del proyecto, Hermes puede ser especialmente \u00fatil ejecutando tareas, trabajando de forma aut\u00f3noma, utilizando herramientas o avanzando en procesos bien definidos.<\/p>\n\n\n\n
      Claude puede encargarse de otra parte del desarrollo, revisar arquitectura, estudiar una implementaci\u00f3n o aportar una segunda opini\u00f3n.<\/p>\n\n\n\n
      Pero hay algo que intento mantener: no mandar a ambos a resolver exactamente el mismo problema de forma independiente salvo que quiera deliberadamente comparar sus soluciones<\/strong>.<\/p>\n\n\n\n
      Si quiero dos opiniones, perfecto.<\/p>\n\n\n\n
      Si quiero productividad paralela, prefiero dividir.<\/p>\n\n\n\n
      Por ejemplo:<\/p>\n\n\n\n
      HERMES\n\u2502\n\u251c\u2500 Implementar endpoints\n\u251c\u2500 Ejecutar tests\n\u2514\u2500 Corregir errores detectados\n\nCLAUDE\n\u2502\n\u251c\u2500 Revisar arquitectura\n\u251c\u2500 Preparar frontend\n\u2514\u2500 Analizar posibles fallos<\/code><\/pre>\n\n\n\n
      Y cuando alguno necesita al otro, utilizamos nuestro canal compartido.<\/p>\n\n\n\n
      El m\u00e9todo que utilizo para que Claude y Hermes se comuniquen<\/h2>\n\n\n\n
      Aqu\u00ed est\u00e1 para m\u00ed la parte realmente interesante.<\/p>\n\n\n\n
      Despu\u00e9s de probar maneras m\u00e1s complicadas de plantear la coordinaci\u00f3n, termin\u00e9 utilizando una soluci\u00f3n tremendamente sencilla:<\/p>\n\n\n\n
      proyecto-hermes.md\nproyecto-claude.md<\/code><\/pre>\n\n\n\n
      Mientras Hermes trabaja, va anotando lo relevante en su fichero.<\/p>\n\n\n\n
      Mientras Claude trabaja, hace exactamente lo mismo en el suyo.<\/p>\n\n\n\n
      Y ambos tienen instrucciones para consultar el otro archivo.<\/p>\n\n\n\n
      Crear proyecto-hermes.md y proyecto-claude.md<\/h3>\n\n\n\n
      Podemos crearlos manualmente:<\/p>\n\n\n\n
      touch proyecto-hermes.md\ntouch proyecto-claude.md<\/code><\/pre>\n\n\n\n
      A partir de ah\u00ed, no los tratar\u00eda como diarios donde el agente escribe absolutamente todo.<\/p>\n\n\n\n
      Eso acabar\u00eda produciendo documentos enormes y poco \u00fatiles.<\/p>\n\n\n\n
      Los utilizar\u00eda como estado operativo del proyecto<\/strong>.<\/p>\n\n\n\n
      Por ejemplo, proyecto-hermes.md<\/code>:<\/p>\n\n\n\n
      # Hermes \u2014 Estado del proyecto\n\n## Tarea actual\nImplementando autenticaci\u00f3n mediante tokens.\n\n## Estado\nEn progreso.\n\n## Archivos que estoy modificando\n- src\/auth.py\n- tests\/test_auth.py\n\n## Cambios realizados\n- A\u00f1adida validaci\u00f3n inicial.\n- Creados tests de expiraci\u00f3n.\n\n## Pendiente\n- Revisar refresh tokens.\n- Ejecutar bater\u00eda completa de tests.\n\n## Mensaje para Claude\nRevisa la estrategia de renovaci\u00f3n de tokens.\nNo modifiques auth.py hasta que termine esta tarea.<\/code><\/pre>\n\n\n\n
      Claude puede consultar este fichero antes de actuar.<\/p>\n\n\n\n
      Su propio documento podr\u00eda contener:<\/p>\n\n\n\n
      # Claude \u2014 Estado del proyecto\n\n## Tarea actual\nRevisando la arquitectura de autenticaci\u00f3n.\n\n## Estado\nEn progreso.\n\n## Archivos que estoy modificando\n- docs\/auth-design.md\n\n## Hallazgos\nHay que revisar el comportamiento de refresh_token()\ncuando se producen peticiones simult\u00e1neas.\n\n## Mensaje para Hermes\nCuando termines auth.py, ejecuta los tests concurrentes.\nHe dejado propuestas en docs\/auth-design.md.<\/code><\/pre>\n\n\n\n
      Ahora tenemos algo bastante parecido a una comunicaci\u00f3n as\u00edncrona entre dos compa\u00f1eros.<\/p>\n\n\n\n
      Uno trabaja.<\/p>\n\n\n\n
      Deja estado.<\/p>\n\n\n\n
      El otro lo consulta.<\/p>\n\n\n\n
      Contin\u00faa.<\/p>\n\n\n\n
      Responde.<\/p>\n\n\n\n
      Y todo queda dentro del propio proyecto.<\/p>\n\n\n\n
      Por qu\u00e9 utilizo un fichero diferente para cada agente<\/h3>\n\n\n\n
      Podr\u00edamos utilizar un \u00fanico agents.md<\/code>.<\/p>\n\n\n\n
      Personalmente prefiero separar los ficheros porque as\u00ed cada agente tiene claramente identificado su espacio de escritura<\/strong>.<\/p>\n\n\n\n
      Reduce la posibilidad de que ambos reescriban el mismo documento simult\u00e1neamente y adem\u00e1s resulta m\u00e1s sencillo saber qui\u00e9n dijo qu\u00e9.<\/p>\n\n\n\n
      La regla ser\u00eda:<\/p>\n\n\n\n
      \n
      Cada agente escribe principalmente en su propio fichero y lee ambos.<\/p>\n<\/blockquote>\n\n\n\n
      Con algo tan simple ya tenemos una base de sincronizaci\u00f3n muy \u00fatil.<\/p>\n\n\n\n
      Mi protocolo para que Claude y Hermes no se pisen trabajando<\/h2>\n\n\n\n
      El mayor riesgo de tener dos agentes con acceso al mismo repositorio es evidente:<\/p>\n\n\n\n
      los dos pueden modificar la misma cosa.<\/strong><\/p>\n\n\n\n
      Y no hace falta que uno cometa un error para que aparezca un problema.<\/p>\n\n\n\n
      Imagina que Hermes abre auth.py<\/code>, detecta una funci\u00f3n mejorable y comienza a refactorizarla.<\/p>\n\n\n\n
      Mientras tanto Claude, partiendo del estado anterior del fichero, decide modificar esa misma funci\u00f3n.<\/p>\n\n\n\n
      Cada soluci\u00f3n puede ser correcta individualmente.<\/p>\n\n\n\n
      El problema es que ambas se est\u00e1n desarrollando sobre contextos diferentes.<\/p>\n\n\n\n
      Por eso utilizo una serie de reglas sencillas.<\/p>\n\n\n\n
      Indicar qu\u00e9 tarea est\u00e1 realizando cada agente<\/h3>\n\n\n\n
      El fichero deber\u00eda responder siempre r\u00e1pidamente a:<\/p>\n\n\n\n
      \u00bfQu\u00e9 est\u00e1 haciendo?\n\u00bfEn qu\u00e9 estado est\u00e1?\n\u00bfSobre qu\u00e9 archivos?\n\u00bfQu\u00e9 queda pendiente?<\/code><\/pre>\n\n\n\n
      No necesitamos una novela.<\/p>\n\n\n\n
      Necesitamos contexto operativo.<\/p>\n\n\n\n
      Marcar los archivos que est\u00e1 modificando<\/h3>\n\n\n\n
      Esta es probablemente la regla que m\u00e1s conflictos puede ahorrar.<\/p>\n\n\n\n
      Si Hermes escribe:<\/p>\n\n\n\n
      ## Archivos reservados temporalmente\n\n- src\/auth.py\n- src\/tokens.py<\/code><\/pre>\n\n\n\n
      Claude sabe que no deber\u00eda empezar una modificaci\u00f3n sobre ellos sin revisar antes lo que est\u00e1 ocurriendo.<\/p>\n\n\n\n
      Y viceversa.<\/p>\n\n\n\n
      No es un bloqueo t\u00e9cnico del sistema de archivos.<\/p>\n\n\n\n
      Es un bloqueo l\u00f3gico entre agentes<\/strong>.<\/p>\n\n\n\n
      Por eso depende de que ambos tengan claramente indicado en sus instrucciones que deben respetarlo.<\/p>\n\n\n\n
      Registrar cambios, pendientes y bloqueos<\/h3>\n\n\n\n
      Otro campo que considero especialmente \u00fatil es:<\/p>\n\n\n\n
      ## Bloqueos\n\nNecesito decidir c\u00f3mo almacenar los refresh tokens.\n\n## Solicitud\nClaude: revisa las alternativas y deja una recomendaci\u00f3n\nen proyecto-claude.md.<\/code><\/pre>\n\n\n\n
      Ahora el fichero no solo comunica estado.<\/p>\n\n\n\n
      Tambi\u00e9n sirve para pedir ayuda<\/strong>.<\/p>\n\n\n\n
      Consultar el estado del otro agente antes de empezar<\/h3>\n\n\n\n
      Esta ser\u00eda una de mis reglas base para ambos:<\/p>\n\n\n\n
      Antes de empezar una tarea nueva:\n\n1. Lee tu fichero de estado.\n2. Lee el fichero de estado del otro agente.\n3. Comprueba qu\u00e9 archivos est\u00e1n siendo modificados.\n4. Comprueba si tienes alguna solicitud pendiente.\n5. Actualiza tu estado antes de comenzar.<\/code><\/pre>\n\n\n\n
      Con esto convertimos dos herramientas independientes en un sistema mucho m\u00e1s coordinado.<\/p>\n\n\n\n
      C\u00f3mo hacer que Claude y Hermes se deleguen tareas<\/h2>\n\n\n\n
      La siguiente evoluci\u00f3n aparece de forma bastante natural.<\/p>\n\n\n\n
      Una vez que Claude puede leer lo que hace Hermes y Hermes puede leer lo que hace Claude, uno puede pedir trabajo al otro<\/strong>.<\/p>\n\n\n\n
      Y aqu\u00ed empiezan a aparecer un mont\u00f3n de posibilidades.<\/p>\n\n\n\n
      Pedir una segunda opini\u00f3n al otro agente<\/h3>\n\n\n\n
      Supongamos que Hermes est\u00e1 construyendo una funcionalidad y encuentra dos alternativas.<\/p>\n\n\n\n
      En lugar de decidir autom\u00e1ticamente, puede escribir:<\/p>\n\n\n\n
      ## Consulta para Claude\n\nEstoy implementando la cach\u00e9 de usuarios.\n\nTengo dos opciones:\n\n1. invalidaci\u00f3n por evento;\n2. TTL corto.\n\nRevisa el contexto del proyecto y dime qu\u00e9 estrategia\nconsideras m\u00e1s adecuada.\n\nNo modifiques todav\u00eda src\/cache.py.<\/code><\/pre>\n\n\n\n
      Claude lo lee y responde en su propio fichero:<\/p>\n\n\n\n
      ## Respuesta para Hermes\n\nRecomiendo invalidaci\u00f3n por evento con TTL de seguridad.\n\nMotivo:\n- el proyecto ya tiene eventos de actualizaci\u00f3n;\n- reduce lecturas obsoletas;\n- TTL queda como mecanismo de recuperaci\u00f3n.\n\nHe dejado una propuesta detallada en docs\/cache.md.<\/code><\/pre>\n\n\n\n
      Hermes recoge la recomendaci\u00f3n y contin\u00faa.<\/p>\n\n\n\n
      Delegar una subtarea<\/h3>\n\n\n\n
      Tambi\u00e9n podemos separar trabajo real.<\/p>\n\n\n\n
      Por ejemplo:<\/p>\n\n\n\n
      ## Tarea para Claude\n\nMientras termino la implementaci\u00f3n de usuarios,\nprepara tests para estos casos:\n\n- usuario inexistente;\n- token expirado;\n- m\u00faltiples sesiones.\n\nNo modifiques src\/users.py.<\/code><\/pre>\n\n\n\n
      Ahora estamos paralelizando trabajo sin duplicarlo.<\/p>\n\n\n\n
      Revisar el trabajo realizado por el otro<\/h3>\n\n\n\n
      Otra posibilidad que utilizo conceptualmente es convertir a un agente en revisor temporal del otro.<\/p>\n\n\n\n
      Hermes termina una parte.<\/p>\n\n\n\n
      Actualiza:<\/p>\n\n\n\n
      ## Tarea terminada\n\nImplementaci\u00f3n finalizada.\n\nArchivos:\n- src\/auth.py\n- tests\/test_auth.py\n\nClaude: puedes revisar los cambios.<\/code><\/pre>\n\n\n\n
      Claude revisa y devuelve observaciones.<\/p>\n\n\n\n
      Eso nos permite construir un ciclo:<\/p>\n\n\n\n
      HERMES\nImplementa\n    \u2502\n    \u25bc\nCLAUDE\nRevisa\n    \u2502\n    \u25bc\nHERMES\nCorrige\n    \u2502\n    \u25bc\nTESTS<\/code><\/pre>\n\n\n\n
      O exactamente al rev\u00e9s.<\/p>\n\n\n\n
      Ejemplo completo de colaboraci\u00f3n Hermes \u2192 Claude \u2192 Hermes<\/h3>\n\n\n\n
      Imaginemos una tarea: a\u00f1adir un sistema de recuperaci\u00f3n de contrase\u00f1a.<\/p>\n\n\n\n
      Primero Hermes escribe:<\/p>\n\n\n\n
      Estoy implementando el endpoint \/forgot-password.\nTrabajar\u00e9 sobre routes\/password.py.\nClaude: revisa posibles problemas de seguridad\ndel flujo mientras avanzo.<\/code><\/pre>\n\n\n\n
      Claude consulta el c\u00f3digo y responde:<\/p>\n\n\n\n
      He revisado el flujo.\n\nRecomendaciones:\n- tokens de un solo uso;\n- expiraci\u00f3n corta;\n- invalidaci\u00f3n despu\u00e9s del cambio;\n- evitar revelar si el email existe.<\/code><\/pre>\n\n\n\n
      Hermes recibe esas observaciones antes de terminar la implementaci\u00f3n y las incorpora.<\/p>\n\n\n\n
      Al finalizar:<\/p>\n\n\n\n
      Implementaci\u00f3n terminada.\nHe aplicado las cuatro recomendaciones.\nClaude: puedes hacer revisi\u00f3n final.<\/code><\/pre>\n\n\n\n
      Esto es exactamente el tipo de interacci\u00f3n que hace que tenga sentido utilizar dos agentes.<\/p>\n\n\n\n
      No porque haya dos inteligencias artificiales en la m\u00e1quina.<\/p>\n\n\n\n
      Sino porque existe colaboraci\u00f3n, divisi\u00f3n del trabajo y retroalimentaci\u00f3n<\/strong>.<\/p>\n\n\n\n
      Ejemplo de archivos Markdown para coordinar ambos agentes<\/h2>\n\n\n\n
      Despu\u00e9s de utilizar este enfoque durante un tiempo, creo que merece la pena estandarizar los ficheros.<\/p>\n\n\n\n
      Cuanto m\u00e1s predecible sea su estructura, m\u00e1s sencillo ser\u00e1 para cada agente encontrar la informaci\u00f3n relevante.<\/p>\n\n\n\n
      Plantilla de proyecto-hermes.md<\/h3>\n\n\n\n
      # HERMES \u2014 ESTADO\n\n## Objetivo general\n[Objetivo actual del proyecto]\n\n## Tarea actual\n[Tarea que estoy ejecutando]\n\n## Estado\nPendiente \/ En progreso \/ Bloqueada \/ Terminada\n\n## Archivos en los que estoy trabajando\n- archivo-1\n- archivo-2\n\n## Cambios realizados\n- cambio\n- cambio\n\n## Decisiones tomadas\n- decisi\u00f3n\n- motivo\n\n## Pendiente\n- tarea\n- tarea\n\n## Bloqueos\n- problema pendiente\n\n## Solicitudes para Claude\n- revisi\u00f3n \/ pregunta \/ subtarea\n\n## \u00daltima actualizaci\u00f3n\n[fecha\/hora o referencia de sesi\u00f3n]<\/code><\/pre>\n\n\n\n
      Plantilla de proyecto-claude.md<\/h3>\n\n\n\n
      Mantendr\u00eda pr\u00e1cticamente la misma estructura:<\/p>\n\n\n\n
      # CLAUDE \u2014 ESTADO\n\n## Objetivo general\n[Objetivo actual del proyecto]\n\n## Tarea actual\n[Tarea que estoy ejecutando]\n\n## Estado\nPendiente \/ En progreso \/ Bloqueada \/ Terminada\n\n## Archivos en los que estoy trabajando\n- archivo-1\n- archivo-2\n\n## Cambios realizados\n- cambio\n- cambio\n\n## Hallazgos\n- problema\n- oportunidad\n\n## Pendiente\n- tarea\n\n## Solicitudes para Hermes\n- revisi\u00f3n \/ prueba \/ implementaci\u00f3n \/ opini\u00f3n\n\n## \u00daltima actualizaci\u00f3n\n[fecha\/hora o referencia de sesi\u00f3n]<\/code><\/pre>\n\n\n\n
      C\u00f3mo mantener ambos archivos limpios y \u00fatiles<\/h3>\n\n\n\n
      Aqu\u00ed hay una trampa importante.<\/p>\n\n\n\n
      Un fichero compartido de contexto puede empezar siendo fant\u00e1stico y acabar convertido en un vertedero de 20.000 l\u00edneas.<\/p>\n\n\n\n
      Yo no intentar\u00eda almacenar todo el razonamiento de cada agente.<\/p>\n\n\n\n
      Guardar\u00eda \u00fanicamente informaci\u00f3n que pueda cambiar una decisi\u00f3n futura:<\/p>\n\n\n\n
        \n
      • tarea actual;<\/li>\n\n\n\n
      • archivos tocados;<\/li>\n\n\n\n
      • decisiones;<\/li>\n\n\n\n
      • cambios importantes;<\/li>\n\n\n\n
      • errores encontrados;<\/li>\n\n\n\n
      • pendientes;<\/li>\n\n\n\n
      • solicitudes al otro agente.<\/li>\n<\/ul>\n\n\n\n
        Cuando una etapa est\u00e9 completamente cerrada, se puede resumir.<\/p>\n\n\n\n
        Por ejemplo, en lugar de mantener 40 mensajes sobre una implementaci\u00f3n:<\/p>\n\n\n\n
        ## Historial\n\n### Autenticaci\u00f3n \u2014 TERMINADO\nImplementado sistema de tokens.\nTests completados.\nDecisi\u00f3n: refresh token rotatorio.\nDocumentaci\u00f3n: docs\/auth.md.<\/code><\/pre>\n\n\n\n
        El objetivo es conservar contexto \u00fatil<\/strong>, no registrar cada palabra que ha generado la IA.<\/p>\n\n\n\n
        Claude + Hermes frente a utilizar un solo agente<\/h2>\n\n\n\n
        \u00bfMerece realmente la pena tener dos agentes?<\/p>\n\n\n\n
        No siempre.<\/p>\n\n\n\n
        Hay tareas en las que utilizar Claude o Hermes por separado es m\u00e1s que suficiente.<\/p>\n\n\n\n
        Si tengo que modificar una funci\u00f3n peque\u00f1a, corregir un error evidente o hacer una consulta sencilla, introducir una arquitectura multiagente solo a\u00f1ade complejidad.<\/p>\n\n\n\n
        La diferencia aparece en trabajos m\u00e1s grandes.<\/p>\n\n\n\n
        Cuando un proyecto empieza a tener varias \u00e1reas, tareas paralelizables, revisiones, investigaci\u00f3n, tests y decisiones arquitect\u00f3nicas, contar con dos agentes puede cambiar bastante el flujo.<\/p>\n\n\n\n
        Con uno solo solemos trabajar de forma m\u00e1s lineal:<\/p>\n\n\n\n
        analizar\n   \u2193\nimplementar\n   \u2193\nrevisar\n   \u2193\nprobar<\/code><\/pre>\n\n\n\n
        Con dos podemos empezar a solapar procesos:<\/p>\n\n\n\n
                    \u250c\u2500 Hermes \u2192 implementaci\u00f3n\nan\u00e1lisis \u2500\u2500\u2500\u2524\n            \u2514\u2500 Claude \u2192 revisi\u00f3n \/ siguiente \u00e1rea<\/code><\/pre>\n\n\n\n
        Mientras uno implementa, el otro puede analizar.<\/p>\n\n\n\n
        Mientras uno ejecuta pruebas, el otro puede preparar una soluci\u00f3n diferente.<\/p>\n\n\n\n
        Mientras Hermes est\u00e1 trabajando en un \u00e1rea, Claude puede detectar problemas en otra.<\/p>\n\n\n\n
        En mi caso, precisamente esa capacidad para conectarme al servidor y trabajar con Claude al mismo tiempo que Hermes sigue avanzando es una de las razones por las que mantengo esta configuraci\u00f3n.<\/p>\n\n\n\n
        Pero no intentar\u00eda medir el beneficio simplemente preguntando:<\/p>\n\n\n\n
        \n
        \u00bfCu\u00e1l de los dos es mejor?<\/p>\n<\/blockquote>\n\n\n\n
        Me parece una pregunta poco \u00fatil.<\/p>\n\n\n\n
        La cuesti\u00f3n interesante es:<\/p>\n\n\n\n
        \n
        \u00bfC\u00f3mo puedo utilizar las capacidades de ambos para eliminar trabajo secuencial?<\/p>\n<\/blockquote>\n\n\n\n
        Ah\u00ed es donde aparece la ganancia.<\/p>\n\n\n\n
        Adem\u00e1s, un segundo agente proporciona algo parecido a una segunda opini\u00f3n permanente.<\/p>\n\n\n\n
        La IA tambi\u00e9n se equivoca.<\/p>\n\n\n\n
        Un agente puede proponer una soluci\u00f3n que parece perfecta hasta que otro revisa las implicaciones.<\/p>\n\n\n\n
        No asumir\u00eda que por utilizar dos agentes obtenemos autom\u00e1ticamente una respuesta correcta.<\/p>\n\n\n\n
        Lo que obtenemos es la posibilidad de construir mejores procesos de revisi\u00f3n y colaboraci\u00f3n<\/strong>.<\/p>\n\n\n\n
        Errores que evitar\u00eda al hacer trabajar juntos a Claude y Hermes<\/h2>\n\n\n\n
        Esta configuraci\u00f3n tiene much\u00edsimo potencial, pero tambi\u00e9n puede convertirse r\u00e1pidamente en un caos.<\/p>\n\n\n\n
        La mayor\u00eda de los problemas no est\u00e1n realmente en Claude ni en Hermes.<\/p>\n\n\n\n
        Est\u00e1n en el protocolo de trabajo que les damos<\/strong>.<\/p>\n\n\n\n
        Dejar que ambos modifiquen los mismos archivos<\/h3>\n\n\n\n
        Este ser\u00eda mi primer error a evitar.<\/p>\n\n\n\n
        Si Claude y Hermes empiezan a editar simult\u00e1neamente la misma parte del proyecto, hemos perdido buena parte de las ventajas de tener dos agentes.<\/p>\n\n\n\n
        Por eso marco qu\u00e9 archivos est\u00e1 utilizando cada uno.<\/p>\n\n\n\n
        Si el otro necesita entrar en esa \u00e1rea, primero debe consultar el estado.<\/p>\n\n\n\n
        No registrar qu\u00e9 est\u00e1 haciendo cada agente<\/h3>\n\n\n\n
        Si proyecto-hermes.md<\/code> lleva tres horas sin actualizarse, Claude puede partir de informaci\u00f3n desfasada.<\/p>\n\n\n\n
        Por eso una instrucci\u00f3n \u00fatil ser\u00eda:<\/p>\n\n\n\n
        Actualiza tu fichero:\n\n- antes de empezar una tarea;\n- cuando cambies de \u00e1rea;\n- cuando aparezca un bloqueo;\n- al terminar.<\/code><\/pre>\n\n\n\n
        No hace falta escribir despu\u00e9s de cada comando.<\/p>\n\n\n\n
        Dar instrucciones contradictorias<\/h3>\n\n\n\n
        Hay otro error bastante f\u00e1cil de cometer.<\/p>\n\n\n\n
        Imagina que yo digo a Hermes:<\/p>\n\n\n\n
        \n
        No cambies la base de datos.<\/p>\n<\/blockquote>\n\n\n\n
        Y m\u00e1s tarde digo a Claude:<\/p>\n\n\n\n
        \n
        Adapta el esquema de base de datos como consideres.<\/p>\n<\/blockquote>\n\n\n\n
        Ya tenemos un conflicto creado por m\u00ed.<\/p>\n\n\n\n
        Por eso las decisiones importantes deber\u00edan aparecer tambi\u00e9n en el estado compartido.<\/p>\n\n\n\n
        Acumular demasiado contexto<\/h3>\n\n\n\n
        M\u00e1s informaci\u00f3n no siempre significa mejor contexto.<\/p>\n\n\n\n
        Un .md<\/code> gigantesco puede hacer que el agente encuentre con m\u00e1s dificultad lo importante.<\/p>\n\n\n\n
        Prefiero resumen + estado actual.<\/p>\n\n\n\n
        Los detalles permanentes pueden vivir en documentaci\u00f3n espec\u00edfica.<\/p>\n\n\n\n
        Olvidarnos del control de versiones<\/h3>\n\n\n\n
        Si dos agentes tienen capacidad para modificar un proyecto, Git pasa de recomendable a casi imprescindible en mi flujo.<\/p>\n\n\n\n
        No porque los agentes vayan necesariamente a romper algo, sino porque el sistema debe ser reversible.<\/p>\n\n\n\n
        Commits peque\u00f1os, ramas cuando tenga sentido y puntos claros de recuperaci\u00f3n hacen mucho m\u00e1s segura cualquier automatizaci\u00f3n.<\/p>\n\n\n\n
        \u00bfHace falta MCP para conectar Claude con Hermes?<\/h2>\n\n\n\n
        No necesariamente para el m\u00e9todo que estoy utilizando aqu\u00ed.<\/p>\n\n\n\n
        Hermes dispone de mecanismos relacionados con MCP y uno de los referentes analizados describe la posibilidad de ejecutar Hermes como servidor MCP para exponer informaci\u00f3n de sesiones a clientes compatibles, entre ellos Claude Desktop. Tambi\u00e9n describe el paso de informaci\u00f3n entre agentes mediante archivos en sus flujos multiagente.<\/p>\n\n\n\n
        MCP abre posibilidades interesantes.<\/p>\n\n\n\n
        Pero no necesitamos convertir MCP en un requisito para que Claude y Hermes puedan coordinar trabajo sobre un repositorio compartido<\/strong>.<\/p>\n\n\n\n
        Para empezar, mi planteamiento es mucho m\u00e1s b\u00e1sico:<\/p>\n\n\n\n
        mismo proyecto\n+\nficheros compartidos\n+\nreglas claras\n=\ncoordinaci\u00f3n<\/code><\/pre>\n\n\n\n
        Esto tiene varias ventajas.<\/p>\n\n\n\n
        Es transparente: puedo abrir el .md<\/code> y saber inmediatamente qu\u00e9 conoce cada agente.<\/p>\n\n\n\n
        Es portable: Markdown no depende de una aplicaci\u00f3n concreta.<\/p>\n\n\n\n
        Es f\u00e1cil de depurar: si Claude ha entendido mal el estado de Hermes, puedo leer exactamente qu\u00e9 informaci\u00f3n ten\u00eda disponible.<\/p>\n\n\n\n
        Y es f\u00e1cil de modificar.<\/p>\n\n\n\n
        \u00bfSignifica esto que Markdown es mejor que MCP?<\/p>\n\n\n\n
        No.<\/p>\n\n\n\n
        Son capas diferentes y pueden incluso coexistir.<\/p>\n\n\n\n
        Si tu caso de uso necesita acceso estructurado a sesiones, herramientas o contexto externo, MCP puede resultar muy interesante.<\/p>\n\n\n\n
        Si lo que necesitas es que dos agentes sepan qu\u00e9 est\u00e1 haciendo el otro dentro de un proyecto<\/strong>, un fichero bien estructurado puede ser suficiente para empezar.<\/p>\n\n\n\n
        Mi recomendaci\u00f3n ser\u00eda no introducir complejidad hasta que exista un problema concreto que la justifique.<\/p>\n\n\n\n
        Consejos para trabajar con dos agentes IA en el mismo servidor<\/h2>\n\n\n\n
        Despu\u00e9s de montar el sistema, hay varias reglas que considero m\u00e1s importantes que cualquier comando de instalaci\u00f3n.<\/p>\n\n\n\n
        Utilizar control de versiones<\/h3>\n\n\n\n
        No dar\u00eda acceso de escritura a dos agentes sobre un proyecto importante sin una estrategia de recuperaci\u00f3n.<\/p>\n\n\n\n
        Git permite revisar exactamente qu\u00e9 ha cambiado y volver atr\u00e1s cuando sea necesario.<\/p>\n\n\n\n
        Tambi\u00e9n podemos pedir a cada agente que indique en su .md<\/code> los commits o cambios relevantes.<\/p>\n\n\n\n
        Dividir el proyecto por \u00e1reas<\/h3>\n\n\n\n
        Cuanto m\u00e1s claras sean las fronteras, mejor.<\/p>\n\n\n\n
        Por ejemplo:<\/p>\n\n\n\n
        Hermes:\nbackend + tests\n\nClaude:\nfrontend + arquitectura<\/code><\/pre>\n\n\n\n
        O:<\/p>\n\n\n\n
        Hermes:\nimplementaci\u00f3n\n\nClaude:\nrevisi\u00f3n + documentaci\u00f3n + an\u00e1lisis<\/code><\/pre>\n\n\n\n
        No tiene que ser una divisi\u00f3n permanente.<\/p>\n\n\n\n
        Puede cambiar en cada tarea.<\/p>\n\n\n\n
        Mantener instrucciones simples<\/h3>\n\n\n\n
        Los protocolos excesivamente complejos terminan incumpli\u00e9ndose.<\/p>\n\n\n\n
        Mi regla principal podr\u00eda resumirse as\u00ed:<\/p>\n\n\n\n
        Lee ambos .md.\nActualiza el tuyo.\nRespeta los archivos ocupados.\nPide ayuda cuando la necesites.\nDeja claro cuando termines.<\/code><\/pre>\n\n\n\n
        Eso es mucho m\u00e1s f\u00e1cil de mantener que un documento de 50 reglas.<\/p>\n\n\n\n
        Dejar trazabilidad de las decisiones importantes<\/h3>\n\n\n\n
        No todo lo que hablan los agentes merece almacenarse.<\/p>\n\n\n\n
        Las decisiones importantes s\u00ed.<\/p>\n\n\n\n
        Por ejemplo:<\/p>\n\n\n\n
        ## Decisi\u00f3n\n\nUtilizamos PostgreSQL advisory locks.\n\nMotivo:\nla aplicaci\u00f3n necesita coordinar trabajos concurrentes.\n\nPropuesto por:\nClaude\n\nImplementado por:\nHermes<\/code><\/pre>\n\n\n\n
        Seis meses m\u00e1s tarde, esa informaci\u00f3n puede ser much\u00edsimo m\u00e1s \u00fatil que cientos de l\u00edneas de conversaci\u00f3n.<\/p>\n\n\n\n
        Y adem\u00e1s crea algo interesante:<\/p>\n\n\n\n
        el sistema no solo permite que Claude y Hermes trabajen juntos ahora.<\/p>\n\n\n\n
        Tambi\u00e9n permite que el siguiente agente que entre al proyecto comprenda por qu\u00e9 se tomaron determinadas decisiones<\/strong>.<\/p>\n\n\n\n
        D\u00f3nde est\u00e1 realmente la ventaja de juntar Claude y Hermes<\/h2>\n\n\n\n
        Instalar Claude en un servidor donde ya funciona Hermes es solamente el primer paso.<\/p>\n\n\n\n
        Para m\u00ed, el verdadero salto lleg\u00f3 cuando dej\u00e9 de pensar en ellos como dos herramientas separadas y empec\u00e9 a tratarlos como dos agentes que necesitan conocer el trabajo del otro<\/strong>.<\/p>\n\n\n\n
        En mi caso, la soluci\u00f3n para mantener una comunicaci\u00f3n estable y fluida ha terminado siendo bastante simple.<\/p>\n\n\n\n
        Hermes mantiene:<\/p>\n\n\n\n
        proyecto-hermes.md<\/code><\/pre>\n\n\n\n
        Claude mantiene:<\/p>\n\n\n\n
        proyecto-claude.md<\/code><\/pre>\n\n\n\n
        Los dos leen ambos documentos.<\/p>\n\n\n\n
        Cada uno registra qu\u00e9 est\u00e1 haciendo.<\/p>\n\n\n\n
        Cada uno puede advertir al otro de los ficheros que est\u00e1 utilizando.<\/p>\n\n\n\n
        Pueden intercambiar opiniones.<\/p>\n\n\n\n
        Pueden delegarse subtareas.<\/p>\n\n\n\n
        Pueden revisar mutuamente su trabajo.<\/p>\n\n\n\n
        Y, sobre todo, pueden continuar trabajando de forma paralela sin entrar constantemente en conflicto.<\/p>\n\n\n\n
        Eso abre un n\u00famero enorme de posibilidades.<\/p>\n\n\n\n
        Podemos tener un agente implementando mientras otro revisa.<\/p>\n\n\n\n
        Uno investigando mientras el otro prueba.<\/p>\n\n\n\n
        Uno detectando un problema y el otro ejecutando la soluci\u00f3n.<\/p>\n\n\n\n
        Y podemos hacerlo sin necesidad de construir desde el primer d\u00eda un orquestador complejo.<\/p>\n\n\n\n
        Despu\u00e9s podremos a\u00f1adir MCP, automatizaciones, triggers, procesos multiagente m\u00e1s sofisticados o cualquier otra capa que tenga sentido.<\/p>\n\n\n\n
        Pero empezar\u00eda por algo mucho m\u00e1s b\u00e1sico:<\/p>\n\n\n\n
        dar a Claude y Hermes un proyecto com\u00fan, responsabilidades claras y una forma sencilla de comunicarse.<\/strong><\/p>\n\n\n\n
        Para m\u00ed, esa es la diferencia entre tener dos agentes instalados y tener realmente Claude y Hermes trabajando juntos<\/strong>.<\/p>\n\n\n\n
        Dudas de la comunidad<\/h2>\n\n\n\n
        \u00bfClaude y Hermes pueden trabajar al mismo tiempo?<\/h3>\n\n\n\n
        S\u00ed, siempre que el entorno permita ejecutar ambos y establezcamos una estrategia para que no modifiquen simult\u00e1neamente las mismas partes del proyecto.<\/p>\n\n\n\n
        En mi caso utilizo ficheros Markdown para mantener el estado de cada agente y dejar claro sobre qu\u00e9 est\u00e1 trabajando cada uno.<\/p>\n\n\n\n
        \u00bfClaude y Hermes pueden modificar el mismo proyecto?<\/h3>\n\n\n\n
        S\u00ed.<\/p>\n\n\n\n
        De hecho, esa es una de las principales ventajas de tener ambos en la misma m\u00e1quina o con acceso al mismo entorno.<\/p>\n\n\n\n
        Lo que intento evitar es que modifiquen simult\u00e1neamente los mismos archivos.<\/p>\n\n\n\n
        \u00bfC\u00f3mo evito que Claude y Hermes se pisen?<\/h3>\n\n\n\n
        Mi m\u00e9todo consiste en que cada agente indique en su .md<\/code>:<\/p>\n\n\n\n
          \n
        • tarea actual;<\/li>\n\n\n\n
        • archivos que est\u00e1 modificando;<\/li>\n\n\n\n
        • cambios realizados;<\/li>\n\n\n\n
        • pendientes;<\/li>\n\n\n\n
        • bloqueos.<\/li>\n<\/ul>\n\n\n\n
          Antes de comenzar una nueva tarea, ambos deben consultar el fichero del otro.<\/p>\n\n\n\n
          \u00bfClaude puede pedirle tareas a Hermes?<\/h3>\n\n\n\n
          S\u00ed, si dise\u00f1amos el flujo para ello.<\/p>\n\n\n\n
          Por ejemplo, Claude puede dejar en proyecto-claude.md<\/code> una solicitud para que Hermes ejecute tests, implemente una parte o compruebe una hip\u00f3tesis.<\/p>\n\n\n\n
          Hermes puede leerla, realizar la tarea y devolver los resultados en su propio fichero.<\/p>\n\n\n\n
          \u00bfHermes puede pedir ayuda a Claude?<\/h3>\n\n\n\n
          Exactamente igual.<\/p>\n\n\n\n
          Hermes puede solicitar una revisi\u00f3n arquitect\u00f3nica, una segunda opini\u00f3n, an\u00e1lisis de c\u00f3digo o cualquier subtarea para la que queramos utilizar Claude.<\/p>\n\n\n\n
          La comunicaci\u00f3n debe ser bidireccional.<\/p>\n\n\n\n
          \u00bfNecesito Claude Code o Claude Desktop?<\/h3>\n\n\n\n
          Depende de c\u00f3mo quieras trabajar.<\/p>\n\n\n\n
          Claude Code<\/strong> est\u00e1 orientado al trabajo desde terminal y resulta especialmente relevante cuando queremos operar directamente sobre proyectos y archivos dentro de un entorno de desarrollo.<\/p>\n\n\n\n
          Claude Desktop<\/strong> es una aplicaci\u00f3n diferente y puede formar parte de otros flujos, incluyendo integraciones mediante MCP. Hermes, seg\u00fan uno de los referentes analizados, puede exponer informaci\u00f3n a clientes compatibles como Claude Desktop mediante su modo MCP.<\/p>\n\n\n\n
          En mi flujo utilizo el acceso remoto junto con Claude para trabajar sobre la misma m\u00e1quina en la que est\u00e1 Hermes, pero conviene no confundir Claude Desktop con Claude Code.<\/p>\n\n\n\n
          \u00bfEs obligatorio utilizar MCP?<\/h3>\n\n\n\n
          No para el m\u00e9todo explicado en esta gu\u00eda.<\/p>\n\n\n\n
          La coordinaci\u00f3n mediante .md<\/code> funciona como una capa sencilla de comunicaci\u00f3n basada en el propio sistema de archivos.<\/p>\n\n\n\n
          MCP puede incorporarse posteriormente si necesitamos una integraci\u00f3n m\u00e1s estructurada.<\/p>\n\n\n\n
          \u00bfEs mejor Claude + Hermes que utilizar un solo agente?<\/h3>\n\n\n\n
          No necesariamente para todas las tareas.<\/p>\n\n\n\n
          Para trabajos peque\u00f1os, un solo agente ser\u00e1 m\u00e1s sencillo.<\/p>\n\n\n\n
          La combinaci\u00f3n empieza a aportar mucho m\u00e1s valor cuando podemos dividir un proyecto en trabajos paralelos, revisiones, investigaci\u00f3n, tests o diferentes \u00e1reas de desarrollo.<\/p>\n\n\n\n
          La clave no est\u00e1 en utilizar m\u00e1s agentes.<\/p>\n\n\n\n
          Est\u00e1 en conseguir que cada uno tenga una responsabilidad clara y suficiente contexto para colaborar con los dem\u00e1s<\/strong>.<\/p>\n\n\n\n
          Opini\u00f3n Personal<\/strong><\/p>\n\n\n\n
          Despu\u00e9s de llevar tiempo trabajando con Hermes Agent, instalar tambi\u00e9n Claude en el mismo servidor ha sido una de esas decisiones que, en mi caso, ha cambiado bastante la forma de afrontar proyectos m\u00e1s complejos.<\/p>\n\n\n\n
          Lo que m\u00e1s valoro no es simplemente tener dos agentes disponibles, sino poder utilizarlos de forma complementaria. Mientras Hermes avanza en una parte del proyecto, Claude puede revisar otra, analizar una decisi\u00f3n, proponer mejoras o encargarse de una subtarea diferente.<\/p>\n\n\n\n
          La clave para m\u00ed ha sido mantener la coordinaci\u00f3n lo m\u00e1s sencilla posible. En lugar de crear desde el principio una arquitectura complicada, utilizo archivos Markdown donde cada agente va dejando constancia de lo que est\u00e1 haciendo, los archivos que est\u00e1 modificando, las decisiones que ha tomado y las tareas que tiene pendientes.<\/p>\n\n\n\n
          Gracias a este sistema, ambos pueden leer el trabajo del otro y mantener suficiente contexto como para colaborar sin pisarse constantemente. Incluso pueden pedirse opiniones, revisiones o peque\u00f1as tareas, algo que abre much\u00edsimas posibilidades cuando el proyecto empieza a crecer.<\/p>\n\n\n\n
          Creo que estamos entrando en una etapa en la que trabajar con varios agentes de IA ser\u00e1 cada vez m\u00e1s habitual. Pero tener varios agentes no sirve de mucho si cada uno trabaja completamente aislado. El verdadero potencial aparece cuando conseguimos que compartan contexto, se repartan responsabilidades y colaboren de una forma organizada.<\/p>\n\n\n\n
          En mi caso, combinar Claude y Hermes de esta manera me permite aprovechar mejor las fortalezas de ambos y trabajar de forma mucho m\u00e1s paralela.<\/p>\n\n\n\n
          \u00bfHas probado alguna vez a utilizar Claude y Hermes juntos o tienes otro m\u00e9todo para coordinar varios agentes de IA? Cu\u00e9ntame tu experiencia en los comentarios. Me interesa especialmente conocer qu\u00e9 sistema utilizas para evitar conflictos y compartir contexto entre ellos.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
          Llevo tiempo utilizando Hermes Agent y, de todas las mejoras que he ido introduciendo en mi forma de trabajar, una de las decisiones que m\u00e1s diferencia ha marcado ha sido tener tambi\u00e9n Claude en el mismo entorno de servidor. No me refiero simplemente a tener dos herramientas de inteligencia artificial instaladas en la misma m\u00e1quina. […]<\/p>\n","protected":false},"author":1,"featured_media":9562,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"set","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"categories":[15],"tags":[1121,1420,606,605],"class_list":["post-9561","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-tecnologia","tag-claude","tag-hermes","tag-ia","tag-inteligencia-artificial"],"_links":{"self":[{"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/posts\/9561","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/comments?post=9561"}],"version-history":[{"count":1,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/posts\/9561\/revisions"}],"predecessor-version":[{"id":9563,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/posts\/9561\/revisions\/9563"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/media\/9562"}],"wp:attachment":[{"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/media?parent=9561"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/categories?post=9561"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.hostingtg.com\/blog\/wp-json\/wp\/v2\/tags?post=9561"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}