Cómo construir un copiloto de soporte con Hermes

En resumen

• Copiloto de soporte (término editorial, no lenguaje de producto de Hermes) significa un asistente interno para agentes humanos: redacta borradores, resume conversaciones, consulta políticas y recomienda escalamiento; la persona es responsable de cada mensaje visible para el cliente.
• No es el bot de atención al cliente de la Parte 2. La Parte 2 conecta un Agent Bot de Chatwoot que responde automáticamente en conversaciones con estado pending. Un copiloto responde a acciones explícitas del agente y publica notas privadas o borradores para copiar y enviar.
• Stack recomendado (julio de 2026, criterio editorial): perfil de Hermes separado (support-copilot) + toolset personalizado centrado en lectura + servidor API + bridge de asistencia ligero o interfaz en barra lateral → notas privadas de Chatwoot.
• La gobernanza importa: memory.write_approval / skills.write_approval, reglas de solo borradores en AGENTS.md, trazas de evaluación y una declaración explícita de «evidencia insuficiente» cuando la recuperación no devuelve resultados.
• El valor de Hermes frente a un wrapper ligero: sesiones, skills, memoria acotada, delimitación de herramientas, trayectorias y controles de aprobación; no solo openai.chat.completions con un prompt de sistema largo.

Qué aprenderás aquí

• En qué se diferencia un copiloto de soporte de un agente de WhatsApp que atiende a clientes
• Responsabilidades de producto e ingeniería en productos de asistencia
• Arquitectura de referencia: perfil de Hermes, toolsets y notas privadas de Chatwoot
• Patrones de memoria, skills y sesiones para equipos de soporte
• Participación humana: confianza, escalamiento y aprobaciones
• Controles de calidad y cuándo incorporar RAG empresarial
• Lista de verificación operativa y modos de falla

Esta es la Parte 4 de la serie sobre Hermes Agent. Lee la Parte 1 para conocer los conceptos del harness y la Parte 2 para la integración con el canal de atención al cliente. La Parte 3 cubre las operaciones programadas.

Copiloto de soporte vs. bot de atención al cliente

La documentación de Hermes describe un harness de agentes de propósito general, no un producto empaquetado como «copiloto de soporte». En esta serie, la distinción es quién envía el mensaje:

CUSTOMER CHANNEL (Part 2)          INTERNAL COPILOT (Part 4)
─────────────────────────          ─────────────────────────
Customer on WhatsApp               Human agent in Chatwoot UI
Agent Bot auto-replies             Agent clicks "Suggest" / macro
Hermes → customer-visible reply    Hermes → private note OR copy box
Conversation status: pending       Conversation status: open (human-owned)
Bridge: Agent Bot webhook          Bridge: explicit assist API call

Criterio editorial: Ejecuta estos componentes en perfiles de Hermes separados para que las herramientas disponibles, la memoria y los ciclos de aprendizaje no entren en conflicto.

Diferencias respecto de la Parte 2

Quién se encarga de qué (producto vs. ingeniería)

La Parte 2 definió quién se encarga de los tokens de Meta y del tráfico entrante al bridge. La Parte 4 define quién se encarga de la calidad de la asistencia y de rendir cuentas por ella.

Arquitectura de referencia

Support agent opens conversation in Chatwoot (status: open)
        |
        v
+-----------------------------------+
| Copilot UI (you build one)        |
| - Chatwoot Dashboard App          |
| - Internal "Suggest reply" web app|
| - Browser extension               |
+---------------+-------------------+
                | HTTPS + API_SERVER_KEY
                v
+-----------------------------------+
| Hermes API server                 |
| profile: support-copilot          |
| toolset: support-copilot (custom) |
+---------------+-------------------+
                |
     +----------+----------+
     v          v          v
  qmd/wiki   MCP/CRM    session_search
  skills     order API   MEMORY.md
                |
                v
+-----------------------------------+
| Outputs (human-reviewed)          |
| - Suggested reply (copy/paste)    |
| - Private note (private: true)    |
| - Escalation recommendation       |
+-----------------------------------+

Una limitación que debes considerar: Chatwoot no tiene un panel de copiloto de Hermes propio. Debes construir la interfaz de barra lateral o la integración HTTP activada por una macro. Los webhooks de Agent Bot (bots de agente de Chatwoot) están optimizados para conversaciones pending gestionadas por un bot y no son adecuados para la asistencia iniciada por una persona.

Paso 1: Crea un perfil aislado de Hermes

hermes profile create support-copilot \
  --description "Internal Chatwoot assist; draft-only; no customer auto-send."

