# Cómo funciona

> El camino desde un clic en tu aplicación hasta una frase en tu correo, las partes que intervienen y qué tan reciente es cada tipo de información.

Aplica a: el motor de Sypnia (código abierto, en tu propia infraestructura) y Sypnia Cloud (servicio pago). Estado: al lanzar.  
Fuente: https://docs.sypnia.com/es/start/how-it-works/

Esta página es para quien quiere saber qué hace Sypnia con los datos de su aplicación antes de instalarlo. El camino es el mismo en el motor de código abierto y en Sypnia Cloud, porque la nube corre el mismo motor. Las diferencias están en las dos puntas: quién entra y cómo te llega el resultado.

**Figura**: De tu aplicación a ti y a tu agente de código. Todo lo que está dentro del recuadro es el motor de código abierto.

## Los cinco pasos

### 1. Tu aplicación reporta lo que pasa

Instalas un SDK, o apuntas un exportador de OpenTelemetry a Sypnia. Desde ahí tu aplicación envía eventos: un error, un clic, una página que cargó, una solicitud a tu API y cuánto tardó. El SDK del navegador también graba la sesión para poder reproducirla, con lo que la persona escribe y los campos sensibles enmascarados antes de que algo salga del navegador.

El SDK del navegador envía los eventos en lotes pequeños, cada 10 segundos o apenas hay 50 esperando, y cuando la página se oculta o se cierra. Tu aplicación se identifica con una llave de ingesta, que empieza por `spk_`. Es pública y solo puede escribir.

