# Una implementación de referencia en AWS, servicio por servicio

> Cada servicio de AWS que usa el motor, qué hace, qué parte del motor corre en él y si esa parte es Rust o un servicio administrado; una solicitud seguida por los servicios reales; la plantilla; y el modelo de costos con su aritmética, hasta lo que cuesta un proyecto gratuito.

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/architecture/reference-implementation-aws/

Para agentes: Lee esto para el despliegue concreto del motor de Sypnia en AWS: CloudFront, tres funciones Lambda que corren el mismo binario en Rust (sypnia-ingest, sypnia-api, sypnia-worker), una cola de entrada en SQS con su cola de mensajes fallidos, EventBridge Scheduler, S3, RDS para PostgreSQL, Secrets Manager, alarmas de CloudWatch; dónde corre el código en Rust y la lógica del motor; límites por servicio; un extracto de la plantilla; costos unitarios (por 1.000 lotes, por millón de eventos, por GB-mes, por 1.000 grabaciones, por análisis), el costo en reposo, ejemplos resueltos y el costo de un proyecto del plan Free en Sypnia Cloud con los límites propuestos.

[Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes) dice que el motor puede correr como funciones en AWS. Esta página es ese despliegue con nombres propios: qué servicio de AWS hace qué, dónde corre el código en Rust, dónde vive la lógica del motor, a qué está limitado cada servicio y cuánto cuesta. Es el despliegue que crea la plantilla `sypnia-aws.yaml`, y el que corre Sypnia Cloud **\[Nube]**.

> **En palabras simples**
>
> En AWS, los servicios de Amazon llevan los datos y los guardan: una dirección, una cola, un bucket, una base de datos, un reloj. No deciden nada. Cada decisión, qué aceptar, qué es un problema, qué contar, cuándo alertar, la toma un solo programa escrito en Rust, que corre en tres funciones pequeñas. Si puedes leer ese programa, ya leíste toda la lógica del motor.

> **Nota: Sobre los números**
>
> Los límites de los servicios de AWS son los publicados. Los tiempos son presupuestos del diseño, no mediciones del motor en Rust, que aún no se ha publicado. Los precios son los de lista, por demanda, para `us-east-1`, tal como se asumen el **2026-11-15**; cambian, así que rehaz las sumas con las listas de precios enlazadas antes de confiar en un total. Las cifras «medidas en el sistema del que sale este motor» lo dicen.

## Los servicios

Nueve servicios de AWS. Uno de ellos, Lambda, corre el código del motor, en tres funciones. La última columna responde «¿esto es Rust, o esto es Amazon?».

| Servicio de AWS                                                   | Qué hace aquí                                                                                                                                                                 | Qué parte del motor                                                                                                                                                 | Código en Rust, o administrado                                                                                          |
| ----------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |
| **Amazon CloudFront**                                             | La única dirección HTTPS. Envía `/v1/ingest/*`, `/v1/otlp/*` y `/v1/sdk.js` a la función de ingesta y todo lo demás a la función de la API. Solo guarda en caché `/v1/sdk.js` | Ninguna. Reenvía                                                                                                                                                    | Administrado. Configuración: dos reglas de ruta                                                                         |
| **AWS Lambda**, función `sypnia-ingest`                           | Recibe lo que envían los SDK                                                                                                                                                  | **Ingesta**: las siete puertas, y luego el lote va a la cola; los fragmentos de grabación y las capturas van al Bucket                                              | **Rust**: el binario `sypnia` con `SYPNIA_ROLE=ingest`                                                                  |
| **AWS Lambda**, función `sypnia-worker`                           | Hace todo el trabajo que no es una solicitud                                                                                                                                  | **El worker**: escribir segmentos, la Vía rápida, la Consolidación, las tareas del agente, Alertas y webhooks, comprobaciones de disponibilidad, retención, Parquet | **Rust**: el mismo binario con `SYPNIA_ROLE=worker`                                                                     |
| **AWS Lambda**, función `sypnia-api`                              | Les responde a las personas y a los agentes de código                                                                                                                         | **La API, el servidor MCP y la Consola**                                                                                                                            | **Rust**: el mismo binario con `SYPNIA_ROLE=api`                                                                        |
| **Amazon SQS**, la cola de entrada y su cola de mensajes fallidos | Guarda los lotes validados hasta que el worker los escribió; estaciona los que fallaron cinco veces                                                                           | Ninguna. Es el búfer que una función no puede tener en memoria                                                                                                      | Administrado. Configuración: retención, tiempo de invisibilidad, `maxReceiveCount`                                      |
| **Amazon EventBridge Scheduler**                                  | Despierta al worker cada minuto                                                                                                                                               | Ninguna. El worker decide qué toca                                                                                                                                  | Administrado. Configuración: `rate(1 minute)`                                                                           |
| **Amazon S3**                                                     | El Bucket: segmentos, archivos por sesión, fragmentos de grabación, capturas, source maps, Parquet                                                                            | Ninguna. Las llaves las arma el motor; la retención es la tarea diaria del motor                                                                                    | Administrado. Configuración: privado, cifrado, una regla para cargas sin terminar, CORS para los enlaces de grabaciones |
| **Amazon RDS para PostgreSQL**                                    | Postgres: el registro, los problemas, los números, el índice de sesiones, las alertas, las tareas                                                                             | Ninguna. Sin procedimientos almacenados, sin disparadores, sin extensiones                                                                                          | Administrado. O cualquier Postgres 15 o posterior tuyo                                                                  |
| **AWS Secrets Manager**                                           | Guarda la contraseña generada de la base de datos que crea la plantilla                                                                                                       | Ninguna                                                                                                                                                             | Administrado                                                                                                            |
| **Amazon CloudWatch**                                             | Un grupo de logs por función, guardados 30 días; tres alarmas                                                                                                                 | Ninguna. Las alarmas vigilan el motor desde afuera                                                                                                                  | Administrado. Configuración: tres umbrales                                                                              |
| **AWS IAM**                                                       | Un rol por función, cada uno con lo mínimo que necesita                                                                                                                       | Ninguna                                                                                                                                                             | Administrado                                                                                                            |

No se usan, a propósito: ni balanceador, ni API gateway, ni clúster de contenedores, ni NAT gateway, ni flujo de datos, ni caché, ni servicio de búsqueda, ni servicio de flujos de trabajo, ni una segunda base de datos.

|                                             | Motor de Sypnia (código abierto, en tu propia infraestructura)                                               | Sypnia Cloud (servicio pago, con un plan gratis)                                                                                                             |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Correo                                      | Ninguno. Las alertas se registran y se envían a tu webhook; las guías muestran cómo enviar correo desde ahí. | **Amazon SES**: los correos de alerta y el resumen diario.                                                                                                   |
| Proveedor de IA                             | El tuyo, apagado hasta que pongas una llave. El worker lo llama por HTTPS.                                   | **OpenRouter**, con ajustes que les prohíben a los proveedores guardar los datos o entrenar con ellos.                                                       |
| Cuentas, facturación, la app, la GitHub App | No están en el motor.                                                                                        | La app privada. Es un cliente de la API pública del motor, igual que tus propias herramientas; tiene su propia base de datos y no le agrega lógica al motor. |

## Dónde está el Rust, y dónde está la lógica

**Figura (diagrama aún sin dibujar)**: La implementación de referencia. Las tres cajas encendidas son el motor: un binario en Rust, tres roles. Todo lo demás es un servicio administrado que mueve o guarda bytes.

