← /posts

Ingeniería

Nadie va a abrir tu dashboard

Cómo rehicimos Gurusup para que lo uses entero desde tu propio Claude o ChatGPT, y adónde fueron las decisiones de producto que antes vivían en nuestras pantallas.

Autor
Nacho González
Publicado
22 oct 2026
Lectura
11 min

Las interfaces han cambiado, y Gergely Orosz no es el único que lo dice. El mismo día de este octubre, Theo (t3.gg) escribió: "If I have to go to a dashboard to use your product, I'm not going to use your product." Y Ben Hylak escribió que todo producto que usa debería ser un MCP sin interfaz que alimente a su agente, "except for our product, of course. In our product, customers love the UI."

Lo de Ben es una broma, y es la parte honesta. Muchos equipos están de acuerdo con Theo y, en silencio, actúan como Ben. Nosotros teníamos una web app con su flujo de alta y un montón de pantallas, y estábamos a punto de hacer la misma excepción.

Entonces nos preguntamos por qué nos pagan de verdad. Por el servicio: una memoria de la empresa que se mantiene al día, y agentes que hacen trabajo real con ella. Las pantallas son una forma de llegar a eso, y gente como Theo no la elegiría. Así que el producto tiene que funcionar donde ya están.

Fuimos por el otro lado. En Gurusup, las operaciones que hay detrás de la web app, 147 a día de hoy, se pueden llamar desde tu propio Claude o ChatGPT, desde conectar fuentes hasta encender agentes. La web app sigue ahí. Solo que no tienes que ir a ella.

Un poco de vocabulario antes de empezar. Las fuentes son las herramientas de las que leemos, como Slack, Drive o Linear. La memoria es lo que construimos a partir de ellas. Las skills son procedimientos escritos. Los agentes usan la memoria y ejecutan skills, cuando se lo pides o con un horario; una tarea programada es un job.

La interfaz era donde guardábamos nuestro criterio

Una interfaz también es donde un equipo de producto guarda su criterio: el orden de los pasos del alta, qué opción viene marcada por defecto, el aviso antes de algo arriesgado, el botón que no está porque no queríamos que lo pulsaras.

Quita las pantallas y ese criterio necesita otro sitio. Lo primero que se nos ocurrió fue meterlo en las instrucciones del asistente, como una lista larga de "haz siempre esto, nunca hagas aquello". El asistente se volvió rígido. Y una regla en un prompt sigue siendo una sugerencia: nada impide que un modelo se la salte en un mal día.

Así que lo partimos en dos, y volvimos a esa separación durante todo el proyecto:

  • Las salvaguardas van en código: lo que no debe pasar lo impone el servidor, decida lo que decida el asistente.
  • El contexto va en prosa: todo lo demás se explica, para qué sirve Gurusup y qué supone cada decisión para la persona.

La arquitectura

ARQUITECTURA MCP-FIRSTtu asistenteClaude · ChatGPTMCP de Gurusup/mcp: 4 tools/mcp/directory: una cada unaweb appAPIslas mismas que la web+ las salvaguardasmemoriaagentesenlacepágina de conexiónclaves · OAuthlas claves y autorizaciones nunca pasan por el chat

Hay cuatro piezas:

  • El asistente de la persona: Claude o ChatGPT, con todo lo que ya sabe de ella, sus conectores, su memoria y sus skills.
  • Nuestro servidor MCP: identifica a la persona con OAuth, describe qué se puede hacer y da formato a las respuestas para el asistente. No tiene reglas de negocio propias.
  • Las APIs: las mismas que usa la web app, la del producto y la del harness de agentes, con los mismos permisos. Todas las salvaguardas viven aquí, así que valen igual si la petición llega desde una pantalla o desde un chat.
  • Unas pocas páginas web: solo para los pasos que nunca deberían ocurrir dentro de un chat, como meter una API key o autorizar una cuenta.

Esa tercera pieza es la decisión que volveríamos a tomar. El servidor MCP es un cliente más de las mismas APIs. Si cambiamos qué ediciones obligan a revisar otra vez un job, lo cambiamos una vez en el harness y la web app, el MCP y nuestros agentes internos lo siguen. Una CLI mañana necesitaría su propia experiencia y su propio login, y nada más.

Un catálogo en vez de cien tools

La forma obvia de exponer 147 operaciones es con 147 tools. Cada capacidad nueva se convierte en una entrada más de la lista que el asistente carga antes de hacer nada, y esa lista solo crece.

