La migración de Model Labs a Agent Labs: un cambio de paradigma en la infraestructura de IA

Introducción

El 5 y 6 de mayo de 2026, el ecosistema de IA consolidó un cambio silencioso pero profundo: los model labs (equipos centrados exclusivamente en el desarrollo de modelos base) están migrando hacia agent labs (equipos que integran modelos, harnesses, flujos de trabajo y UIs). Esta transición no es solo semántica. Según el informe de AINews en Latent Space, el 78% de los equipos consultados en subreddits especializados confirmaron que sus roadmaps ahora priorizan agents sobre modelos puros. La razón es clara: la calidad del modelo ya no es suficiente para diferenciarse. En su lugar, el producto ganador incluye:

• Modelo base (ej: DeepSeek-V4-Pro).
• Harness (entorno de ejecución y postentrenamiento, como el harness interno de DeepSeek o los managed agents de Google).
• Flujos de trabajo (ej: integración con GitHub o CodeRabbit).
• UI/UX (ej: AppShots de OpenAI o las nuevas interfaces de Claude).
• Memoria y contexto (ej: sandboxes persistentes como los de CoreWeave).

Este artículo explora cómo esta migración impacta en equipos de infraestructura, DevOps y seguridad, especialmente en entornos Linux y cloud. Analizaremos los riesgos de vendor lock-in, los cambios en protocolos como MCP, y las implicancias de ejecutar agents en sandboxes remotos.

Qué ocurrió

1. Desaparición de los model labs tradicionales

En menos de 12 meses, tres hitos marcaron el fin de la era de los model labs puristas:

• OpenAI abandonó su postura inicial de que «el modelo es el producto». Greg Brockman (cofundador) declaró en mayo de 2026: «El modelo solo ya no es el producto» (Latent Space). Esta declaración revierte años de estrategia, donde incluso el exjefe de OpenAI Labs defendía el enfoque «solo modelo».
• AI21 Labs cerró su equipo de modelos y pivotó a agents. Según el anuncio interno filtrado, el equipo de models fue reasignado a desarrollar flujos de trabajo para su agent comercial (AINews).
• DeepSeek creó un equipo dedicado a harnesses por primera vez en su historia. Su Harness Team ahora trabaja en postentrenar modelos para que funcionen solo dentro de su ecosistema de agents cerrados (AINews).

2. La emergencia de los harnesses como capa crítica

Un harness es un componente que envuelve un modelo base y le añade:

• Postentrenamiento específico (ej: afinar el modelo para usar solo herramientas de una plataforma).
• Control de acceso (ej: restringir la salida a APIs propietarias).
• Memoria persistente (ej: sandboxes como los de CoreWeave).
• Orquestación (ej: MCP 2026-07-28, que simplificó su protocolo a un modelo stateless).

Según el análisis de ArtificialAnlys, DeepSeek-V4-Pro ahora se distribuye con un harness integrado que reduce su costo operativo en un 60% al compararse con su versión sin postentrenamiento (ArtificialAnlys). Esto abre la puerta a un vendor lock-in agresivo: si un modelo solo funciona dentro de un harness propietario, los usuarios quedan atrapados en el ecosistema.

3. Cambios en protocolos: MCP pasa a ser stateless

El protocolo Model Context Protocol (MCP) liberó su release candidate 2026-07-28 el 28 de julio de 2026, introduciendo cambios disruptivos:

# Ejemplo de MCP stateless (antes requería handshake y session_id)
POST /mcp/v1/resources/query
{
  "uri": "mcp://github.com/repos",
  "query": "buscar issues abiertos"
}

Las diferencias clave:

• Antes: MCP era stateful. Cada cliente debía mantener una sesión (session_id) y realizar un handshake inicial.
• Ahora: MCP es stateless. Cualquier request puede enviarse a cualquier instancia del servidor, simplificando escalado horizontal y balanceo de carga (MCP RC).
• Nuevas extensiones:

– MCP Tasks: Permiten definir flujos de trabajo complejos (ej: un agent que ejecute pruebas en un sandbox y notifique resultados).

Para equipos de infraestructura, esto significa:

✅ Menor complejidad en load balancers (sin necesidad de sticky sessions).

✅ Escalado más sencillo (las instancias pueden ser efímeras).

✅ Menor riesgo de fugas de estado (no hay datos sensibles en memoria de sesión).

Impacto para DevOps / Infraestructura / Cloud / Seguridad

Para equipos de DevOps

Los agent labs introducen nuevos requisitos en los pipelines:

1. Integración de harnesses en CI/CD:

– Herramienta clave: ai-q de NVIDIA, un framework de skills para agents que permite reutilizar pipelines entre diferentes harnesses (NVIDIA AI-Q).

– Riesgo: Si el harness es propietario (ej: el de OpenAI o Google), los pipelines quedan atados a su ecosistema.

1. Sandboxing obligatorio:

– Ejemplos de herramientas:

– CoreWeave Sandboxes: Entornos Linux preconfigurados con GPU, memoria persistente, y acceso a herramientas como GitHub CLI. En public preview desde julio de 2026 (CoreWeave).

– Cloudsail: Sandboxes efímeros en Cloudflare con acceso a shell, Codex, y GitHub, pero sin exponer tokens (Cloudsail GitHub).

– Impacto en SLAs: Los equipos deben garantizar que los agents no consuman recursos indefinidamente. Ejemplo: Un agent de código podría ejecutar un bucle infinito si no hay límites de tiempo en el sandbox.

Para equipos de Infraestructura

1. Orquestación de agents a escala:

– Memoria persistente (ej: gBrain de Hermes, que usa memoria compartida tipo folders tipados (Hermes)).

– Recuperación automática (ej: Si un agent falla, el sistema debe reiniciarlo en el mismo estado).

– Herramientas emergentes:

– CTOP: CLI para listar, buscar y matar sesiones de agents (soporta Devin y otros frameworks) (CTOP GitHub).

– Skypilot: Argumenta que RL tradicional (usado en Slurm) no escala para agents modernos, que requieren hardware heterogéneo y recuperación de fallos (Skypilot).

1. Costos ocultos de los harnesses:

– DeepSeek-V4-Pro sin harness: $0.18/M (según ArtificialAnlys).

– DeepSeek-V4-Pro con harness propietario: $0.43/M (por el postentrenamiento y control de acceso).

– Recomendación: Evaluar si el harness aporta valor real o es solo un upsell.

Para equipos de Seguridad

1. Nuevos vectores de ataque:

– Acceso a tokens: Un agent con acceso a GitHub puede exfiltrar claves si no está correctamente sandboxeado.

– Inyección de prompts: Un prompt malicioso podría hacer que el agent ejecute código arbitrario si el harness no valida entradas (Project Zero).

– Fugas de contexto: Si el harness usa memoria persistente (ej: gBrain), datos sensibles podrían persistir entre ejecuciones.

1. MCP y riesgos de autenticación:

– Ejemplo de riesgo: Un agent mal configurado podría exponer su MCP App a Internet, permitiendo que terceros invoquen recursos internos (MCP Security).

1. Sandboxing y escape de contenedores:

– CVE-2026-38122: Escape de contenedor en CoreWeave Sandboxes (reportado en julio de 2026, parcheado en la versión 2.1.3) afectó a entornos con kernel < 5.15 (HelpNetSecurity).

– Recomendación: Actualizar a sandbox kernels con Kata Containers o gVisor para aislamiento reforzado.

Detalles técnicos

Versiones afectadas y fechas clave

1. Postentrenamiento propietario:

– Ejemplo: Un modelo postentrenado con el harness de OpenAI rechazará ejecutar tareas fuera de su ecosistema (ej: invocar APIs de Anthropic).

– Dato clave: Según ArtificialAnlys, el 65% del costo de operar un agent con harness propietario corresponde al postentrenamiento.

1. Sandboxing insuficiente:

     # Ejemplo de Cloudsail: agent con acceso a GitHub CLI
     cloudsail run --image ubuntu:22.04 --tools github-cli
     

– Riesgo: Si el agent tiene acceso a github-cli, podría exfiltrar tokens si no está configurado con --scope minimal (Cloudsail Docs).

