X-Ops

De SAM a Agent Mesh: qué cambia para tu plataforma una malla P2P entre agentes

# De SAM a Agent Mesh: qué cambia para tu plataforma una malla P2P entre agentes

Lo que ocurrió, en fechas

El 18 de agosto de 2026 apareció en la organización de Google en GitHub un proyecto sin keynote, sin vídeo de lanzamiento y con un nombre que genera confusión: SAM, Sovereign Agent Mesh. Michal Sutter lo destapó ese mismo día en MarkTechPost. No era un modelo ni un framework de agentes: era una capa de red con licencia Apache-2.0 para que los agentes compartieran herramientas sin abrir nada a internet. La arquitectura tenía tres piezas: un plano de control para identidad y política, unos enrutadores que hacían de transporte y descubrimiento, y un nodo por agente.

El problema era concreto. Los agentes ya vivían en servidores de nube, centros de datos, portátiles, Raspberry Pi y móviles Android, y la forma habitual de que dos colaboraran era exponer scripts internos, endpoints de LLM o APIs privadas a internet. La propuesta era una malla entre pares, zero-config y zero-trust: más parecida a una VPN privada que a una pasarela, pero limitada al repartido de herramientas sobre MCP.

Ocho semanas después el proyecto ya no se llamaba SAM. El repositorio pasó de google/sam a google/agentmesh y el README de la rama principal explica que el nombre se actualizó a Agent Mesh para alinear el proyecto con su papel en el ecosistema. Una revisión de Wavect del 12 de octubre de 2026 ya usaba los nombres nuevos y avisaba de un detalle que va a morder a quien escriba documentación operativa: la versión v0.1.0-rc.9, publicada el 7 de octubre, todavía usaba binarios sam-*. El 2 de noviembre de 2026 salió la v0.2.0, que añadió Ingress y un SDK de Go. El repositorio, creado el 21 de abril de 2026, suma 1182 estrellas y 198 forks.

Para un responsable de plataforma el titular no es que Google haya sacado una malla de agentes. Es que un problema que hasta ahora se resolvía con VPN, túneles y excepciones de cortafuegos tiene ya una alternativa de código abierto, y esa alternativa te pide decisiones a ti en lugar de tomarlas por ti.

La decisión de fondo: qué significa realmente soberano

El término soberano del nombre original era la promesa más interesante y también la más confusa. No significa que el agente sea autónomo ni que el proyecto tenga un ciclo de vida propio. Significa que decides quién entra en la malla, qué identidad se le concede, qué credenciales firma tu despliegue y dónde se ejecuta el software. En un despliegue dedicado controlas cinco cosas: la pertenencia (altas mediante tu proveedor de identidad o mediante tokens de bootstrap que tú emites), la clave de firma (el plano de control la genera y la rota, o la tomas de un fichero PEM con el parámetro de clave de firma y lo relee cada 30 segundos), la política, la revocación y el lugar donde corre cada pieza.

Eso tiene una consecuencia arquitectónica que conviene interiorizar antes de discutir nada más: el plano de control no está en el camino de los datos. Ve altas, renovaciones de credencial, leases de router, informes del catálogo e intercambios de token, pero nunca ve una petición. El tráfico entre nodos va directo o a través de un relay cuando el NAT no deja otra cosa, y el relay solo reenvía texto cifrado: ve que dos pares se hablan, no qué se dicen.

Zero-trust sin pasarela: qué se comprueba en cada llamada

Here está el cambio de fondo, y no es más cifrado. El plano de control verifica un JWT de OIDC, traduce sus afirmaciones a hechos Datalog (el identificador del sujeto se convierte en un hecho de usuario, cada grupo en un hecho de grupo, y el identificador del par se ata como cliente) y sella el resultado en un token Biscuit firmado con su clave Ed25519. Cualquier nodo que posea la clave pública puede verificarlo sin llamar a nadie.

De ahí sale la propiedad que más importa en operación: el nodo que recibe la llamada autoriza en local, sin consulta de permisos en caliente. Cada petición pasa por dos etapas: una que filtra la conexión contra las cachés de baneo y revocación, y otra con dos pasadas del autorizador Biscuit, una para la identidad del propio nodo y otra para la del llamante, más una comprobación base que exige que el identificador del par de la conexión coincida con el del token. Eso último es lo que impide que alguien reutilice una credencial robada desde otra máquina.