Mostrará: DIAGRAMA DE ARQUITECTURA con nombres de servicios de AWS, dentro de un marco «Cuenta de AWS · us-east-1 · stack: sypnia». Las tres funciones Lambda son los elementos ENCENDIDOS (relleno de acento) y cada una lleva una etiqueta pequeña «Rust»; todos los demás nodos van en tono neutro con una etiqueta pequeña «administrado». IZQUIERDA, fuera del marco: «Tu app (SDK)» y debajo «Tú · tu agente de código · tu CI». ADENTRO, de izquierda a derecha: nodo «Amazon CloudFront · la dirección» (dos flechas de salida con los rótulos «/v1/ingest/\* · /v1/otlp/\* · /v1/sdk.js» y «todo lo demás»); caja ENCENDIDA «AWS Lambda · sypnia-ingest» con el subrótulo «Ingesta: las siete puertas» y la etiqueta «256 MB · 10 s · 40 copias»; símbolo de cola «Amazon SQS · cola de entrada» con una más pequeña debajo «cola de mensajes fallidos · 14 días»; caja ENCENDIDA «AWS Lambda · sypnia-worker» con CINCO fichas internas apiladas: «escribir segmentos», «Vía rápida», «Consolidación», «El agente», «Alertas · disponibilidad · retención» y la etiqueta «1.024 MB · 15 min · 2 copias»; sobre el worker un reloj «Amazon EventBridge Scheduler · cada minuto»; una flecha curva del worker hacia sí mismo con el rótulo «tareas del agente»; a la derecha dos almacenes apilados: «Amazon S3 · el Bucket» y «Amazon RDS para PostgreSQL · Postgres»; en la fila inferior una caja ENCENDIDA «AWS Lambda · sypnia-api» con el subrótulo «API · servidor MCP · Consola» y la etiqueta «512 MB · 30 s · 20 copias». Nodos pequeños en una franja de esquina con el rótulo «alrededor»: «AWS Secrets Manager · contraseña de la base de datos», «Amazon CloudWatch · logs + 3 alarmas», «AWS IAM · un rol por función». FLECHAS: Tu app → CloudFront → sypnia-ingest; sypnia-ingest → cola de entrada «SendMessage»; sypnia-ingest → S3 «fragmentos de grabación, capturas»; cola de entrada → sypnia-worker «hasta 10 s de mensajes»; cola de entrada ⇢ cola de mensajes fallidos (punteada) «tras 5 entregas»; sypnia-worker → S3 «segmentos, archivos por sesión, Parquet»; sypnia-worker → RDS «registro, problemas, números, tareas»; Tú → CloudFront → sypnia-api; sypnia-api → RDS «lecturas»; sypnia-api → S3 «enlaces firmados». FUERA del marco a la derecha, punteados: «Proveedor de IA (el tuyo · Sypnia Cloud: OpenRouter)» y «Tu webhook», cada uno con una flecha desde sypnia-worker; y una caja punteada solo de la nube «Solo Sypnia Cloud: Amazon SES · la app privada» con la insignia de nube. Una leyenda con dos muestras: acento «el motor: Rust, toda la lógica» y neutro «servicios administrados de AWS: mueven y guardan bytes». Llamadas numeradas (1) CloudFront, (2) sypnia-ingest, (3) las colas, (4) sypnia-worker, (5) el programador, (6) S3, (7) RDS, (8) sypnia-api.

Tres afirmaciones, y cada una la puedes comprobar en la plantilla y en el código:

1. **Todo lo que hay dentro de las tres funciones es el motor, y el motor es Rust.** Las funciones corren el mismo archivo, `sypnia`, compilado para arm64 y arrancado por Lambda como su `bootstrap`. En el despliegue no hay un entorno de Node, Python ni Java, ni un segundo programa.
2. **Los servicios de AWS mueven y guardan bytes.** CloudFront reenvía una solicitud. SQS guarda un mensaje. S3 guarda un objeto. Postgres guarda filas. El programador envía un documento JSON fijo cada minuto. Ninguno mira dentro de un evento.
3. **Ninguna lógica vive en la configuración de un servicio.** Lo que la plantilla configura son números y nombres: dos reglas de ruta, una retención, un tiempo de invisibilidad, el `5` de la regla de mensajes fallidos, una frecuencia, tres umbrales de alarma, los roles. No hay plantillas que transformen solicitudes, ni reglas con filtros, ni código en el borde, ni notificaciones del bucket, ni procedimientos almacenados, ni disparadores, ni definiciones de flujos de trabajo. La retención ni siquiera es una regla de ciclo de vida del bucket: es la tarea diaria del motor, así que es igual en cualquier almacén compatible con S3.