cat >> ~/.hermes/profiles/support-copilot/.env <<'EOF'
OPENAI_API_KEY=sk-...
API_SERVER_ENABLED=true
API_SERVER_HOST=127.0.0.1
API_SERVER_PORT=8643
API_SERVER_KEY=change-me-to-a-long-random-secret
EOF

support-copilot gateway install
support-copilot gateway start   # or: support-copilot gateway run (foreground dev)

Los perfiles aíslan la configuración, la memoria, las sesiones y el estado del gateway (documentación de perfiles). Mantén customer-bot y support-copilot en puertos distintos si ambos servidores API se ejecutan al mismo tiempo.

Paso 2: Delimita las herramientas de asistencia (no uses las predeterminadas)

El servidor API expone un conjunto predeterminado de herramientas casi completo (hermes-api-server), a menos que lo restrinjas (servidor API). No incluyas herramientas de terminal o navegador en un copiloto de soporte.

Según la referencia de toolsets, los valores predeterminados de plataforma como hermes-whatsapp se corresponden con toolsets de CLI casi completos; la recomendación de la Parte 2 de limitar su alcance también aplica aquí. Define un toolset de asistencia personalizado en la configuración y verifícalo en tiempo de ejecución:

# ~/.hermes/profiles/support-copilot/config.yaml
memory:
  write_approval: true
skills:
  write_approval: true
display:
  memory_notifications: verbose
auxiliary:
  background_review:
    provider: openai-api
    model: gpt-4o-mini

custom_toolsets:
  support-copilot:
    - safe
    - session_search
    - skills
    - memory

Luego delimita las herramientas de la plataforma del servidor API mediante hermes tools (selecciona el toolset api_server / support-copilot). Verifica los flags para tu versión de Hermes: es posible que hermes gateway --help no exponga --toolsets en todas las compilaciones; la configuración + hermes tools es la vía confiable (la misma advertencia que en la Parte 2).

curl http://127.0.0.1:8643/v1/toolsets \
  -H "Authorization: Bearer $API_SERVER_KEY"

El toolset integrado safe incluye herramientas web de solo lectura (web_search, web_extract, vision_analyze) sin ejecución de terminal ni de archivos (referencia de toolsets).

Paso 3: Define las reglas del copiloto en AGENTS.md

Las reglas del canal pertenecen a Hermes, no deben estar codificadas en el bridge (la misma lección de la Parte 2):

<!-- AGENTS.md -->
# Support Copilot Rules

- You assist human agents only. Never imply you sent a message to the customer.
- Default output structure:
  1. suggested_reply (plain text, WhatsApp-safe length)
  2. confidence: high | medium | low
  3. sources: list skill names, doc paths, or MCP record IDs used
  4. escalation_recommended: true | false
- If policy is unclear or retrieval is empty, say "insufficient evidence" — do not invent refund eligibility.
- For billing disputes over $500, recommend escalation per escalation-matrix skill.

Hermes las carga mediante ensamblaje de prompts: se agregan como una capa sobre el prompt principal del harness, sin reemplazarlo.

Inicializa la memoria acotada

Las escrituras en memoria durante una sesión se guardan en disco de inmediato, pero no modifican el prompt congelado hasta que se reconstruye (memoria persistente). Precarga las políticas críticas antes de un turno.

Skills que debes incluir

Créalas a partir de runbooks mediante /learn (sistema de skills).

Paso 4: Construye el bridge de asistencia

A diferencia del webhook de Agent Bot de la Parte 2, el bridge del copiloto procesa solicitudes explícitas del agente:

# copilot/assist.py
import httpx

CHATWOOT_BASE = "https://support.example.com"
ACCOUNT_ID = 1
HERMES_BASE = "http://127.0.0.1:8643"
HERMES_API_KEY = "..."


def extract_response_text(data: dict) -> str:
    for item in data.get("output", []):
        if item.get("type") != "message":
            continue
        for part in item.get("content", []):
            if part.get("type") == "output_text":
                text = (part.get("text") or "").strip()
                if text:
                    return text
    return ""


async def fetch_chatwoot_thread(client: httpx.AsyncClient, account_id: int, conversation_id: int, token: str) -> str:
    """Hermes does not ingest Chatwoot natively — pack thread context yourself."""
    url = f"{CHATWOOT_BASE}/api/v1/accounts/{account_id}/conversations/{conversation_id}/messages"
    resp = await client.get(url, headers={"api_access_token": token})
    resp.raise_for_status()
    lines = []
    for msg in resp.json().get("payload", []):
        role = "customer" if msg.get("message_type") in (0, "incoming") else "agent"
        content = (msg.get("content") or "").strip()
        if content:
            lines.append(f"{role}: {content}")
    return "\n".join(lines[-20:])  # recent tail