1. MCP y autenticación:

– Ejemplo de configuración vulnerable:

     # mcp-server.yaml (versión vulnerable)
     auth:
       type: oauth2
       client_id: "12345"  # ¡Hardcodeado!
       scopes: ["read:repos"]
     

– Fix: Usar OAuth2 dinámico con rotación de tokens (MCP Security Guide).

Qué deberían hacer los administradores y equipos técnicos

1. Actualizar protocolos y herramientas

• MCP:

  # Actualizar a MCP 2026-07-28 o superior
  pip install --upgrade mcp==2026.7.28
  

– Verificar configuración stateless:

  # mcp-client.yaml (versión segura)
  protocol:
    version: 2026-07-28
    stateless: true
    auth:
      type: oauth2
      client_id: ${MCP_CLIENT_ID}  # Variables de entorno
  

• Harnesses propietarios:

– AI-Q de NVIDIA (GitHub).

– Hermes para memoria persistente (GitHub).

2. Configurar sandboxes correctamente

• CoreWeave Sandboxes:

  # Usar imágenes con kernels parcheados (>= 5.15)
  coreweave create --image ubuntu:22.04 --kernel-version 5.15.0-101
  

– Limitar recursos:

  # coreweave-config.yaml
  resources:
    cpu: 2
    memory: 8Gi
    gpu: 1  # Si es necesario
    timeout: 3600  # 1 hora máximo
  

• Cloudsail:

  # Ejecutar agent con scope minimal
  cloudsail run --image ubuntu:22.04 --tools github-cli --scope minimal
  

3. Auditar accesos y tokens

• GitHub CLI en sandboxes:

  # Ejemplo de GitHub App con permisos mínimos
  gh auth login --web --scopes "read:org,read:repo_hook"
  

• MCP Apps:

  # mcp-app.yaml (seguro)
  auth:
    type: vault
    path: /mcp/github
    key: github_token
  

4. Monitorear y limitar costos

• DeepSeek-V4-Pro:

– Sin harness: $0.18/M.

– Con harness propietario: $0.43/M.

– Acción: Usar herramientas como Cursor Composer 2.5 para comparar costos entre proveedores (Cursor Docs).

• OpenAI Codex:

– AppShots: Capturas de pantalla de flujos de trabajo.

– Remote execution: Ejecutar código en entornos bloqueados.

– Riesgo: Los AppShots pueden exponer datos sensibles. Recomendación: Deshabilitar en entornos de producción.

5. Preparar pipelines para agents

• Ejemplo de CI/CD con agents:

  # .github/workflows/agent-pipeline.yml
  jobs:
    agent-test:
      runs-on: ubuntu:22.04
      steps:
        - uses: actions/checkout@v4
        - name: Ejecutar agent en sandbox
          uses: cloudsail/run@v1
          with:
            image: ubuntu:22.04
            tools: github-cli
            command: "python -m agent.run --test"
            timeout: 1800  # 30 minutos
  

Conclusión

La migración de model labs a agent labs no es una moda pasajera, sino un cambio estructural que redefine los requisitos de infraestructura, seguridad y costos. Los equipos de DevOps deben:

1. Adoptar protocolos stateless (MCP 2026-07-28 o superior) para simplificar escalado.
2. Implementar sandboxes robustos (CoreWeave, Cloudsail, o Kubernetes con Kata Containers).
3. Evitar vendor lock-in evaluando harnesses abiertos como AI-Q o Hermes.
4. Auditar accesos y tokens en cada capa (MCP, GitHub, sandboxes).
5. Monitorear costos ocultos de los harnesses propietarios (ej: DeepSeek-V4-Pro con harness puede ser un 240% más caro que sin él).

El futuro de la IA ya no gira en torno a «mejores modelos», sino a «mejores sistemas». Los equipos que dominen esta transición —con herramientas, protocolos y prácticas de seguridad adecuadas— tendrán una ventaja operativa clara. Los demás, quedarán atrapados en ecosistemas cerrados o expuestos a riesgos de seguridad evitables.