Así que el endpoint principal, /mcp, añade cuatro tools genéricas junto a las de siempre: learn explica cómo hacer un flujo, discover encuentra operaciones y devuelve su contrato, query ejecuta lecturas y execute ejecuta cambios. El catálogo entero se queda en el servidor y el asistente trae la parte que necesita:

DE 147 OPERACIONES A UNA LLAMADA147 operacionesen el servidordiscover()≤ 20 resúmenesdiscover(search)≤ 20 coincidenciasdiscover(operation)un contratoquery · executela llamadafiltrado por rol en cada paso; la API vuelve a comprobar al ejecutar

Una búsqueda devuelve hasta 20 resúmenes y un indicador has_more, ya filtrados por el rol de quien llama. Solo cuando el asistente pide una operación concreta recibe el esquema completo de sus argumentos y su respuesta. Filtrar por rol solo decide lo que ve el asistente. La API vuelve a comprobar los permisos cuando la llamada se ejecuta.

La diferencia se nota antes de la primera llamada:

LO QUE CARGA EL ASISTENTE ANTES DE SU PRIMERA LLAMADAlearn · discover · query · execute≈ 3.2 KB/mcp, las 21 tools≈ 25 KB/mcp/directory, 165 tools≈ 213 KBtamaño del listado de tools en JSON, no tokens; medido en local como admin

Esas cifras son tamaños en JSON; cuántos tokens cuestan depende del cliente. El fichero del catálogo tiene cerca de 40.000 líneas y nunca sale del servidor. Esto baja lo que el asistente carga de entrada; no promete menos tokens en cada tarea, porque una conversación guarda los contratos que consulta. A veces discover cuesta un paso más. Creemos que un punto de partida más pequeño lo compensa.

De dónde sale el catálogo

Nadie escribe el catálogo a mano. FastAPI ya saca los esquemas de entrada y salida de nuestros modelos Pydantic, así que lo único que añadimos a una ruta es una línea que dice que se expone:

@router.post(
    "/v1/agents/{agent_id}/jobs",
    response_model=JobView,
    status_code=201,
    openapi_extra={
        "x-brain-operation": {
            "name": "jobs.create",
            "effect": "write",
        }
    },
)
async def create_job(agent_id, payload: JobDefinition, actor, store, idempotency_key):
    return await store.create(actor, agent_id, payload, idempotency_key)
La ruta que crea un job. Los argumentos salen de JobDefinition y la respuesta de JobView.
DE DÓNDE SALE EL CATÁLOGOruta de la APIx-brain-operationOpenAPIapp + harnessmakemcp-catalogoperation_catalog.json/mcpdiscover · query · execute/mcp/directoryuna tool cada unaCI y deploy fallan si no coincidelas rutas sin marcar se quedan fuera

make mcp-catalog exporta OpenAPI desde el código, sin levantar servidores ni bases de datos, y escribe el catálogo. Se commitea junto al cambio de API. CI y los scripts de deploy ejecutan make check-mcp-catalog y fallan si alguien cambió un contrato y se olvidó de regenerarlo; nunca lo reescriben por su cuenta.

La exposición es explícita. Una ruta sin la marca se queda fuera, y así mantenemos lo que solo tiene sentido en la web app o en procesos internos. Una operación también se puede limitar a ciertos roles.

Un catálogo, dos formas

Las guías de apps de ChatGPT no permiten una tool genérica de "ejecuta cualquier operación". Por eso hay un segundo endpoint, /mcp/directory, que lee el mismo catálogo y anuncia cada operación como su propia tool (jobs.defaults pasa a ser jobs_defaults), cada una con su descripción y sus anotaciones readOnlyHint / destructiveHint.

La URL decide la forma. Cualquier cliente puede usar cualquiera de los dos, y los dos pasan por el mismo adaptador de ejecución, así que no hay una segunda copia de los contratos ni de las reglas. Nuestros tests ejecutan las mismas operaciones por los dos endpoints.

Tomamos ideas de OpenArtifact, de Samuel Colvin, que comparte tools MCP entre su propio agente y clientes externos, y de los servidores MCP de WorkOS y PostHog.

Una petición, de punta a punta

Este recorrido está hecho con llamadas reales de nuestros tests de punta a punta, con los ids cambiados y las respuestas recortadas. Alguien le pide a su asistente un resumen de producto cada lunes a las 9:

UNA PETICIÓN, DE PUNTA A PUNTA«un resumen de producto cada lunes a las 9»asistenteMCP + APIs de Gurusuplearn(topic="agents")cómo funcionan agentes y jobsdiscover(operation="jobs.create")argumentos y respuestaquery("jobs.defaults")timezone: "Europe/Madrid"execute("jobs.create", request_id)job creado: en pausa, revisión pendientequery("jobs.get")configuración y estado guardados