async def suggest_reply(conversation_id: int, agent_token: str) -> str:
    conversation_key = f"chatwoot:copilot:{conversation_id}"
    session_key = f"chatwoot:contact:{conversation_id}"

    async with httpx.AsyncClient(timeout=120.0) as client:
        thread_text = await fetch_chatwoot_thread(client, ACCOUNT_ID, conversation_id, agent_token)

        payload = {
            "model": "hermes-agent",
            "input": thread_text,
            "conversation": conversation_key,
            "store": True,
        }
        headers = {
            "Authorization": f"Bearer {HERMES_API_KEY}",
            "X-Hermes-Session-Key": session_key,
        }
        resp = await client.post(f"{HERMES_BASE}/v1/responses", json=payload, headers=headers)
        resp.raise_for_status()
        return extract_response_text(resp.json())


async def post_private_note(conversation_id: int, agent_token: str, content: str) -> None:
    url = f"{CHATWOOT_BASE}/api/v1/accounts/{ACCOUNT_ID}/conversations/{conversation_id}/messages"
    async with httpx.AsyncClient(timeout=30.0) as client:
        await client.post(
            url,
            headers={"api_access_token": agent_token},
            json={"content": content, "message_type": 1, "private": True},
        )

Semántica de las sesiones (según el servidor API):

• conversation (chatwoot:copilot:{id}) encadena la asistencia de múltiples turnos dentro de una sesión del copiloto.
• X-Hermes-Session-Key (chatwoot:contact:{id}) delimita los proveedores de memoria a largo plazo por conversación con el cliente; se mantiene intencionalmente separado de la clave del historial de asistencia.
• /v1/chat/completions no tiene estado; evítalo para conversaciones de asistencia.

La Parte 2 usó una sola clave para ambos roles en el flujo del bot de atención al cliente; el copiloto las separa para que los reinicios de la conversación de asistencia no alteren la memoria asociada al contacto.

Consulta Agentes con estado vs. sin estado en producción para conocer las ventajas y desventajas generales.

Paso 5: Participación humana

Notas privadas (solo para agentes)

La API de creación de mensajes de Chatwoot admite private: true, invisible para el cliente:

{
  "content": "🤖 Copilot draft (not sent):\n\nSuggested reply: ...\n\nSources: refund-policy skill §3\nConfidence: medium",
  "message_type": 1,
  "private": true
}

Chatwoot también acepta "message_type": "outgoing" como cadena; el entero 1 coincide con la convención del bridge de la Parte 2.

Usa notas privadas para resúmenes del razonamiento, listas de fuentes y justificaciones de escalamiento. Configura la interfaz del copiloto como privada por defecto; exige una acción humana explícita para copiar contenido al cuadro de respuesta al cliente.

Escalamiento

Hermes no tiene una primitiva confidence nativa; impleméntala mediante el esquema de salida de AGENTS.md y evaluaciones. Cuando aparezca escalation_recommended: true o confidence: low:

1. Publica una nota privada con la recomendación.
2. Una persona ejecuta toggle_status → open o realiza la asignación en la interfaz de Chatwoot (API de cambio de estado).

Aprobaciones para consultas sensibles

Para interfaces de copiloto con lógica de cliente más completa, Hermes expone POST /v1/runs/{run_id}/approval cuando una llamada a una herramienta espera una decisión humana (servidor API — Runs API). Es útil para consultas de CRM que manejan muchos datos personales identificables.

Gobernanza del aprendizaje

Con memory.write_approval: true y skills.write_approval: true, la revisión en segundo plano puede proponer macros a partir de patrones de tickets, que quedan pendientes de revisión mediante /memory pending y /skills pending. Sin controles, un solo ticket problemático puede enseñar «reembolsar siempre».

Paso 6: Controles de calidad

Hermes te da los componentes básicos; la capa de evaluación del producto es responsabilidad tuya.

Qué proporciona Hermes

Qué debes construir tú (evaluación por ticket)

Usa herramientas de escenarios y rúbricas para los tickets de referencia de Chatwoot, no solo el ejecutor de trayectorias por lotes:

• Evaluación de agentes de IA con LangWatch — suites de escenarios
• Cómo revisar respuestas generadas por IA — rúbrica para revisión humana
• Calificación de trazas vs. pruebas de escenarios
• Aplicaciones RAG en la práctica — antes de basar en documentos las respuestas a clientes

Lista de verificación de fuentes

[ ] Copilot output lists sources (skill name, qmd path, MCP record ID)
[ ] Empty retrieval → explicit "insufficient evidence"
[ ] Golden ticket set (50–200) with expected citations
[ ] Regression on prompt/model/skill changes
[ ] PII scrubbing before logging trajectories

Cuándo incorporar RAG empresarial

