Ir al contenido

Cómo funciona

El agente propone una sentencia. PostgreSQL la verifica y decide.

Primero en simple y después el detalle: el problema, el mecanismo paso a paso, por qué va dentro de la base, lo que está medido y lo que este sitio no afirma.

En simple

Tu empresa quiere usar IA con sus datos reales. La pregunta es qué pasa cuando la IA se equivoca.

Sin tecnicismos. Lo técnico viene más abajo, para tu equipo.

  1. Hoy 01

    Conectas un asistente de IA a tu base de datos

    Para que responda preguntas y haga tareas: actualizar un cliente, revisar pedidos. Funciona bien. Hasta que un día entiende mal una instrucción y pide borrar todos los pedidos del mes.

  2. Sin la puerta 02

    La base de datos obedece

    Es una orden válida de un usuario válido. Los pedidos desaparecen. Te enteras cuando llama un cliente.

  3. Con la puerta 03

    La base de datos revisa antes de hacer

    No ejecuta lo que la IA dice: lo verifica, muestra exactamente qué cambiaría (8 pedidos borrados) y lo rechaza porque supera lo permitido. El cambio legítimo de un cliente sí pasa. Y todo queda registrado.

Una forma de verlo

Piensa en cómo se paga una factura en una empresa seria: cualquiera puede proponer un pago, pero nadie lo ejecuta solo. Se revisa, se ve el monto exacto, se aprueba dentro de un límite y queda en los libros. Eso hace la puerta con cada instrucción que una IA le da a tu base de datos.

Qué gana tu empresa

  • Puedes usar IA con datos reales

    Sin copiar tus datos a otro lado ni confiar en que el modelo "se porte bien". La protección está en la base de datos misma.

  • Cada acción queda registrada

    Qué propuso la IA, qué se aprobó, qué se rechazó y por qué. Evidencia para una auditoría, y para dormir tranquilo.

  • Nada cambia para tu equipo

    Es PostgreSQL, la base de datos que probablemente ya usas. Tu equipo técnico lo instala en una tarde; no hay plataforma nueva que aprender.

Lo que no es

No es un chatbot ni reemplaza a tu equipo. No decide por ti qué puede hacer la IA: tu equipo pone los límites y la base de datos los hace cumplir.

El problema

El agente conecta. El modelo alucina. La base ejecuta.

  1. 01

    Hoy un agente llega a PostgreSQL con un rol y una conexión. Desde ese momento, para la base es indistinguible de la aplicación.

  2. 02

    Cada garantía vive en el servidor MCP o en el prompt, fuera de la base. PostgreSQL nunca se entera de qué se verificó.

  3. 03

    Cuando el modelo se equivoca, lo que llega al servidor es SQL válido con permisos válidos. Y se ejecuta.

No es un problema de modelo. Es que la decisión está en el lugar equivocado.

psql · sesión del agente "assistant" · imagen pública
assistant=> (agent, max_rows 5, no DDL)
DELETE FROM orders;
ERROR: pg_agent_gate: this session belongs to agent "assistant": it proposes, it does not execute
DETAIL: DELETE does not reach the database from an agent session
SELECT agent_gate.propose('drop table orders', 'fix schema');
{"ok": false, "kind": "ddl", … "checks": [… {"check": "kind_allowed", "detail": "T_DropStmt changes the schema or the server, and this agent is not allowed DDL", "passed": false}], "proposal": 1, …}
SELECT agent_gate.commit(2); -- proposal 2: DELETE FROM orders
{… "rows": [{"after": null, "before": {"id": 1, "total": 1000}}, …], … "reason": "it touched 8 rows, more than this agent may change in one statement", "outcome": "aborted", … "rows_affected": 8, …}
SELECT agent_gate.commit(3); -- proposal 3: UPDATE orders SET total = 999 WHERE id = 1
{… "rows": [{"after": {"id": 1, "total": 999}, "before": {"id": 1, "total": 1000}}], … "outcome": "kept", … "rows_affected": 1, …}

Salida real de ghcr.io/latamflows/ygg-pg:0.3.6 (pg_agent_gate 0.4.3), 13-11-2026; las respuestas JSON van recortadas con "…". El setup está en la sección de prueba.

Cómo funciona

Propone. Verifica. Decide.