La llamada que lo crea tiene esta forma:

{
  "name": "execute",
  "arguments": {
    "operation": "jobs.create",
    "request_id": "weekly-product-summary",
    "arguments": {
      "agent_id": "AGENT_ID",
      "body": {
        "name": "Weekly product summary",
        "instructions": "Write a short product summary with the sources you used.",
        "schedule_kind": "calendar",
        "calendar_days": [1],
        "calendar_hour": 9,
        "calendar_minute": 0,
        "timezone": "Europe/Madrid"
      }
    }
  }
}

El harness creó el job en pausa y con una prueba revisada pendiente. El MCP pasó esa decisión tal cual; no añadió una política de aprobación propia. Crear el job no enciende su horario: todavía hay que ejecutar la prueba y revisarla. Tampoco todas las tareas necesitan las cuatro tools. Si el asistente ya conoce el procedimiento y el contrato, los reutiliza.

Contexto: lo primero que lee el asistente

Cada sesión empieza con init. Es corto a propósito: unas frases sobre para qué sirve Gurusup, por dónde empezar y dónde están los límites, más un checklist calculado con el estado real de la organización. También dice, con todas las letras, que "a queued request or a complete setup checklist is not authorization to activate work".

Las indicaciones más largas viven en cuatro playbooks, empezar, conocimiento, agentes y organización, que el asistente carga con learn cuando los necesita. Los escribimos como le explicaríamos el trabajo a un compañero nuevo el primer día: para qué sirve el producto, haz una propuesta a la que la persona pueda reaccionar, explica las consecuencias antes de actuar.

La parte de para qué sirve el producto llegó tarde, y cambió el comportamiento más que cualquier regla. Un asistente que entiende el propósito toma decisiones razonables en situaciones que nadie dejó escritas.

Con el checklist, el asistente nunca tiene que acordarse de dónde lo dejó. Conectar fuentes y construir la memoria son lo esencial; skills, agentes y apps son opcionales, así que usar solo la memoria ya es un alta completa. En cuanto existe un agente, pasa a ser obligatorio tener uno probado.

El flujo de alta

ALTA MCP-FIRSTinitguía + checklistmirar antesde preguntarunapropuestafuentes, históricobuild de memoriaredactar skillsproponer agentes+ su accesoprobar · revisaractivartras una propuesta, tres líneas en paralelo

Nuestro asistente de alta en la web hace las mismas preguntas a todo el mundo. Tu asistente quizá ya esté conectado a tu email, tu calendario y tu gestor de issues, y quizá sepa cómo escribes. Así que se puede saltar casi todas las preguntas:

  • Empezar: el asistente llama a init y recibe la guía y el checklist.
  • Mirar antes de preguntar: usa lo que ya sabe de cómo trabaja la persona, y solo pregunta lo que no puede deducir.
  • Una propuesta completa: fuentes que conectar para que la memoria esté al día, agentes que le quitarían trabajo y los jobs que harían esos agentes. La persona acepta, cambia o se lo salta.

Tras la propuesta, corren tres líneas en paralelo:

  • Fuentes y memoria: la persona conecta cada fuente en nuestra página, abierta desde el chat. En las fuentes que lo permiten, entran por defecto los últimos 30 días de histórico, hasta 100.000 tokens por organización entre todas esas importaciones automáticas. Más adelante se puede importar más de forma explícita. Cuando el histórico llega así, el primer build de la memoria arranca solo.
  • Skills: redacta skills a partir de los procesos reales de la persona.
  • Agentes: propone agentes, incluido qué conocimiento puede ver cada uno.

Las líneas se juntan al final: cada job de agente ejecuta una prueba, la persona la revisa y solo entonces se puede encender.

Salvaguardas: lo que impone el servidor

Los jobs nacen en pausa

CICLO DE VIDA DE UN JOBcreadoen pausapruebarevisadoesta versióncontrol del servidoractivojob editado: necesita otra revisión

Un job creado desde un chat nace en pausa y marcado como pendiente de una prueba revisada. La revisión va ligada a la versión del comportamiento del job: si cambias su horario, sus instrucciones o su destino, o las apps o skills del agente, necesita otra revisión. Cambiarle el nombre no. Si intentas reanudar un job sin prueba revisada, el servidor lo rechaza.

