← /posts

Engineering

Tu agente sabe que tu MCP falla. ¿Le has dado forma de decírtelo?

Un MCP le da tu producto a un agente. El agente es también el primero en ver dónde falla tu producto, y si tu MCP no tiene una tool para decirlo, ese fallo muere con el chat. Le dimos al nuestro dos tools para eso, y montamos el camino de un report hasta una pull request.

Autor
Nacho González
Publicado
1 nov 2026
Lectura
7 min

Quien ve el bug no es quien lo reporta

Alguien le pregunta a Claude o a ChatGPT algo de su empresa. Gurusup responde mal, o no responde. Lo que pasa después, casi siempre, es nada. Reformula, se rinde o se lo pregunta a un compañero. Cuando llega un mensaje a soporte, dice algo como "no lo encontró".

El agente que está en medio vio mucho más. Sabe qué tool llamó y con qué argumentos, qué le devolvió, el error exacto si lo hubo y qué dijo el usuario que debería estar ahí. Es justo lo que necesita un ingeniero para reproducir el problema, y desaparece al cerrar el chat.

Así que dejamos de preguntarnos cómo conseguir que la gente reporte más, y empezamos a preguntarnos por qué el report dependía de ella. Un MCP le da a un agente los botones de tu producto. Sin una tool para decir que un botón está roto, o que le faltó uno que no tienes, tiras a la basura al mejor tester que tienes.

Dos tools, porque son dos preguntas distintas

El MCP de Gurusup tiene dos tools para esto. report_issue es para un fallo que el agente puede señalar. send_feedback es para cuando nada falló pero algo habría ayudado. Las separamos porque van a sitios distintos: un fallo es un bug y va a ingeniería; una capacidad que falta es una señal de producto y compite con todo lo demás del roadmap.

DOS TOOLS, DOS PREGUNTASel agente acabao se atasca¿ha falladoalgo?sínoreport_issue4 categoríassend_feedbackorigin · blockedse lo dice alusuario en una líneaun fallo y una capacidad que falta van por caminos distintos

Estos son los argumentos de cada una:

report_issue(
  category,        # missing_information | wrong_answer | tool_error | access_problem
  observed,        # qué pasó
  expected,        # qué debería haber pasado
  activity_id,     # el id que devolvió Gurusup en la llamada que falló
  tool_name, user_request, error_message,
)

send_feedback(
  summary,
  origin,          # user | agent
  blocked,         # ¿se pudo acabar la tarea sin ello?
  context, activity_id,
)

Las cuatro categorías llevan a cuatro arreglos distintos. missing_information significa que el usuario dice que algo existe y la búsqueda no lo devolvió, normalmente un problema de fuente o de indexado. wrong_answer, que la respuesta contradice su propia evidencia. tool_error es un error sin más. access_problem es un permiso que bloqueó algo que no debía.

En send_feedback, el campo que miramos primero es blocked. Una capacidad que le faltó al agente pero con la que acabó la tarea es un nice-to-have. Una sin la que no pudo acabar se parece más a un bug.

Reportar sin pedir permiso

El comportamiento está en el contrato que Gurusup devuelve en init, la primera llamada de cualquier agente:

If Brain fails you (a tool error, or the user says something exists and it is not returned), call report_issue once without asking and tell the user in one line. If a capability you needed was missing, call send_feedback once at the end of the task.

Lo de "sin pedir permiso" fue la decisión que más nos costó. Pedir permiso cada vez añade un paso a alguien que ya está molesto, y esperábamos que la mayoría dijera que no o lo ignorara. No decírselo sería un comportamiento oculto, en un producto cuyo trabajo es tratar el conocimiento de la empresa con cuidado. Así que el agente lo hace y luego lo dice en una línea. El usuario ve que ha pasado y no tiene que hacer nada.

El control del ruido está escrito en las descripciones de las tools. Reportar una vez. Reportar cuando el fallo está confirmado, no a la primera sospecha. Mandar feedback una vez, al final de la tarea y todo junto. Y hay dos cosas excluidas a propósito: un dato equivocado sobre la empresa (lo que está mal es el conocimiento, no Brain, y eso tiene su propio camino de curación) y el contexto denegado (un permiso haciendo su trabajo no es un bug).

Todo esto son instrucciones. Un modelo puede ignorarlas, reportar dos veces o no reportar. Preferimos saber cuántas veces pasa que fingir que la descripción de una tool lo asegura.

Qué viaja con un report y qué no

Lo tentador es adjuntarlo todo: la pregunta, la respuesta y la evidencia que devolvió Gurusup. En un producto montado sobre acceso con permisos, eso convierte cada report en una puerta trasera. Un report escrito por el agente de una persona llevaría contenido a un sitio con otros permisos.

Así que el backend solo adjunta ids. Cuando llega un report con activity_id, busca esa actividad en el Audit Trail de quien llama y añade los ids de los eventos de auditoría, los de las trazas que sirvieron esas llamadas y los de los documentos y fragmentos devueltos. El contenido se queda en el Audit Trail, detrás de la misma autorización que cualquier otra lectura.

QUÉ VIAJA CON UN REPORTreportobserved · expectedactivity_idbackendune por idAudit Trailpregunta, respuestay evidencia se quedan aquísolo idsmcp_issue_reportedaudit_event_idsorigin_trace_idsreturned_document_idsreturned_chunk_idsevento de Logfirealertasolo el númeroel report apunta a la evidencia, nunca la lleva