pg_agent_gate mueve la decisión adentro de PostgreSQL. Un agente no corre SQL: tiene siete verbos y, en una sesión que le pertenece, no puede hacer nada más. Ni DELETE, ni DO, ni COPY, ni PREPARE.

  1. agent_gate.discover() 01

    Qué puedo tocar

    Tablas, vistas y funciones sobre las que el agente tiene privilegios, con columnas, tipos, claves y restricciones. Sale del catálogo vivo, no de un prompt.

  2. agent_gate.propose() 02

    Una sentencia, nada corre

    El parser, el analyzer, el rewriter y el planner de PostgreSQL la aceptan o la rechazan. Cada check queda registrado con su veredicto y su razón.

  3. agent_gate.dry_run() 03

    El efecto exacto, sin guardar

    Corre en una subtransacción y se deshace: filas tocadas, antes y después de cada fila, y si las aserciones vinculadas seguirían cumpliéndose.

  4. agent_gate.commit() 04

    Se guarda si todas las guardas están de acuerdo

    Verifica de nuevo, ejecuta con los privilegios del propio agente y guarda. Si tocó más filas que su límite o rompió una aserción, se deshace. Una propuesta se confirma una sola vez.

Los checks de propose

  • parses
  • single_statement
  • kind_allowed
  • no_writing_cte
  • keeps_its_context
  • no_amplification
  • no_opaque_function
  • resolves

Nada se reimplementa: cada check es PostgreSQL mismo.

Está aplicado por hooks dentro del servidor. No hay cliente, driver ni protocolo que lo esquive: lo que la sesión escribe no se ejecuta, salvo los siete verbos.

Sin puerta / con puerta

Sin pg_agent_gate
an ordinary role, the way an agent connects today
database now: customers: 4 · orders: 8
DELETE FROM orders
database now: customers: 4 · orders: 0
DROP TABLE customers CASCADE
database now: customers: TABLE GONE · orders: 8
set_config('app.tenant_id', '2') + SELECT
Iris|iris@TWO.example
Juan|juan@TWO.example
Con pg_agent_gate
the same role, registered as an agent (max_rows 5, no DDL)
DELETE FROM orders
ERROR: pg_agent_gate: this session belongs to agent "assistant": it proposes, it does not execute
DROP TABLE customers CASCADE
ERROR: pg_agent_gate: this session belongs to agent "assistant": it proposes, it does not execute
…and the same, PROPOSED through the gate:
propose + commit: DELETE FROM orders
commit: aborted -- it touched 8 rows, more than this agent may change in one statement
propose: DROP TABLE customers
refused at propose -- kind_allowed: T_DropStmt changes the schema or the server, and this agent is not allowed DDL
propose: a read that moves the tenant from inside the statement
refused at propose -- keeps_its_context: set_config() would change, while the proposal runs, a parameter …
database now: customers: 4 · orders: 8
dry_run: UPDATE customers SET email = … WHERE id = 1
"rows": [{"before": {"email": "ana@one.example"}, "after": {"email": "ana@new.example"}}] (nothing kept)
commit
kept, Ana's email is now ana@new.example

Lo que ve un agente

Donde un servidor común devuelve un conteo de filas después de ejecutar, la puerta devuelve el catálogo que el agente puede tocar, cada check con su veredicto y el antes/después exacto del cambio, antes de guardar nada.

psql · session of agent "billing"sql
-- what may I touch? derived from the live catalog and MY privileges
SELECT agent_gate.discover('customers');

-- propose one statement: nothing runs
SELECT agent_gate.propose(
  'update customers set plan = ''pro'' where id = $1::int',
  'upgrade the customer who asked for it',
  ARRAY['1']);
--  {"proposal": 42, "ok": true, "kind": "write", "estimated_rows": 1,
--   "checks": [{"check": "parses",           "passed": true},
--              {"check": "single_statement", "passed": true},
--              {"check": "kind_allowed",     "passed": true},
--              ... no_writing_cte, keeps_its_context, no_amplification, no_opaque_function, resolves]}

-- see the exact effect, then nothing is kept
SELECT agent_gate.dry_run(42);
--  {"outcome": "rolled_back", "rows_affected": 1,
--   "rows": [{"before": {"id": 1, "plan": "free"}, "after": {"id": 1, "plan": "pro"}}]}