La ejecución es de denegación por defecto y sin excepciones incorporadas. Para llamar a algo hace falta un hecho explícito de capacidad, y hasta el catálogo de descubrimiento hay que concederlo a mano. Los servicios se nombran con esquema y nombre, del tipo mcp://calculator o inference://vllm-eu, con comodines admitidos como mcp://build-runner.*.

La consecuencia práctica es un cambio de radio de impacto. En lugar de una clave estática de API con acceso amplio, cada llamada se comprueba criptográficamente y el daño de una credencial filtrada se reduce a lo que esa política permite de forma explícita. Eso no sustituye a la gestión de secretos, pero acota el problema de una forma que un gateway con tokens de larga duración no puede hacer.

Hay además una sutileza de gobernanza que conviene tener presente. La política de la malla define roles con listas de servicios permitidos, servicios que puede publicar, destinos permitidos, etiquetas admitidas, estrechamientos de método y ruta, y hechos Datalog propios; los enlaces sujetan esos roles a identidades. La política se compila en hechos: una lista con mcp://calculator se convierte en un hecho de conjunto de servicios, mcp://* en un hecho de servicios todos y mcp://*.internal en un hecho de sufijo, conservando el punto del comodín. Los nodos descargan el texto cada 15 minutos por defecto, o antes si llega un evento de cambio, así que una concesión nueva alcanza a toda la malla sin reemitir credenciales. Quitar una concesión, en cambio, no es inmediato: los hechos ya emitidos dentro de un token siguen siendo válidos hasta que ese token se refresca o caduca. Si tu proceso de baja de permisos tiene que ser instantáneo, ahí hay un punto ciego que cerrar con revocación explícita.

Las piezas y el descubrimiento entre pares

El nodo es el que corre junto a tu agente y le expone la malla como un servidor MCP local. En agosto el cliente se llamaba sam-node; hoy los binarios se llaman agentmesh-node, agentmesh-router y agentmesh-control-plane, y hay un cuarto, agentmesh-one, que empaqueta plano de control, router y consola en un único ejecutable para despliegues pequeños. El nombre del proyecto y el nombre del binario no siempre coinciden en la misma versión, así que fija ambos a la vez.

Desde el punto de vista del agente la superficie es mínima: un endpoint MCP sobre HTTP en 127.0.0.1:8080, un socket de dominio Unix con modo 0600 que no necesita token, un endpoint compatible con OpenAI para inferencia y un proxy inverso del tipo /mesh/<peer-id>/<tipo>/<nombre>. El agente ve tres herramientas: descubrir servicios remotos, buscar herramientas remotas y llamar a una herramienta remota. El alta del nodo sigue siendo deliberadamente humana: el login se queda con la persona.

El transporte es libp2p. Por defecto el nodo escucha QUIC en el puerto 5001 y TCP en el 5002, anuncia también sus direcciones privadas salvo que se lo digas, y cuando ninguno de los dos extremos puede aceptar conexiones entrantes usa un circuito de relay a través de un router; el hole punching está activado, así que una conexión relayed puede degradar a directa cuando el NAT lo permite. Cada salto va cifrado con un canal seguro ligado a la identidad del par: TLS 1.3 para los pares escritos en Go y los SDK de Node y Python, o Noise para navegadores.

Configuración real para empezar

El arranque es corto:

```bash curl -sL https://google.github.io/agentmesh/install.sh | bash agentmesh-node join https://bananas.sam-mesh.dev agentmesh-node run --daemonize agentmesh-node skill install ```

Ese testnet público es un parque de pruebas sin compromiso de disponibilidad, y la documentación es explícita en que no debes publicar allí nada que no publicarías. Lo que de verdad importa es la política, que se envía al plano de control con el token de administrador:

```bash AUTH_HEADER=$(printf 'Bearer %s' "$(cat ./admin-token)") curl -sS -X POST "$CONTROL_PLANE/policies" \ -H "Authorization: $AUTH_HEADER" \ -H 'Content-Type: application/json' \ --data @policy.json ```

```json { "roles": [ { "name": "contractor", "allowed_services": ["egress://api.github.com"], "allowed_targets": ["*"], "http": [ { "service": "egress://api.github.com", "methods": ["GET"], "paths": ["/repos/acme/*"] } ] } ], "bindings": [ { "role": "contractor", "members": ["group:external"] } ], "egress": [ { "name": "api.github.com", "credential": "github-eu", "served_by": ["pep"] } ] } ```