Esto solo funciona si el agente pasa el activity_id. Un report sin él sigue contando qué pasó, pero nadie puede llegar a la traza sin buscar a mano.

Dónde viven los reports, de momento

Los reports no tienen tabla. Cada uno es un evento de Logfire, mcp_issue_reported o mcp_feedback_sent, con los 30 días de retención de Logfire. El código lo dice tal cual:

# ponytail: reports live only in Logfire (30-day retention); move to a table
# once they need status, long history, or a customer-facing view.

Una tabla te obliga a elegir esquema, flujo de estados y política de retención antes de haber visto un solo report real. No sabíamos qué campos iban a importar. Logfire ya guardaba las trazas a las que apuntan los reports, así que el report queda al lado de su evidencia sin coste extra.

Dos alertas de Logfire miran cada cinco minutos si hay eventos nuevos y avisan en Slack. Solo mandan el número, nunca el texto. El canal de Slack lo lee más gente de la que puede ver las trazas.

De una alerta de Logfire a una pull request

Un número en Slack sigue necesitando que alguien abra Logfire, lea el report y escriba la issue. Ese es el paso que automatizamos.

DE UN REPORT A UNA PULL REQUESTel agenteda con un falloreport_issuetool MCPLogfireevento + idsalertacada 5 minnuestro agentelee el códigoissueen LinearHermesprepara una PRpullrequestuna personarevisael fix llegaa todos los clientesninguna persona escribe la issue; una persona decide qué sale

Cuando salta la alerta, un agente de Gurusup la recoge. Lee el report, mira el código implicado y analiza el error contra él. Después escribe la issue en Linear. Quien la lee no parte de "el usuario dice que no lo encontró": parte de un fallo, del sitio del código donde ocurre y de una causa probable.

Luego la issue se asigna a Hermes, el agente open source de Nous Research que usamos para coordinar Linear, GitHub y Codex y preparar pull requests. Ya es el camino de otras issues en nuestro proceso de desarrollo. Un report pasa a ser una entrada más.

Sigue habiendo una persona en el circuito, solo que más tarde. Nadie escribe ya la issue, pero alguien revisa la pull request y puede tirarla. Por lo que llevamos visto, Hermes funciona mejor con issues pequeñas y bien definidas, y eso es lo que sale de un buen report: un fallo, una traza, un sitio en el código.

Cómo montarlo en tu propio servidor MCP

Nada de esto es exclusivo de Gurusup. Si tienes un servidor MCP, los agentes que lo usan ya ven tus fallos antes que tú. Esto es lo que mantendríamos si lo hiciéramos otra vez:

  • Dos tools: un fallo y una capacidad que falta piden un triaje distinto. Una tool genérica de feedback mezcla bugs con deseos, y acabas leyéndolo todo a mano para separarlos.
  • Pon el disparador en las instrucciones del servidor: la descripción de una tool dice qué hace; no hace que el modelo piense en llamarla. Las instrucciones que el cliente lee al empezar son el sitio para decir cuándo reportar, que no pregunte antes y que se lo diga al usuario.
  • Devuelve un id en cada llamada y pídelo de vuelta: sin él, un report es una anécdota. Con él, apunta a la llamada exacta, su traza y lo que devolvió.
  • Resuelve los ids en el servidor, contra la actividad de quien llama: el agente manda el id y el servidor añade el resto. El report nunca lleva contenido que quien lo lee no pudiera ver de todas formas.
  • Escribe las reglas contra el ruido en las descripciones: una vez por fallo, solo cuando está confirmado, el feedback todo junto al final. Y di qué no es un report: los casos en que el sistema hizo lo que tenía que hacer.
  • Guarda los reports junto a tus trazas antes de montar una tabla: los reports reales te dirán qué campos importan.
  • Mide si los agentes lo siguen: cuántos reports llegan con el id es la señal más barata de si tus instrucciones funcionan.

Un punto de partida para las instrucciones, para adaptar a tus tools:

If a tool fails you (an error, or the user says something exists and it was
not returned), call report_issue once, without asking, with the id the failing
call returned. Tell the user in one line that you reported it.

If a capability you needed was missing, call send_feedback once at the end of
the task, combining everything. Say whether you could finish without it.

Do not report results that are wrong because the data is wrong, or access
that was denied on purpose.
Va en inglés: es texto para el modelo, como el contrato de Gurusup.

Lo que no hemos resuelto

  • Un agente puede culpar a la tool de su propio error. Una consulta mal construida que no devuelve nada se parece mucho a missing_information vista desde el agente.
  • Duplicados. Diez usuarios con el mismo fallo mandan diez reports, y la alerta cuenta los diez.
  • Reports que llegan sin activity_id. La instrucción está. Algunos agentes no la siguen.
  • Treinta días. Vale para lo que acaba en Linear, pero un report que no se convierte en issue desaparece al mes.
  • Qué reports van a Hermes y cuáles a una persona sigue siendo criterio. Esa regla no la hemos escrito.

Antes, reportar dependía de que el usuario estuviera lo bastante molesto como para escribirnos. Ahora depende de que el agente siga una instrucción. Es otra forma de no ser fiable, pero esta la podemos medir.

guest@gurusup > /posts

guest@gurusup > /install · conecta Gurusup Brain a tus agentes

Empieza - gratis