-- make it real, if every guard still agrees
SELECT agent_gate.commit(42);
--  {"outcome": "kept", "rows_affected": 1}

Sin MCP en el medio

El modelo escribe SQL. Sin servidor MCP, sin HTTP y sin JSON entre el agente y tus datos.

Lo habitual es poner un servidor MCP entre el modelo y la base: ese servidor guarda la conexión, le entrega al modelo una lista de herramientas y ejecuta lo que el modelo pide. Acá esa pieza no existe. El agente llega por psql, un driver o SQL directo: la sentencia viaja por el protocolo nativo de PostgreSQL, sin HTTP ni JSON-RPC en el camino, y lo que decide está dentro de la base. Para un cliente que solo habla MCP hay un adaptador, pero es compatibilidad, no el producto.

Lo habitual

  1. Modelo
  2. Servidor MCP
  3. PostgreSQL

Los datos viajan como JSON-RPC. El modelo decide, el servidor obedece y la base ejecuta.

Con pg_agent_gate

  1. Modelo
  2. SQL nativo
  3. PostgreSQL + la puerta

Protocolo nativo de PostgreSQL: sin HTTP y sin JSON. Con el modelo en proceso (ygg-agent 0.2.0), sin HTTP de punta a punta. El modelo propone y PostgreSQL decide.

ygg-agent 0.2.0 · Python

El loop entre el modelo y PostgreSQL, en un solo proceso

El modelo escribe una sentencia; la puerta la verifica, la ejecuta bajo los límites del agente y la registra; el veredicto vuelve al modelo. Sin servidor MCP, sin esquema de herramientas en el contexto del modelo y sin JSON entre el modelo y sus datos. Desde 0.2.0 el modelo puede correr dentro del mismo proceso (un archivo GGUF cargado con llama.cpp): sin servidor de modelo y sin HTTP, la única conexión que se abre es la de PostgreSQL. También habla con cualquier servidor /v1/chat/completions: llama.cpp, vLLM, Ollama u OpenAI.

ygg-agent en GitHub →

pg_phasevec (preview 0.x) · C++ sobre llama.cpp

El modelo que lee corre al lado de la base

El lector de referencia de pg_phasevec carga el modelo con llama.cpp dentro de su propio proceso y habla con la base directamente: sin HTTP y sin un servicio en el medio. Antes de leer le prueba a la base, con el sha256, que los pesos que cargó son los que se registraron.

El lector, en el repo →

pg_grammar_guard · GBNF

El nombre equivocado no se puede escribir

pg_grammar_guard genera, desde el catálogo vivo, una gramática GBNF, que es el formato de llama.cpp. Con ella el muestreador decide token por token, y un nombre que no existe queda fuera de su alcance.

pg_grammar_guard en GitHub →

La tubería: lo que cuesta el JSON

MCP es JSON-RPC, y JSON no tiene entero de 64 bits, ni decimal exacto, ni binario. La garantía de la puerta es la misma por cualquier camino; lo que cambia es la tubería por la que viajan tus datos.

El mismo datoNativo, por el protocolo de PostgreSQLForzado a pasar por JSON
El id 9007199254740993 exacto 9007199254740992: un número JSON es un double IEEE
numeric(40,12) exacto se pierde, salvo que viaje como texto
Binario los bytes, tal cual texto en base64, más largo

Se reproduce con make transfer en el repo de pg_agent_gate. No usa datos reales.

Medido con pg_agent_gate 0.4.0, con la misma puerta detrás de ambos

  • 5× menos tokens de prompt usó el agente sin MCP que por MCP (24k contra 126k en 13 tareas).
  • 13× más rápido terminó cada tarea: una mediana de 14 s contra 185 s.

La seguridad no viene de quitar el MCP: viene de que decida la base. Sin MCP es más eficiente y no deja el control en el conector.

Si tu cliente solo habla MCP, hay un adaptador (gated-mcp) que se conecta con el rol del agente y no tiene poder propio: solo puede llamar a la puerta.

Ver la corrida →

Por qué dentro de la base

Hay cuatro lugares donde poner la última palabra. Solo uno no se puede esquivar.

Reglas en el prompt, un proxy con guardrails, un middleware a medida o la base misma. No se excluyen: el prompt sigue guiando y un proxy puede seguir ahí. Lo que cambia es quién decide al final.