Más: [Eventos](https://docs.sypnia.com/es/concepts/events), [Qué se recoge](https://docs.sypnia.com/es/privacy/what-is-collected).

### 2. La ingesta recibe y revisa

La ingesta es la puerta. Revisa que la llave de ingesta sea de un proyecto, que cada evento tenga una forma y un tamaño válidos, y que el proyecto esté dentro de su cuota. Después escribe los eventos en el almacenamiento, y solo entonces responde: la respuesta espera hasta 2 segundos, para que los eventos de varios navegadores se escriban juntos en un solo objeto. No analiza nada, y por eso es barata.

Si la ingesta rechaza algo, responde con el motivo, y Sypnia cuenta lo que rechazó para que lo veas después. Nada se descarta en silencio. Mira [Planes y límites](https://docs.sypnia.com/es/cloud/plans-and-limits).

### 3. El almacenamiento guarda lo crudo a bajo costo

Los eventos crudos, las grabaciones, las capturas de página y los source maps van a un bucket compatible con S3. Los resultados van a una base de datos Postgres: cifras por hora y por día, el índice de sesiones, los problemas y la configuración. Los eventos crudos nunca entran a Postgres. No hace falta ningún otro servicio.

Cada fila y cada objeto llevan su proyecto. Nada se comparte entre proyectos.

### 4. El motor convierte los eventos en respuestas

El motor lee lo que llegó y hace cuatro cosas. No necesita otro servicio de consultas: lee los objetos crudos él mismo.

1. **Agrupa las fallas en problemas.** Las fallas con la misma causa se vuelven un solo problema, con la gente a la que afectó. Este es el camino rápido: lee lo nuevo cada 30 segundos y solo busca fallas, así que un problema nuevo aparece dentro de los 2 minutos siguientes a su primer evento.
2. **Arma cada sesión**: sus páginas, clics, errores y solicitudes, en orden, con su grabación.
3. **Traduce los stack traces** de vuelta a tu código fuente, con los source maps que subiste.
4. **Actualiza las cifras**: velocidad de las páginas, velocidad y fallas de la API, clics, personas y cuentas. Esta pasada más lenta, la consolidación, corre cada 5 minutos. Las cifras están completas dentro de 10 minutos, y después se guardan como totales por hora y por día para que los periodos largos sigan siendo baratos de leer.

Procesar dos veces los mismos datos da el mismo resultado, así que un paso que falló se vuelve a correr sin contar nada dos veces.

Más: [Problemas](https://docs.sypnia.com/es/concepts/problems), [Rendimiento](https://docs.sypnia.com/es/concepts/performance), [Versiones y source maps](https://docs.sypnia.com/es/concepts/releases-and-source-maps).

### 5. El agente escribe la frase, y te avisan

Cuando un problema es nuevo, vuelve o crece, el agente lo lee: la falla agrupada, el stack con las líneas del código fuente, lo que la persona hizo justo antes, la traza, la versión y qué cambió, y a cuántas personas y sesiones afectó. Escribe una frase en palabras claras, a quién afectó, desde cuándo, la causa probable con su evidencia, qué hacer, un nivel de confianza y un prompt para tu agente de código.

El agente nunca lee los píxeles de una grabación ni lo que la gente escribe, y nunca mezcla código. [Cómo funciona el análisis](https://docs.sypnia.com/es/agent/how-the-analysis-works) lista todo lo que lee y lo que escribe.

Después el problema te llega a ti y a tu agente de código:

|                             | Motor de Sypnia (código abierto, en tu propia infraestructura)                                                                    | Sypnia Cloud (servicio pago, con un plan gratis)                                                   |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| Te avisan                   | La alerta queda registrada, se ve en la Consola, está disponible por la API y por MCP, y se envía a un webhook si configuras uno. | Un correo y una alerta dentro de la aplicación. Todo lo demás espera al correo del resumen diario. |
| Lo lees                     | La Consola (lista de problemas y visor de grabaciones), la API, la CLI o tu agente de código por MCP.                             | La aplicación completa, más la API y el servidor MCP remoto.                                       |
| Tu agente de código recibe  | El prompt y el servidor MCP.                                                                                                      | El prompt, el servidor MCP y un pull request abierto por la GitHub App de Sypnia.                  |
| El modelo detrás del agente | Tu propia llave, por OpenRouter o por cualquier endpoint compatible con OpenAI. Apagado hasta que pongas una.                     | Incluido. Sypnia Cloud llega a los modelos por OpenRouter.                                         |

Qué modelo se usa, y qué se le envía exactamente, está en [Modelos y qué se envía](https://docs.sypnia.com/es/agent/models-and-what-is-sent). Para enviar las alertas por correo desde tu propio motor, mira [Enviar alertas por correo desde un motor en alojamiento propio](https://docs.sypnia.com/es/guides/alert-emails-self-hosted).

## Qué tan reciente es cada cosa

Esta tabla es una promesa que el motor debe cumplir, en tu propia infraestructura y en Sypnia Cloud.

| Qué                                                   | Cuándo lo ves                                                                                                                                                |
| ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| La ingesta recibió tus eventos                        | Unos 2 segundos después de enviarlos, como mucho. La respuesta llega cuando los eventos ya están escritos en el almacenamiento, y dice cuántos se guardaron. |
| Un problema nuevo                                     | Dentro de los 2 minutos siguientes a su primer evento.                                                                                                       |
| La alerta de un problema nuevo                        | Dentro de esos mismos 2 minutos. Lleva la frase en palabras claras si el agente ya terminó, y el título técnico si no.                                       |
| La frase en palabras claras                           | Cuando el agente termina, normalmente dentro de esos mismos 2 minutos. Nunca, si el agente está apagado.                                                     |
| Conteos, cifras de rendimiento y la lista de sesiones | Completos dentro de 10 minutos.                                                                                                                              |
| Una grabación                                         | Se puede ver cuando su sesión lleva 2 minutos sin actividad, o ya terminó.                                                                                   |
| Una alerta de disponibilidad                          | Después de dos verificaciones fallidas seguidas. Mira [Disponibilidad](https://docs.sypnia.com/es/concepts/uptime).                                          |
| El resumen diario **\[Nube]**                         | Una vez al día, por la mañana, sobre el día anterior.                                                                                                        |

## La misma historia, paso a paso

1. Un cliente hace clic en **Pagar** en tu tienda. El SDK del navegador registra el clic y la solicitud `POST /api/checkout`, y le pasa un id de traza a tu API.
2. Tu API llama a `createPayment()` sin monto, y el servicio de pagos responde 400. El SDK del servidor registra esa llamada dentro de la misma traza.
3. El cliente hace clic en Pagar cuatro veces más. El SDK del navegador registra un clic de rabia y empieza a subir la grabación, desde 30 segundos antes.
4. La ingesta guarda todo en el bucket.
5. Dentro de los 2 minutos siguientes al primer pago fallido, el motor abre un problema. Cuando el segundo y el tercer cliente fallan en la misma llamada con la misma respuesta, entran a ese problema en vez de abrir otros. El motor anota que la primera falla llegó después de la versión desplegada ayer a las 18:40.
6. El agente lee el problema y escribe: «3 personas intentaron pagar hoy y no pudieron. El botón Pagar no hace nada desde el cambio de ayer.»
7. Te llega la alerta, minutos después de que falló el primer cliente. Tu agente de código recibe el prompt y puede leer el problema por MCP. En Sypnia Cloud, el arreglo también puede llegar como pull request.

## Sigue con