Otras salvaguardas

  • Los reintentos no duplican trabajo: los asistentes reintentan. execute recibe un request_id, y las operaciones que arrancan trabajo, como crear un job, ejecutarlo ahora o escribir a un agente, lo usan como clave de idempotencia, así que un reintento no las ejecuta dos veces.
  • Los permisos de los agentes son cosa de admins: qué conocimiento puede ver un agente es lo primero que cubre el playbook de agentes, y solo un admin puede cambiarlo. Un agente con horario sigue usando ese acceso cuando nadie mira, así que ampliarlo es una decisión de la organización.
  • La privacidad se decide al conectar: una fuente puede ser solo tuya, compartida con personas concretas o abierta a toda la organización. Las apps se pueden conectar para ti o para la organización, y con más de una cuenta.

Las claves nunca pasan por el chat. Si el cliente lo permite, el asistente abre nuestra página directamente; si no, manda un enlace. Un enlace desde un chat trae un problema nuevo: cualquiera que lo reciba podría abrirlo. Así que cada uno va firmado y caduca a los 30 minutos. La firma cubre la petición que lo creó, la organización y la persona, y nuestra página comprueba que quien tiene la sesión abierta es quien lo pidió antes de enseñar nada.

Depurar un agente sin abrir la caja

Si la gente maneja sus agentes desde su asistente, también los va a depurar desde ahí. "¿Por qué ha contestado eso mi agente?" necesita una respuesta de verdad.

El asistente puede leer la traza de cualquier ejecución: los pasos, los documentos citados, las apps llamadas en nombre de la persona y dónde se paró el agente a preguntar a alguien. Lo que no recibe son nuestras tripas: prompts, skills internas, qué modelo lo ejecutó o nuestra infraestructura.

La traza se construye con una lista de permitidos: cada campo que aparece se eligió a propósito, así que lo que añadamos por dentro más adelante queda privado por defecto. Los campos que parecen secretos se descartan, y una ejecución fallida da uno de siete motivos fijos.

Cómo lo probamos

Los asistentes son muy buenos diciendo que han hecho algo. Así que la prueba del flujo completo nunca se lo pregunta.

Los tests unitarios cubren las salvaguardas. Para el flujo montamos una eval de punta a punta:

  • Un modelo hace de asistente, a través de un cliente al estilo de ChatGPT conectado a nuestro servidor MCP y nuestras APIs reales en local. Conectar una fuente está simulado; todo lo que viene después es real.
  • Otro modelo hace de founder que no sabe nada de cómo está hecho y pide las cosas con palabras normales.
  • El veredicto sale del estado de la organización leído desde la API: una fuente conectada, un build de memoria pedido, una skill aprobada y un agente con una prueba revisada y su activación pedida.
  • Falla si el founder necesita más de seis intervenciones, o si la primera revisión tarda más de diez minutos. También puntúa de 0 a 5 cuánto se parece el borrador del agente a cómo escribe el founder.

Antes de darlo por hecho, también lo recorrimos entero a mano con un email nuevo, una vez en Claude Code y otra en ChatGPT.

Lo que no hemos resuelto

  • Avisarte cuando acaba un trabajo largo: construir la memoria lleva minutos. Hoy el asistente vuelve a mirar, y a veces espera a que le digas "mira otra vez". ElevenLabs, Emergent y Chatbase, los productos MCP-first que miramos, tampoco avisan. La extensión Tasks de la próxima revisión de MCP debería ayudar.
  • Los contratos se acumulan: discover mantiene pequeña la lista de partida, pero cada contrato que consulta el asistente se queda en la conversación. En una sesión larga, eso suma.
  • Agentes que trabajan solos: un agente que lee entradas de las que no se fía, puede ver datos privados y puede enviar cosas fuera de la empresa es lo que Simon Willison llama la tríada letal. Una prueba revisada no lo hace seguro sin una persona mirando. Todavía no hemos decidido qué lo hace.
  • Demostrar que es más rápido con gente real: el listón de la eval es diez minutos hasta la primera revisión. Publicaremos un número cuando lo hayamos medido con personas reales.

Volviendo a la broma

El post de Ben funciona porque muchos equipos creen que su interfaz es la excepción. La nuestra podría haberlo sido. Pero cuanto más de Gurusup hicimos usable desde el asistente de otro, más claro quedó dónde está lo que nos diferencia: la memoria, los agentes y las reglas que los mantienen seguros. La interfaz que tienen delante es la parte que nos podemos permitir soltar.

Úsalo desde nuestra web app, desde Claude, desde ChatGPT o desde lo que uses el año que viene. Seguimos manteniendo la web app. Solo hemos dejado de diseñar el producto alrededor de ella.

guest@gurusup > /posts

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

Empieza - gratis