Copiloto de Hermes vs. wrapper ligero de ChatGPT

La Parte 2 sostuvo que el bridge debía mantenerse simple. La Parte 4 sostiene que la capa de producto del copiloto —políticas, evaluaciones, gobernanza de herramientas y aprendizaje— es donde Hermes aporta valor.

Lista de verificación operativa

[ ] Separate Hermes profile for copilot (not customer-bot)
[ ] Custom read-heavy toolset verified via GET /v1/toolsets
[ ] memory.write_approval + skills.write_approval enabled
[ ] AGENTS.md: draft-only, cite sources, escalation rules
[ ] MEMORY.md seeded with critical policies (<80% capacity)
[ ] API_SERVER_KEY rotated; bind loopback unless behind TLS proxy
[ ] Copilot UI authenticated (SSO); no Hermes keys in browser
[ ] Private notes tested (private: true not visible to customer)
[ ] Golden ticket eval set + baseline scores
[ ] Trajectory/PII redaction policy documented
[ ] Escalation SLA owned by support lead

Modos de falla comunes

En conclusión

Un copiloto de soporte es una capa de asistencia gobernada, no un bot de atención al cliente con otra apariencia. Hermes encaja cuando necesitas sesiones, skills, herramientas con alcance delimitado y aprendizaje auditable, con personas siempre responsables de los mensajes salientes.

La Parte 2 conectó el canal de atención al cliente. La Parte 4 es donde las políticas de producto, la calidad de las evaluaciones y la responsabilidad operativa se encuentran con el harness. Primero define bien el perfil, el toolset y el contrato de AGENTS.md; el bridge es la parte fácil.

Fuentes

Fuentes primarias consultadas el 3 de julio de 2026:

1. Hermes Agent — Arquitectura — subsistemas del harness, núcleo independiente de la plataforma. hermes-agent.nousresearch.com/docs/developer-guide/architecture
2. Hermes Agent — Ensamblaje de prompts — AGENTS.md, prompts por niveles. hermes-agent.nousresearch.com/docs/developer-guide/prompt-assembly
3. Hermes Agent — Memoria persistente — memoria acotada, write_approval, revisión en segundo plano. hermes-agent.nousresearch.com/docs/user-guide/features/memory
4. Hermes Agent — Sistema de skills — divulgación progresiva, /learn, aprobación de escritura. hermes-agent.nousresearch.com/docs/user-guide/features/skills
5. Hermes Agent — Servidor API — Responses API, Sessions API, Runs API, X-Hermes-Session-Key. hermes-agent.nousresearch.com/docs/user-guide/features/api-server
6. Hermes Agent — Referencia de toolsets — safe, valores predeterminados de plataforma, toolsets personalizados. hermes-agent.nousresearch.com/docs/reference/toolsets-reference
7. Hermes Agent — Perfiles — configuración, memoria y sesiones aisladas. hermes-agent.nousresearch.com/docs/user-guide/profiles
8. Hermes Agent — Comandos de perfil — hermes profile create, support-copilot gateway. hermes-agent.nousresearch.com/docs/reference/profile-commands
9. Hermes Agent — Formato de trayectorias — exportaciones para evaluación. hermes-agent.nousresearch.com/docs/developer-guide/trajectory-format
10. Hermes Agent — Procesamiento por lotes — suites de escenarios. hermes-agent.nousresearch.com/docs/user-guide/features/batch-processing
11. Hermes Agent — Skill opcional qmd — búsqueda híbrida de documentos. hermes-agent.nousresearch.com/docs/user-guide/skills/optional/research/research-qmd
12. Chatwoot — Bots de agente — contraste con conversaciones gestionadas por personas. chatwoot.com/hc/user-guide/articles/1677497472-how-to-use-agent-bots
13. Documentación para desarrolladores de Chatwoot — Crear un mensaje nuevo — notas con private: true. developers.chatwoot.com/api-reference/messages/create-new-message
14. Documentación para desarrolladores de Chatwoot — Cambiar estado — transferencia por escalamiento. developers.chatwoot.com/api-reference/conversations/toggle-status
15. Nous Research — Hermes Agent en GitHub — perfiles, servidor API, toolsets. github.com/NousResearch/hermes-agent

Serie y artículos relacionados:

16. Parte 1: Arquitectura de Hermes Agent y lecciones de RAG
17. Parte 2: Agente de WhatsApp con Cloud API, Chatwoot, Hermes y OpenAI
18. Parte 3: Trabajos cron de Hermes para operaciones de agentes
19. Aplicaciones RAG en la práctica
20. Agentes con estado vs. sin estado en producción
21. Evaluación de agentes de IA con LangWatch
22. Cómo revisar respuestas generadas por IA