Ese fragmento dice cuatro cosas. El contratista solo puede llamar al destino de salida, solo con el método GET y solo bajo esa ruta. El destino es un nombre, nunca un valor: el nodo que lo sirve lee la credencial real de un fichero del sistema anfitrión y el plano de control nunca la ve. El rol se ata a un grupo concreto, y el plano de control rechaza de entrada una política que referencie un rol inexistente, que use un prefijo de miembro desconocido o que conceda más de lo que el autorizador Biscuit es capaz de evaluar. Y la aplicación cliente deja de hablar con el proveedor: apunta a la URL base del nodo y usa el token del nodo, de modo que la clave del proveedor nunca está dentro del proceso del agente.

El endurecimiento local va en el fichero de configuración del nodo, y se evalúa antes que las políticas básicas, así que un permiso local puede admitir a un llamante al que la malla no concedió nada y una denegación local anula una concesión de la malla:

```yaml attenuation: checks: - 'check if label("jurisdiction", "eu");' policies: - 'deny if service("mcp", "db-writer"), group("contractors");' ```

Malla o pasarela: cuándo tiene sentido cada una

La respuesta honesta es que no compiten en el mismo terreno. Una pasarela central gana cuando tienes un inventario moderado de servicios, un único dominio de confianza y necesitas observabilidad y facturación centralizadas en un solo sitio. Una malla entre pares gana cuando los agentes cruzan fronteras de red heterogéneas: nube, centro de datos, portátil, borde. Ahí el valor no está en el cifrado, que ya tenías con la VPN, sino en dos cosas concretas: la identidad viaja con el nodo, así que la política se expresa sobre nombres de servicio y no sobre direcciones IP; y el descubrimiento elimina la lista de endpoints que hoy mantienes a mano para cada agente.

El coste es simétrico. Dejas de tener un punto único donde mirar y una credencial de larga duración que rotar, y coges un plano de control que operar, enrutadores que colocar bien, una base de datos que respaldar y una política escrita en Datalog, un lenguaje en el que un error es un error de seguridad, no un error de estilo. Y recuerda el encaje que declara el propio proyecto: el valor aparece cuando los agentes atraviesan más de una frontera de red; una empresa entera dentro de una sola VPC gana muy poco.

Lo que falta para poner esto en producción

Dos advertencias concretas. La primera es de madurez: el proyecto se declara anterior a la versión 1.0, sin compromiso de soporte ni acuerdo de nivel de servicio, y el repositorio mantiene el descargo de que no es un producto de Google. La segunda es de seguridad: la hoja de ruta sitúa las auditorías independientes de la verificación de tokens Biscuit, de la ligadura del identificador de par y de la rotación de claves en la etapa de la versión 1.0.0, es decir, todavía no están hechas.

Y una nota de operación que te ahorra un susto: al subir a la v0.2.0 el esquema de la base de datos del plano de control pasa a la versión 21 con migración automática, los nodos y routers v0.1.1 siguen siendo interoperables y los cambios de API son aditivos, pero no debes retroceder de versión una base ya migrada, porque el binario antiguo no conoce el tipo de recurso Ingress y un guardado de política desde él elimina todas las concesiones de entrada. Haz copia antes de tocar nada.

Esa misma v0.2.0 añadió Ingress, que es la pieza que conecta esta malla con el mundo exterior: un router puede exponer servicios a2a, mcp o inference a clientes HTTP externos, pero bajo las mismas comprobaciones de identidad y política que rigen dentro de la malla, con un límite de 32 MiB por cuerpo y apagado por defecto hasta que lo configuras.

Si tu siguiente trimestre tiene una decisión de plataforma que tomar, la pregunta útil no es si adoptas esta malla. Es qué parte de tu actual maraña de túneles, proxies inversos y credenciales estáticas entre agentes desaparecería si el transporte y la autorización los hiciera la malla, y qué parte seguirías necesitando porque no es un problema de red.

Empieza por un piloto acotado con tu propio plano de control, dos agentes en entornos distintos y una política pequeña que puedas auditar. La decisión no es si esto es el futuro de la red para agentes; es si tu arquitectura actual sobrevive al agente que cruza el centro de datos. Lee el resto del dossier en la documentación oficial del proyecto y monta el piloto antes de que te lo pidan.