Criterio Reglas en el promptProxy o MCP server con guardrailsMiddleware a medidapg_agent_gate, dentro de PostgreSQL
¿Quién hace cumplir la regla? El modelo, si la recuerda Un proceso aparte, delante de la base Tu código El servidor PostgreSQL, por hooks
¿Se esquiva conectando por otro lado (psql, un driver)? Sí Sí, si alguien conecta directo Sí, si alguien conecta directo No: en la sesión del agente no se ejecuta SQL
¿Ve el efecto real antes de guardar? No Lo estima desde afuera Depende de lo que construyas Sí: PostgreSQL lo mide (filas, antes y después)
¿Registro que nadie puede editar? No Los logs del proxy Lo que construyas Append-only en la base; sobrevive a pg_dump
¿Depende del modelo o del proveedor de IA? Sí En parte No No: el agente solo necesita hablar SQL
¿Qué cuesta operarlo? Tokens en cada llamada Un servicio más que mantener Meses de desarrollo y mantención Una extensión dentro de PostgreSQL, sin otro servicio

La columna de la puerta sale del README de pg_agent_gate y de sus suites de prueba. Las otras tres describen el enfoque en general, no un producto en particular.

Medido con pg_agent_gate 0.4.0

Cada número sale de una corrida pública que cualquiera puede volver a correr.

  • 0/7

    tareas trampa que se escaparon con la base decidiendo; a través de un MCP server popular de Postgres, 4 de 7. Mismo modelo, mismas tareas, un superusuario revisando qué cambió de verdad.

    Fuente →

  • 5 ×

    menos tokens de prompt usó el agente sin MCP que por MCP, con la misma puerta detrás de ambos (24k contra 126k en 13 tareas).

    Fuente →

  • 13 ×

    más rápido terminó cada tarea sin MCP: una mediana de 14 s contra 185 s, en un runner de CI solo CPU que cualquiera puede volver a correr.

    Fuente →

  • 6 s

    de mediana por tarea al escribir una sentencia y dejar que la base decida.

    Fuente →

Todas las cifras se midieron con pg_agent_gate 0.4.0, no con la versión actual. Corrida de referencia: la CI del repo agent-gate-demo, en un runner de GitHub solo CPU; cada cifra está atada a su dato crudo con sha256 en pg-evidence. Encontramos un hueco nosotros mismos (un modelo en loop partió un borrado rehusado en tajadas legales) y lo cerramos en 0.4.0: un presupuesto de escritura por agente, encendido por defecto.

Lo que decimos y lo que no

El producto se vende mostrando que funciona.

  • La imagen pública es un preview

    Corre PostgreSQL 19 release candidate. Sirve para evaluar el ecosistema, no para producción. Para eso existe la edición Enterprise.

  • Red Hat: partner, contenedor no certificado

    LatamFlows es partner de Red Hat; la certificación del contenedor es el próximo paso. La imagen ygg-pg Enterprise 0.3.1 (pg_agent_gate 0.4.3) no está certificada.

  • La seguridad tiene límites, y están escritos

    pg_agent_gate documenta su modelo de amenazas y lo que no cubre. Léelo antes de confiar: la puerta acota lo que el agente nombra, no su intención.

    Threat model y lo que no cubre →
  • Sin clientes ni números inventados

    No hay testimonios, logos ni cifras de uso en esta página porque no los vamos a inventar. Lo que sí hay se puede verificar en los repos.

    Ver los repos →

Contacto

Escríbenos. Te contactamos nosotros.

Edición Enterprise, auditoría de seguridad o integración de agentes con tu base: un correo con dos líneas sobre tu caso basta. Respondemos en español y en inglés.

Correo

manu@latamflows.com

El correo lo lee una persona. Si prefieres escribir directo, el buzón está arriba.

O cuéntanos acá

Solo usamos estos datos para responderte. Sin listas ni newsletters.

Quién está detrás

Manuel Reyes Bravo

Las siete extensiones, la imagen y los aportes al núcleo de PostgreSQL los firma Manuel Reyes Bravo, desde Chile. Para hablar de código, de los repos o de las listas de PostgreSQL, su correo personal:

Correo personal

manuelreyesbravo@gmail.com

También por issues en GitHub: pg_agent_gate/issues

Pruébala Hablar