Esa tercera afirmación es lo que hace portable al motor. Cambia SQS por memoria y Lambda por un proceso, y tienes la [forma de un solo proceso](https://docs.sypnia.com/es/architecture/deployment-shapes#como-un-proceso-largo), con el mismo código decidiendo las mismas cosas.

### De crates a funciones a servicios

**Figura (diagrama aún sin dibujar)**: Qué crate corre en qué función, y qué servicio puede tocar cada función. La columna izquierda contiene toda la lógica.

Mostrará: DIAGRAMA DE CORRESPONDENCIA EN TRES COLUMNAS con líneas que las conectan. COLUMNA IZQUIERDA titulada «Crates (Rust)»: nodos pequeños apilados en las capas del diagrama del código, rótulos exactos: «sypnia (binario): main, lambda, Engine», «sypnia-ingest», «sypnia-pipeline», «sypnia-agent», «sypnia-alerts», «sypnia-api», «sypnia-store», «sypnia-db», «sypnia-fingerprint», «sypnia-core». COLUMNA DEL MEDIO titulada «Funciones (el mismo binario, por rol)», tres cajas ENCENDIDAS más grandes: «sypnia-ingest · SYPNIA_ROLE=ingest», «sypnia-worker · SYPNIA_ROLE=worker», «sypnia-api · SYPNIA_ROLE=api». COLUMNA DERECHA titulada «Servicios de AWS», nodos: «Amazon CloudFront», «Amazon SQS», «Amazon EventBridge Scheduler», «Amazon S3», «Amazon RDS para PostgreSQL», y punteados «Proveedor de IA», «Tu webhook». LÍNEAS izquierda → medio (el código de qué crate corre en qué función): sypnia-ingest → función sypnia-ingest (rótulo «puertas, envío») y → función sypnia-worker (rótulo «el otro extremo de la cola: escribir segmentos»); sypnia-pipeline → sypnia-worker; sypnia-agent → sypnia-worker (rótulo «tareas») y → sypnia-api (rótulo «el prompt»); sypnia-alerts → sypnia-worker; sypnia-api → función sypnia-api; un corchete alrededor de sypnia-store, sypnia-db, sypnia-fingerprint, sypnia-core con el rótulo «enlazados en las tres»; el crate del binario → las tres con el rótulo «main → lambda::run(role)». LÍNEAS medio → derecha (qué puede tocar cada función, con el permiso como rótulo): función sypnia-ingest → SQS «enviar»; → S3 «solo escribir»; ← CloudFront «la invoca». Función sypnia-worker ← SQS «recibe, borra, demora»; ← Scheduler «cada minuto»; → S3 «leer y escribir»; → RDS «leer y escribir»; → Proveedor de IA; → Tu webhook. Función sypnia-api ← CloudFront; → RDS «leer, y las escrituras de la API»; → S3 «leer + firmar». Bajo el diagrama una línea: «la columna izquierda es toda la lógica; la derecha no tiene ninguna». Llamadas numeradas (1) columna izquierda, (2) medio, (3) derecha.

| Crate                                             | Corre en                                                                                                    | Alcanza                                                                       |
| ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------- |
| `sypnia` (el binario): `main`, `lambda`, `Engine` | Las tres funciones                                                                                          | El entorno de Lambda                                                          |
| `sypnia-ingest`                                   | `sypnia-ingest`: las puertas y el envío. `sypnia-worker`: el otro extremo de la cola, que escribe segmentos | SQS, S3                                                                       |
| `sypnia-pipeline`                                 | `sypnia-worker`                                                                                             | S3, Postgres                                                                  |
| `sypnia-agent`                                    | `sypnia-worker`: las tareas. `sypnia-api`: el prompt                                                        | S3, Postgres, el proveedor de IA                                              |
| `sypnia-alerts`                                   | `sypnia-worker`                                                                                             | Postgres, tu webhook, las direcciones de tus comprobaciones de disponibilidad |
| `sypnia-api`                                      | `sypnia-api`                                                                                                | Postgres, S3 (leer, y firmar enlaces)                                         |
| `sypnia-store`, `sypnia-db`                       | Las tres                                                                                                    | S3; Postgres                                                                  |
| `sypnia-fingerprint`, `sypnia-core`               | Las tres                                                                                                    | Nada: no hacen E/S                                                            |

Las funciones comparten un solo punto de entrada. Es el `main` de [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes#un-motor-dos-maneras-de-despertarlo); estas son las líneas que importan aquí. Fíjate en que el rol es lo único que cambia entre las tres funciones, y en que se lee del entorno que pone la plantilla.

`crates/sypnia/src/main.rs`

```rust
    // Bucket, Postgres, el proveedor de IA (o ninguno), los destinos de alertas. Se arma una vez, lo comparten todos.
    let engine = match Engine::connect(config.clone()).await {
        Ok(engine) => Arc::new(engine),
        Err(error) => return fail(4, &error),
    };

    // Dentro de AWS Lambda el entorno pone esta variable y no hay línea de comandos.
    if std::env::var_os("AWS_LAMBDA_RUNTIME_API").is_some() {
        return exit(lambda::run(engine, config.role).await); // SYPNIA_ROLE: ingest | worker | api
    }
```

## Una solicitud por los servicios reales

El pago fallido del [resumen](https://docs.sypnia.com/es/architecture#la-vida-de-una-solicitud-en-9-pasos), con el servicio que lleva cada paso, su presupuesto de tiempo, su límite y qué pasa cuando ese servicio falla. La columna de fallas es un resumen; [Qué pasa cuando algo falla](https://docs.sypnia.com/es/architecture/reliability) tiene todos los casos.

| #  | Paso                                                                                                  | Servicio                                                     | Presupuesto                                     | El límite que aplica                                                                                                        | Si falla                                                                                    |
| -- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
| 1  | El navegador envía `POST /v1/ingest/events`                                                           | CloudFront → Lambda `sypnia-ingest`                          | 50 ms en caliente; 300 ms para una función fría | Cuerpo: 2 MiB descomprimido (el del motor), 6 MB (el de Lambda). 10 s. 40 copias; pasadas esas, la dirección responde `429` | El SDK conserva el lote y reintenta con el mismo `batch_id`                                 |
| 2  | La Ingesta envía el lote validado                                                                     | SQS `SendMessage`                                            | 20 ms                                           | 256 KiB por mensaje; un lote de más de 192 KiB comprimido va a S3 y el mensaje lo nombra                                    | `503`; el SDK reintenta                                                                     |
| 3  | La Ingesta responde `200`                                                                             | Lambda → CloudFront                                          | —                                               | —                                                                                                                           | —                                                                                           |
| 4  | La cola le entrega el lote al worker                                                                  | SQS → Lambda `sypnia-worker`                                 | Hasta 10 s                                      | 500 mensajes o 6 MB por entrega. 2 copias. Invisibilidad de 15 min                                                          | Se entrega de nuevo a los 15 s, 1 min, 5 min, 15 min; luego la cola de mensajes fallidos    |
| 5  | El worker escribe el segmento                                                                         | S3 `PutObject`                                               | 300 ms                                          | 4 MiB por segmento, antes de comprimir                                                                                      | El mensaje no se borra; el paso 4 se repite                                                 |
| 6  | El worker escribe la fila del registro, revisa el segmento, escribe el problema, su alerta y su tarea | RDS para PostgreSQL, una transacción                         | 50 ms; 5 s para la revisión                     | 3 conexiones por copia del worker                                                                                           | El segmento queda reservado 2 minutos, y luego otro intento; 5 intentos, y luego cuarentena |
| 7  | El worker se llama a sí mismo con la tarea                                                            | Lambda `Invoke`, asíncrono                                   | 100 ms                                          | Reintentos propios de Lambda apagados: la fila de la tarea es el reintento                                                  | La marca del minuto encuentra la fila                                                       |
| 8  | El agente lee los mapas y la sesión, llama al modelo, escribe la frase                                | S3 `GetObject`; HTTPS al proveedor de IA; Postgres           | 60 s                                            | 15 min para la función; 3 intentos para la tarea                                                                            | La alerta sale a tiempo sin la frase; `analysis.status: failed`                             |
| 9  | La alerta se libera hacia tu webhook                                                                  | HTTPS desde el worker                                        | 10 s                                            | 7 intentos en 21 horas                                                                                                      | La alerta queda registrada de todos modos                                                   |
| 10 | Cada minuto: una pasada                                                                               | EventBridge Scheduler → Lambda `sypnia-worker`               | 1 s en reposo                                   | 2 copias compartidas con los pasos 4, 7 y 8                                                                                 | La siguiente marca la hace                                                                  |
| 11 | Tu agente de código llama la herramienta MCP `problem`                                                | CloudFront → Lambda `sypnia-api` → Postgres                  | 300 ms                                          | Respuesta: 6 MB (el de Lambda); 30 s; 20 copias; 2 conexiones por copia                                                     | `503` con `Retry-After: 2`                                                                  |
| 12 | Abres la grabación                                                                                    | `sypnia-api` firma enlaces; el navegador lee S3 directamente | 300 ms para los enlaces                         | Un enlace vive 15 minutos; los fragmentos nunca pasan por una función                                                       | `503`; la lista de problemas sigue funcionando                                              |

### Límites y ajustes en un solo lugar

| Dónde                     | Ajuste                             | Valor                                                                                                                      | Por qué este valor                                                                                                                   |
| ------------------------- | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| `sypnia-ingest`           | Memoria, tiempo límite, copias     | 256 MB, 10 s, 40                                                                                                           | Solo revisa y reenvía. 40 copias a 50 ms aceptan unos 800 lotes por segundo                                                          |
| `sypnia-worker`           | Memoria, tiempo límite, copias     | 1.024 MB, 15 min, 2                                                                                                        | Dos proyectos consolidándose a la vez (2 × 256 MB), la caché de source maps, holgura. La tarea diaria puede necesitar los 15 minutos |
| `sypnia-api`              | Memoria, tiempo límite, copias     | 512 MB, 30 s, 20                                                                                                           | El detalle de una sesión se arma en memoria, dentro de un presupuesto de 4 MB                                                        |
| Todas las funciones       | Arquitectura, entorno              | arm64, `provided.al2023`                                                                                                   | Un binario nativo; no hay un entorno de lenguaje que arrancar                                                                        |
| Todas las funciones       | Variables de entorno               | Menos de 4 KB en total                                                                                                     | El límite de Lambda. El motor necesita unos 12 ajustes                                                                               |
| Cola de entrada           | Retención, invisibilidad, entregas | 4 días, 15 min, 5                                                                                                          | Ver [Qué pasa cuando algo falla](https://docs.sypnia.com/es/architecture/reliability#en-aws-una-cola-y-su-cola-de-mensajes-fallidos) |
| Cola de mensajes fallidos | Retención                          | 14 días                                                                                                                    | Lo máximo que permite SQS                                                                                                            |
| Cola → worker             | Lote, ventana, respuesta           | 500 mensajes o 6 MB, 10 s, fallas reportadas por mensaje                                                                   | Un mensaje malo no devuelve a los demás                                                                                              |
| Programador               | Frecuencia                         | Cada minuto                                                                                                                | Una sola programación; el trabajo diario y semanal lo arranca la pasada cuando toca                                                  |
| Bucket                    | Cifrado, acceso                    | En reposo, privado                                                                                                         | Las funciones llegan por sus roles; los navegadores, por enlaces firmados de 15 minutos                                              |
| Postgres                  | Conexiones                         | Máximo 86: 40 × 1, 20 × 2, 2 × 3                                                                                           | Caben en la instancia más pequeña, que acepta unas 100                                                                               |
| Alarmas                   | Tres                               | Cola de mensajes fallidos no vacía; mensaje más viejo de más de 120 s durante 3 minutos; worker fallando en 3 de 5 minutos | Funcionan cuando el motor no                                                                                                         |

Las dos copias del worker las comparten las entregas de la cola, la marca del minuto y las tareas del agente. Cuando todas están ocupadas, una llamada nueva espera: un mensaje se queda en la cola, una llamada asíncrona la retiene Lambda. No se pierde nada; el trabajo sale más tarde. Este es el primer número que hay que subir cuando `lag_seconds` crece, junto con las conexiones de la base de datos.

## La plantilla

Todo el despliegue es un archivo, `sypnia-aws.yaml`. Este extracto es la parte de la que habla esta página: las tres funciones, la cola con su regla de mensajes fallidos, la programación y una alarma. Quedan por fuera: la distribución, el bucket, la base de datos, las otras dos alarmas y las salidas. Cómo desplegarla está en [Desplegar en AWS](https://docs.sypnia.com/es/self-hosting/deploy-aws).

`deploy/sypnia-aws.yaml (extracto)`

```yaml
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Runtime: provided.al2023          # sin entorno de lenguaje: el paquete es el binario sypnia, con el nombre bootstrap
    Handler: bootstrap
    Architectures: [arm64]
    CodeUri: { Bucket: !Ref CodeBucket, Key: !Sub "sypnia/${Version}/sypnia-lambda-arm64.zip" }
    Environment:
      Variables:
        SYPNIA_ROOT_TOKEN: !Ref RootToken
        SYPNIA_STORAGE_BUCKET: !Ref Bucket
        SYPNIA_DATABASE_URL: !If [CreateDb, !Sub "postgres://sypnia:{{resolve:secretsmanager:${DatabaseSecret}:SecretString:password}}@${Database.Endpoint.Address}:5432/sypnia?sslmode=require", !Ref DatabaseUrl]
        SYPNIA_INTAKE_QUEUE_URL: !Ref IntakeQueue                       # la cola ocupa el lugar del búfer en memoria
        SYPNIA_INTAKE_DEAD_LETTER_QUEUE_URL: !Ref IntakeDeadLetterQueue # la leen /v1/engine/status y sypnia doctor

Resources:
  IngestFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: sypnia-ingest
      MemorySize: 256
      Timeout: 10
      ReservedConcurrentExecutions: 40
      FunctionUrlConfig: { AuthType: NONE }   # se llega por la distribución; el motor revisa cada llave por su cuenta
      Environment: { Variables: { SYPNIA_ROLE: ingest, SYPNIA_DATABASE_MAX_CONNECTIONS: "1" } }
      Policies:
        - SQSSendMessagePolicy: { QueueName: !GetAtt IntakeQueue.QueueName }
        - Statement: [{ Effect: Allow, Action: "s3:PutObject", Resource: !Sub "${Bucket.Arn}/*" }]

  ApiFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: sypnia-api
      MemorySize: 512
      Timeout: 30
      ReservedConcurrentExecutions: 20
      FunctionUrlConfig: { AuthType: NONE }
      Environment: { Variables: { SYPNIA_ROLE: api, SYPNIA_DATABASE_MAX_CONNECTIONS: "2" } }
      Policies:
        - S3ReadPolicy: { BucketName: !Ref Bucket }                    # leer, y firmar enlaces de lectura

  WorkerFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: sypnia-worker
      MemorySize: 1024
      Timeout: 900
      ReservedConcurrentExecutions: 2
      Environment: { Variables: { SYPNIA_ROLE: worker, SYPNIA_DATABASE_MAX_CONNECTIONS: "3" } }
      EventInvokeConfig: { MaximumRetryAttempts: 0 }                    # una tarea es una fila en Postgres: la fila es el reintento
      Policies:
        - S3CrudPolicy: { BucketName: !Ref Bucket }
        - Statement:
            - { Effect: Allow, Action: "lambda:InvokeFunction", Resource: !Sub "arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:sypnia-worker" }
            - { Effect: Allow, Action: "sqs:GetQueueAttributes", Resource: !GetAtt IntakeDeadLetterQueue.Arn }
      Events:
        Intake:
          Type: SQS
          Properties:
            Queue: !GetAtt IntakeQueue.Arn
            BatchSize: 500
            MaximumBatchingWindowInSeconds: 10
            FunctionResponseTypes: [ReportBatchItemFailures]             # solo vuelven los mensajes que fallaron
            ScalingConfig: { MaximumConcurrency: 2 }
        EveryMinute:
          Type: ScheduleV2
          Properties:
            ScheduleExpression: rate(1 minute)
            Input: '{"job":"pass"}'

  IntakeQueue:
    Type: AWS::SQS::Queue
    Properties:
      VisibilityTimeout: 900                  # no menor que el tiempo límite del worker
      MessageRetentionPeriod: 345600          # 4 días
      ReceiveMessageWaitTimeSeconds: 20
      SqsManagedSseEnabled: true
      RedrivePolicy:
        deadLetterTargetArn: !GetAtt IntakeDeadLetterQueue.Arn
        maxReceiveCount: 5                    # la quinta entrega fallida es la última

  IntakeDeadLetterQueue:
    Type: AWS::SQS::Queue
    Properties:
      MessageRetentionPeriod: 1209600         # 14 días
      SqsManagedSseEnabled: true

  DeadLetterNotEmpty:
    Type: AWS::CloudWatch::Alarm
    Properties:
      AlarmDescription: Batches were set aside. Look at one, fix the cause, redrive.
      Namespace: AWS/SQS
      MetricName: ApproximateNumberOfMessagesVisible
      Dimensions: [{ Name: QueueName, Value: !GetAtt IntakeDeadLetterQueue.QueueName }]
      Statistic: Maximum
      Period: 60
      EvaluationPeriods: 1
      Threshold: 0
      ComparisonOperator: GreaterThanThreshold
      TreatMissingData: notBreaching
```

Qué despierta al worker se distingue por la forma del evento, en el `worker_event` de [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes#como-funciones-de-aws): `{ "Records": […] }` es la cola, `{ "job": "pass" }` es la programación, `{ "job": { "agent": { "problem": "prb_8f3k2m9x4q7w" } } }` es el worker llamándose a sí mismo.

## Postgres: cuál, y por qué

La referencia usa **Amazon RDS para PostgreSQL, una instancia pequeña en una sola zona de disponibilidad**: `db.t4g.micro`, Postgres 16, 20 GB, cifrada, respaldos guardados 7 días. Es lo que crea la plantilla cuando `CreateDatabase` es `true`.

| Opción                                                  | Costo en reposo al mes                                                        | Lo bueno                                                                           | El precio que pagas                                                                                                                                           |
| ------------------------------------------------------- | ----------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **RDS para PostgreSQL**, `db.t4g.micro` (la referencia) | 11,68 + 2,30 de disco                                                         | El Postgres administrado más barato de AWS; una factura fija; Postgres sin adornos | Una zona: una falla de la instancia son minutos de «se recibe, pero no se puede leer». Unas 100 conexiones                                                    |
| RDS en dos zonas (Multi-AZ)                             | El doble de la instancia y del disco                                          | Cambia de zona solo, en uno o dos minutos                                          | El doble de precio por una base de datos que el Bucket puede reconstruir casi entera                                                                          |
| Aurora Serverless v2                                    | Desde 43,80: 0,5 unidades de capacidad × 0,12 × 730, más almacenamiento y E/S | Crece y se encoge con la carga                                                     | Tres veces el costo en reposo. Escalar a cero no sirve: la marca del minuto la despertaría cada minuto                                                        |
| Un Postgres fuera de AWS (Supabase, Neon, el tuyo)      | 0 a 25                                                                        | Quizá ya lo tienes                                                                 | Cada consulta cruza internet; aplican sus límites de conexiones. Usa una conexión directa o en modo sesión, no un agrupador de conexiones en modo transacción |

**Una sola cadena de conexión.** El motor recibe un único `SYPNIA_DATABASE_URL`, para todos los roles. Debe ser una conexión directa o en modo sesión: el motor prepara sus sentencias y corre transacciones de varias sentencias, y un agrupador de conexiones en modo transacción las rompe. A cambio, las funciones mantienen el total pequeño: 1 conexión por copia de ingesta, 2 por copia de la API, 3 por copia del worker.

> **Advertencia: La base de datos que crea la plantilla se puede alcanzar desde internet**
>
> Las funciones corren fuera de una red privada, porque el worker debe llegar a tu webhook, a tu proveedor de IA y a tus comprobaciones de disponibilidad, y dentro de una red privada eso necesita un NAT gateway: unos USD 33 al mes antes del tráfico, más que todo lo demás junto en un despliegue pequeño. Una base de datos que esas funciones pueden alcanzar tiene una dirección pública. La plantilla obliga a usar TLS y genera una contraseña de 32 caracteres, guardada en Secrets Manager. Las alternativas: trae un Postgres con las reglas de red que quieras, o pon las funciones en una red privada con un NAT gateway y págalo. El modelo de costos de abajo cuenta las dos maneras.

**Secretos.** La contraseña generada de la base de datos vive en Secrets Manager y se resuelve cuando se despliega el stack. El token raíz, la llave de IA y el secreto del webhook son parámetros de la plantilla que nunca se muestran, guardados como entorno de las funciones, que Lambda cifra en reposo. Quien pueda leer la configuración de una función los puede leer; restringe ese permiso igual que restringirías los secretos mismos.

## El modelo de costos

### Precios usados

USD, por demanda, `us-east-1`, tal como se asumen el 2026-11-15, sin ninguna cuota gratuita. Cada nombre enlaza a la lista de precios oficial.

| Servicio                                                                     | Unidad                                                                                              | Precio                     |
| ---------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- | -------------------------- |
| [AWS Lambda](https://aws.amazon.com/lambda/pricing/), arm64                  | Por GB-segundo; por millón de solicitudes                                                           | 0,0000133334; 0,20         |
| [Amazon SQS](https://aws.amazon.com/sqs/pricing/), estándar                  | Por millón de solicitudes (cada 64 KB de un mensaje es una)                                         | 0,40                       |
| [Amazon S3](https://aws.amazon.com/s3/pricing/), Standard                    | Por GB-mes; por millón de escrituras o listados; por millón de lecturas                             | 0,023; 5,00; 0,40          |
| [Amazon CloudFront](https://aws.amazon.com/cloudfront/pricing/)              | Por millón de solicitudes HTTPS; por GB enviado a la función; por GB enviado hacia afuera           | 1,00; 0,02; 0,085          |
| Datos que salen de AWS desde S3                                              | Por GB                                                                                              | 0,09                       |
| [Amazon RDS para PostgreSQL](https://aws.amazon.com/rds/postgresql/pricing/) | `db.t4g.micro` por hora; `db.t4g.medium` por hora; disco por GB-mes; una dirección pública por hora | 0,016; 0,065; 0,115; 0,005 |
| [Amazon EventBridge Scheduler](https://aws.amazon.com/eventbridge/pricing/)  | Por millón de invocaciones                                                                          | 1,00                       |
| [Amazon CloudWatch](https://aws.amazon.com/cloudwatch/pricing/)              | Logs por GB; por alarma al mes                                                                      | 0,50; 0,10                 |
| [AWS Secrets Manager](https://aws.amazon.com/secrets-manager/pricing/)       | Por secreto al mes                                                                                  | 0,40                       |
| [Amazon SES](https://aws.amazon.com/ses/pricing/) **\[Nube]**                | Por 1.000 correos                                                                                   | 0,10                       |
| NAT gateway (no está en la referencia)                                       | Por hora; por GB                                                                                    | 0,045; 0,045               |

AWS le da a cada cuenta una cuota mensual que cubre las funciones de un despliegue pequeño (400.000 GB-segundos y un millón de solicitudes), su cola (un millón de solicitudes) y su dirección (10 millones de solicitudes). Los costos unitarios de abajo la ignoran, para que sigan siendo ciertos a cualquier tamaño.

### Un despliegue en reposo

No llega nada. Lo que igual cuesta:

| Línea                                      | Aritmética                                                                 | Al mes      |
| ------------------------------------------ | -------------------------------------------------------------------------- | ----------- |
| La marca del minuto                        | 43.200 llamadas × 1 s × 1 GB × 0,0000133334, más 43.200 × 0,20 ÷ 1.000.000 | 0,59        |
| La programación                            | 43.200 × 1,00 ÷ 1.000.000                                                  | 0,04        |
| Las consultas vacías a la cola             | Unas 15 por minuto: 648.000 × 0,40 ÷ 1.000.000                             | 0,26        |
| Tres alarmas                               | 3 × 0,10                                                                   | 0,30        |
| Un secreto                                 |                                                                            | 0,40        |
| Logs                                       | Cerca de 0,1 GB                                                            | 0,05        |
| Bucket, dirección, las otras dos funciones | No llega nada, no se cobra nada                                            | 0,00        |
| **El motor, en reposo**                    |                                                                            | **≈ 1,64**  |
| Postgres, si lo crea la plantilla          | 0,016 × 730 + 20 × 0,115                                                   | 13,98       |
| Su dirección pública                       | 0,005 × 730                                                                | 3,65        |
| **Total, en reposo**                       |                                                                            | **≈ 19,27** |

Con un Postgres que ya tengas, un motor en reposo cuesta menos de USD 2 al mes, y con la cuota gratuita son centavos.

### Costos unitarios

**Recibir, guardar y procesar eventos.** La unidad que cuesta no es el evento: es el lote, y el segmento en el que cae.

| Paso, por 1.000 lotes                                                          | Servicio   | Aritmética                              | USD        |
| ------------------------------------------------------------------------------ | ---------- | --------------------------------------- | ---------- |
| La dirección los recibe                                                        | CloudFront | 1.000 × 1,00 ÷ 1.000.000                | 0,00100    |
| Los cuerpos llegan a la función, 3 KB cada uno                                 | CloudFront | 0,003 GB × 0,02                         | 0,00006    |
| Se llama a `sypnia-ingest`                                                     | Lambda     | 1.000 × 0,20 ÷ 1.000.000                | 0,00020    |
| Corre 50 ms con 256 MB                                                         | Lambda     | 12,5 GB-s × 0,0000133334                | 0,00017    |
| Los lotes se envían a la cola                                                  | SQS        | 1.000 × 0,40 ÷ 1.000.000                | 0,00040    |
| El worker los recibe y los borra, en grupos                                    | SQS        | Unas 670 solicitudes × 0,40 ÷ 1.000.000 | 0,00027    |
| **Recibir**                                                                    |            |                                         | **0,0021** |
| Segmentos escritos: máximo uno por lote                                        | S3         | 1.000 × 5,00 ÷ 1.000.000                | 0,00500    |
| Cada uno leído una vez por la vía rápida y hasta 11 veces por la consolidación | S3         | 12.000 × 0,40 ÷ 1.000.000               | 0,00480    |
| El tiempo del worker para ellos, 20 ms cada uno con 1 GB                       | Lambda     | 20 GB-s × 0,0000133334                  | 0,00027    |
| **Guardar y procesar, como máximo**                                            |            |                                         | **0,0101** |
| **Total, como máximo**                                                         |            |                                         | **0,0122** |

Los segmentos son la mitad más grande, y tienen tope: un proyecto y entorno recibe máximo un segmento por entrega de 10 segundos, 259.200 al mes, envíe lo que envíe. Por eso el costo de un millón de eventos depende de cómo llegan:

| Un millón de eventos                                                                                                                                                                     | Lotes     | Segmentos                                    | Aritmética                                                              | USD         |
| ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------- | -------------------------------------------- | ----------------------------------------------------------------------- | ----------- |
| **Un proyecto activo**: el proyecto pequeño de [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes#cu%C3%A1nto-cuesta-en-aws), 4 millones de eventos al mes | 225.000   | 65.000 (el tope, repartido entre 4 millones) | 225 × 0,0021 + 65 × 0,0101 + 15.000 archivos por sesión × 5 ÷ 1.000.000 | **≈ 1,20**  |
| **Un proyecto tranquilo**: cada lote solo en sus 10 segundos                                                                                                                             | 225.000   | 225.000                                      | 225 × 0,0122 + 0,08                                                     | **≈ 2,80**  |
| **La peor forma**: cada evento solo en un lote, dos eventos por sesión                                                                                                                   | 1.000.000 | 1.000.000                                    | 1.000 × 0,0122 + 1.000.000 de archivos por sesión × 5 ÷ 1.000.000       | **≈ 17,20** |

Medido en el sistema del que sale este motor: 4,4 eventos por lote y 30 lotes por sesión, de donde sale el 225.000. La peor forma es la que un techo debe asumir, y la que no tiene la app de nadie.

**Guardar.** USD 0,023 por GB-mes. Un GB son unos 8 millones de eventos en segmentos (125 MB por millón), o 2,7 millones con sus archivos por sesión y Parquet (375 MB por millón), o unas 1.330 grabaciones cortas.

**Grabaciones.** Una grabación es un objeto por cada 10 segundos, enviado por la dirección y `sypnia-ingest`, y leído por el navegador directamente de S3 cuando alguien la ve.

| Por 1.000 grabaciones                     | Una corta: 22 fragmentos, 0,75 MB (medido allá)                 | La más larga: 720 fragmentos, 144 MB, dos horas |
| ----------------------------------------- | --------------------------------------------------------------- | ----------------------------------------------- |
| Solicitudes por la dirección y la función | 22.000 × (1,00 + 0,20 + 0,33) ÷ 1.000.000 = 0,034               | 1,10                                            |
| Cuerpos hacia la función                  | 0,75 GB × 0,02 = 0,015                                          | 2,88                                            |
| Objetos escritos                          | 22.000 × 5 ÷ 1.000.000 = 0,110                                  | 3,60                                            |
| **Guardadas**                             | **≈ 0,16**                                                      | **≈ 7,58**                                      |
| Conservadas, por mes de retención         | 0,75 GB × 0,023 = 0,017                                         | 3,31                                            |
| **Vistas una vez, cada una**              | 22.000 lecturas × 0,40 ÷ 1.000.000 + 0,75 GB × 0,09 = **0,076** | **≈ 13,25**                                     |

Una grabación corta cuesta dos centésimas de centavo entre guardarla y verla. La más larga cuesta dos centavos, casi 90 veces más, y la mayor parte son los datos que salen de AWS cuando se ve.

**Un análisis de IA.** El motor cuenta tokens, no dinero; el precio es el de tu proveedor. La fórmula:

```text
costo = llamadas × (tokens_entrada × precio_entrada + tokens_salida × precio_salida) ÷ 1.000.000
```

|                                    | Tokens de entrada                                                                                   | Tokens de salida               | Llamadas                                                                              |
| ---------------------------------- | --------------------------------------------------------------------------------------------------- | ------------------------------ | ------------------------------------------------------------------------------------- |
| Un análisis usual                  | 8.000: unos 24.000 caracteres de contexto a 3 o 4 caracteres por token, más las instrucciones fijas | 700                            | 1,15: se asume que una respuesta de cada siete no pasa la revisión y se pide de nuevo |
| El más grande que permite el motor | 9.000                                                                                               | 2.000 (`ai.max_output_tokens`) | 3                                                                                     |

| Precio del modelo, por millón de tokens de entrada / salida | Un análisis usual | El más grande |
| ----------------------------------------------------------- | ----------------- | ------------- |
| 0,15 / 0,60                                                 | 0,0019            | 0,0077        |
| 0,40 / 1,60                                                 | 0,0050            | 0,0204        |
| 3,00 / 15,00                                                | 0,040             | 0,171         |

Así que un análisis cuesta entre un quinto de centavo y cuatro centavos, según el modelo, y hasta 17 centavos en el peor caso con uno caro. Medido en el sistema del que sale este motor: USD 0,08 a 0,20 por una corrida semanal de 15 a 25 llamadas, cerca de medio centavo a un centavo por llamada. Aquí no se nombra ningún modelo porque no se promete ninguno.

**Una comprobación de disponibilidad.** Una solicitud por minuto, hecha dentro de la pasada que corre de todos modos: cerca de USD 0,02 al mes por sus 43.200 filas de resultados y su parte del tiempo del worker.

### Dos ejemplos de alojamiento propio

Los dos proyectos de [Formas de despliegue](https://docs.sypnia.com/es/architecture/deployment-shapes#cu%C3%A1nto-cuesta-en-aws), sumados por servicio. La aritmética línea por línea está allá; las últimas filas agregan tres cosas fijas y pequeñas que esa tabla no incluye.

| USD al mes                                                         | Pequeño: 4 millones de eventos, 30.000 sesiones | Mediano: 40 millones de eventos, 300.000 sesiones |
| ------------------------------------------------------------------ | ----------------------------------------------- | ------------------------------------------------- |
| Lambda                                                             | 3,31                                            | 15,26                                             |
| SQS                                                                | 0,60                                            | 4,00                                              |
| S3: escrituras, lecturas, almacenamiento                           | 3,52                                            | 14,34                                             |
| Logs de CloudWatch                                                 | 0,50                                            | 2,00                                              |
| CloudFront                                                         | 0,00 (dentro de la cuota)                       | 0,00                                              |
| **El motor**                                                       | **≈ 8**                                         | **≈ 36**                                          |
| RDS para PostgreSQL                                                | ≈ 14 (`db.t4g.micro`)                           | 25 a 50 (2 a 4 GB de memoria)                     |
| **Total, como en las otras páginas**                               | **≈ 22**                                        | **≈ 60 a 85**                                     |
| Tres alarmas, un secreto, la dirección pública de la base de datos | 0,30 + 0,40 + 3,65 = 4,35                       | 4,35                                              |
| **Todo lo que llega en la factura**                                | **≈ 26**                                        | **≈ 65 a 90**                                     |
| Con las funciones en una red privada                               | + 32,85 por el NAT gateway, − 3,65              | Lo mismo                                          |

No incluido: el modelo, al precio de tu proveedor (un proyecto que hace 200 análisis usuales al mes a 0,40 / 1,60 paga USD 1,00), y los datos que salen de AWS cuando ves grabaciones (0,09 por GB).

### Un proyecto en el plan Free de Sypnia Cloud **\[Nube]**

La regla del dueño: **ningún proyecto del plan Free puede costarle a Sypnia más de USD 3 al mes, con todo incluido.** Una regla así solo es cierta si cada línea de la factura tiene un límite. Por eso esta sección hace tres cosas: le pone precio a cada límite en su peor forma, muestra qué líneas no tienen límite hoy, y propone los límites que hacen cumplir la regla.

**Costos fijos, compartidos.** Sypnia Cloud es este mismo despliegue, dimensionado para muchos proyectos, y sus costos fijos los comparten todos:

| Fijo, al mes                                                         | Aritmética                      | USD       |
| -------------------------------------------------------------------- | ------------------------------- | --------- |
| Postgres: `db.t4g.medium` en dos zonas, 100 GB                       | 2 × 0,065 × 730 + 100 × 0,23    | 117,90    |
| Un NAT gateway, para que la base de datos no tenga dirección pública | 0,045 × 730                     | 32,85     |
| La marca del minuto, presupuestada en 10 s por pasada                | 43.200 × 10 GB-s × 0,0000133334 | 5,76      |
| Logs, alarmas, secretos                                              | 10 GB × 0,50 + 0,30 + 1,20      | 6,50      |
| **Fijo**                                                             |                                 | **≈ 163** |

Supuesto, dicho de frente: **500 proyectos comparten un despliegue así**, y cada uno carga USD 0,33. Con 130 proyectos la parte es USD 1,25 y el techo de abajo todavía se cumple; con menos, Sypnia paga el costo fijo sean cuales sean los planes, y el techo es una afirmación sobre cada proyecto adicional. El alojamiento propio de la app privada no está en este número.

**El modelo.** Para la aritmética del plan Free, el modelo de Sypnia Cloud se presupuesta en no más de USD 0,40 por millón de tokens de entrada y 1,60 de salida: un análisis usual es medio centavo, el más grande son dos centavos. Si se elige un modelo más caro, la fila crece en la misma proporción.

**Un proyecto gratuito al 100 % de cada límite, en la peor forma:**

| Límite (propuesto)                                                              | En el límite                                              | Costo unitario, peor forma              | USD al mes |
| ------------------------------------------------------------------------------- | --------------------------------------------------------- | --------------------------------------- | ---------- |
| Eventos recibidos: tope duro en 20.000, cuatro veces los 5.000 eventos contados | 20.000 lotes de un evento                                 | 0,0122 por 1.000 lotes                  | 0,24       |
| …sus sesiones                                                                   | 10.000 sesiones, dos archivos escritos por cada una       | 5,00 por millón de escrituras           | 0,10       |
| …sus consolidaciones                                                            | Una corrida en cada 5 minutos del mes: 8.640 × 0,3 GB-s   | 0,0000133334 por GB-s                   | 0,04       |
| Grabaciones: 50 al mes, de máximo 30 minutos, guardadas 7 días                  | 50 × 180 fragmentos, 36 MB cada una; todas vistas una vez | 0,0021 por guardarla + 0,0033 por verla | 0,27       |
| Comprobaciones de disponibilidad: 1                                             | 43.200 revisiones                                         |                                         | 0,02       |
| Análisis: 50 al mes                                                             | 50 de los más grandes                                     | 0,0204                                  | 1,02       |
| Correos de alerta: 100 al mes, más el resumen diario                            | 131 correos                                               | 0,10 por 1.000                          | 0,01       |
| Pull requests: ninguno                                                          |                                                           |                                         | 0,00       |
| Parte de los costos fijos                                                       | 163 ÷ 500                                                 |                                         | 0,33       |
| **Total**                                                                       |                                                           |                                         | **≈ 2,03** |

El mismo proyecto en los mismos límites, con la forma que tienen las apps reales (4,4 eventos por lote, grabaciones cortas de las que se ve una de cada cinco, análisis usuales), cuesta cerca de **USD 0,65**, la mitad por la parte fija.

**Figura (diagrama aún sin dibujar)**: Lo que le cuesta a Sypnia un proyecto gratuito al mes, por componente. Los análisis del agente son la mitad del peor caso, y por eso su límite es el que más cambia.

Mostrará: GRÁFICA DE BARRAS HORIZONTALES APILADAS, una gráfica con dos barras y una línea vertical de límite. Eje X en USD de 0 a 3,25 con marcas cada 0,50; una línea vertical gruesa en 3,00 con el rótulo «el techo: USD 3». BARRA 1 con el rótulo «Un proyecto gratuito al 100 % de cada límite, peor forma · USD 2,03», segmentos de izquierda a derecha con estos rótulos y anchos exactos: «Análisis de IA · 1,02» (el segmento encendido, color de acento), «Eventos: recibir, guardar, procesar · 0,38», «Parte de los costos fijos · 0,33», «Grabaciones: guardar y ver · 0,27», «Comprobación de disponibilidad · 0,02», «Correo · 0,01». BARRA 2 con el rótulo «Los mismos límites, con la forma de las apps reales · USD 0,65», segmentos: «Parte de los costos fijos · 0,33», «Análisis de IA · 0,25», «Eventos · 0,03», «Comprobación de disponibilidad · 0,02», «Grabaciones · 0,01», «Correo · 0,01». A la derecha de la barra 1, un corchete de 2,03 a 3,00 con el rótulo «margen: 0,97». Bajo la gráfica, una tercera barra rayada que se sale por el borde derecho con una marca de corte, con el rótulo «La propuesta de hoy (20 análisis al día, 5 pull requests, sin tope duro) · más de USD 15», para mostrar que cruza el techo. No hace falta leyenda: los rótulos van en los segmentos. La alternativa de texto lista los seis componentes de cada barra con sus valores.

**Frente a la propuesta de hoy.** `pricing.ts` y [Límites](https://docs.sypnia.com/es/agent/limits) proponen para Free: 5.000 eventos, 50 grabaciones, 7 días, 1 comprobación de disponibilidad, 5 pull requests al mes y 20 análisis al día. Con los mismos precios:

| Línea             | Propuesta de hoy                                                                        | USD al mes, peor forma                            | Veredicto                                                                                    |
| ----------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| Análisis          | 20 al día, 620 al mes                                                                   | 620 × 0,0204 = 12,65                              | Cuatro veces el techo por sí sola. Incluso al tamaño usual son 3,10                          |
| Pull requests     | 5 al mes                                                                                | 5 × 0,30 a 0,60 = 1,50 a 3,00                     | De la mitad del techo a todo el techo. Ya decidido: no van en el plan Free                   |
| Eventos           | 5.000 contados; los eventos que no cuentan y las fallas pasado el límite no tienen tope | Sin techo                                         | Una página que dispara un evento propio en un ciclo, o un error en un ciclo, no tiene límite |
| Grabaciones       | 50, de hasta dos horas cada una                                                         | 50 × (0,0084 + 0,0133) = 1,08                     | Cabe solo si nada más está en su peor caso                                                   |
| Correos de alerta | Sin tope                                                                                | Sin techo                                         | Una comprobación de disponibilidad que sube y baja todo el mes son 43.200 correos: 4,32      |
| **Total**         |                                                                                         | **Más de 15, con dos líneas que no tienen techo** |                                                                                              |

> **Advertencia: Límites propuestos (para que el dueño los confirme)**
>
> Lo que debe cambiar para que el techo se cumpla, y la misma revisión para los planes pagos. Nada de esto se ha aplicado todavía a `pricing.ts` ni a las páginas de Sypnia Cloud.
>
> |                                                                                                      | Free                                             | Builder, USD 10                               | Team, USD 49                                    |
> | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------ | --------------------------------------------- | ----------------------------------------------- |
> | Eventos al mes (contados)                                                                            | 5.000 · igual                                    | 50.000 · igual                                | 500.000 · igual                                 |
> | **Nuevo:** tope duro a todo lo recibido, cuente o no, fallas incluidas                               | 20.000                                           | 200.000                                       | 2.000.000                                       |
> | Grabaciones al mes                                                                                   | 50 · igual                                       | 500 · igual                                   | 5.000 · igual                                   |
> | **Nuevo:** grabación más larga                                                                       | 30 minutos                                       | 2 horas                                       | 2 horas                                         |
> | Análisis                                                                                             | **50 al mes, máximo 10 al día** · eran 20 al día | **200 al mes** · eran 100 al día por proyecto | **1.000 al mes** · eran 500 al día por proyecto |
> | Pull requests al mes                                                                                 | **0** · eran 5                                   | **5** · eran 50                               | **30** · eran 300                               |
> | **Nuevo:** correos de alerta al mes; pasado eso, las alertas siguen en la app y en el resumen diario | 100                                              | 1.000                                         | 5.000                                           |
> | Proyectos, personas, comprobaciones de disponibilidad, días guardados                                | Igual                                            | Igual                                         | Igual                                           |
>
> Pasado el tope duro, la ingesta responde `429 limit_reached` hasta que termina el mes, y se les avisa a los dueños, como en cualquier límite. Los límites son por organización, como en [Planes y límites](https://docs.sypnia.com/es/cloud/plans-and-limits).

**Los planes pagos al 100 % de los límites propuestos.** A un plan pago se le pone precio con la forma que tienen las apps reales, y la peor forma se declara como el riesgo. Un pull request es el número menos seguro de esta página, porque su worker no está diseñado en detalle: se presupuesta en USD 0,30, y 0,60 en el peor caso, por unos 120.000 tokens de entrada y 8.000 de salida con un modelo apto para escribir código.

| USD al mes                                                | Builder, 3 proyectos       | Team, 10 proyectos           |
| --------------------------------------------------------- | -------------------------- | ---------------------------- |
| Eventos: se recibe el doble de los contados, 4,4 por lote | 0,29                       | 3,12                         |
| Grabaciones: cortas, se ve una de cada cinco              | 0,10                       | 1,13                         |
| Comprobaciones de disponibilidad                          | 5 × 0,02 = 0,10            | 25 × 0,02 = 0,50             |
| Análisis, tamaño usual                                    | 200 × 0,005 = 1,00         | 1.000 × 0,005 = 5,00         |
| Pull requests                                             | 5 × 0,30 = 1,50            | 30 × 0,30 = 9,00             |
| Correo: resúmenes y alertas                               | 0,06                       | 0,51                         |
| Parte de los costos fijos                                 | 3 × 0,33 = 0,99            | 10 × 0,33 = 3,30             |
| Pago con tarjeta: 2,9 % + 0,30                            | 0,59                       | 1,72                         |
| **Costo al 100 % de los límites**                         | **≈ 4,63**                 | **≈ 24,28**                  |
| **Margen**                                                | **5,37, 54 %**             | **24,72, 50 %**              |
| Los mismos límites en la peor forma                       | ≈ 24,50                    | ≈ 233                        |
| Con la propuesta de hoy para pull requests (50 y 300)     | 18,13: una pérdida de 8,13 | 105,28: una pérdida de 56,28 |

Tres cosas que leer de aquí:

1. **Los pull requests y los análisis son la factura.** El almacenamiento, los eventos y las grabaciones juntos son menos de un quinto del costo de cualquiera de los dos planes con formas reales. El modelo es más de la mitad.
2. **Los planes pagos no están a salvo en la peor forma, y la exposición es una sola línea:** grabaciones largas que se ven todas. 5.000 grabaciones de dos horas son 720 GB escritos, guardados tres meses y descargados: cerca de USD 154 en un plan de USD 49. Una grabación máxima más corta en los planes pagos, o contar horas de grabación en vez de grabaciones, lo cerraría. Es una pregunta para el dueño, abajo.
3. **Los números de hoy para pull requests pierden plata** en los dos planes pagos, con cualquier forma.

### Preguntas que este modelo deja abiertas

- **El nivel de precio del modelo de Sypnia Cloud.** Todo lo anterior asume 0,40 / 1,60 por millón de tokens. Un modelo de 3,00 / 15,00 hace que los 50 análisis del plan Free cuesten hasta USD 8,55; el mismo techo entonces permite 5.
- **El NAT gateway.** USD 33 al mes para que la base de datos de Sypnia Cloud no tenga dirección pública. Está contado arriba; la referencia de alojamiento propio no lo usa.
- **Las grabaciones en los planes pagos:** un tope por grabación, u horas en vez de una cantidad.
- **El costo de un pull request,** cuando su worker exista y se pueda medir.

## Qué cambió frente al sistema del que sale

| Allá                                                                                                                                    | Aquí                                                                  | Por qué                                                                     |
| --------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| Una función de ingesta, una horaria, una diaria y una semanal, en TypeScript, con un motor de consultas nativo como un binding de 68 MB | Tres funciones por rol, un binario en Rust, sin dependencias nativas  | Un solo programa que leer, arm64, arranques en frío de 300 ms               |
| Un flujo de entrega administrado entre la ingesta y el bucket                                                                           | SQS, con cola de mensajes fallidos y un comando de redrive            | Frescura; objetos nombrados por proyecto; fallas que se pueden ver          |
| La base de datos compartida de la app                                                                                                   | Una base de datos propia del motor                                    | La compartida se quedó sin memoria una vez                                  |
| Retención con reglas de ciclo de vida del bucket y una extensión de cron en la base de datos                                            | La tarea diaria del motor                                             | Igual en cualquier almacén y cualquier Postgres                             |
| El costo estimado una vez, para una app                                                                                                 | Un costo unitario por lote, grabación y análisis, y un techo por plan | Un servicio con plan gratuito debe saber cuánto cuesta un proyecto gratuito |

## Sigue
