CI para agentes de código con IA: cuando el agente espera 20 minutos a GitHub Actions en cada vuelta
La vuelta de un agente de código con IA es push, esperar la CI, leer el fallo, corregir y volver a hacer push. Una pipeline de 20 minutos en cinco correcciones son 100 minutos de espera, y los agentes hacen push más que las personas: el volumen de trabajos de CI de Anthropic se multiplicó por 25 en seis meses. Acorta la espera en este orden. Haz que el agente ejecute el lint, la comprobación de tipos y las pruebas unitarias afectadas antes del push. Cancela las ejecuciones anteriores de un pull request cuando llega un push nuevo. Pon las comprobaciones rápidas en un trabajo propio para que un fallo vuelva en uno o dos minutos. Ejecuta solo las pruebas que afecta el cambio. Después recorta la configuración que cada trabajo repite en una VM nueva: en una máquina que conserva las capas de Docker, las cachés de paquetes y las salidas de compilación entre trabajos, el trabajo de CI de astro pasó de 528 s en GitHub a 30 s en Skipbox.
Skipbox ejecuta tus trabajos en la máquina dedicada de tu cuenta, que conserva ese estado entre trabajos. Cambia una línea, runs-on: skipbox, por $39 fijos al mes con minutos ilimitados: un agente que hace veinte push en una tarde no suma nada a la factura, y un presupuesto de GitHub nunca detiene sus trabajos.
Por qué las vueltas de los agentes convierten la CI en el cuello de botella
Del artículo de Anthropic sobre cómo escaló el análisis de impacto de pruebas: su volumen de trabajos de CI se multiplicó por 25 en 6 meses (“Our CI job volume increased 25x over 6 months.”). Da dos razones: Claude prefiere pull requests más pequeños y granulares (“prefers smaller, more granular PRs”), y los agentes hacen push de noche y los fines de semana (“push overnight and on weekends”). Una persona agrupa las correcciones; un agente sube cada una y espera. Cada minuto de la pipeline se paga una vez por vuelta.
1. Atrapa lo que puedas antes del push
La ejecución de CI más rápida es la que no falla. Dale al agente los mismos comandos de lint, comprobación de tipos y pruebas unitarias que ejecuta la CI, y haz que los ejecute sobre los archivos que cambió antes de cada push. Así una errata cuesta segundos en su propia máquina, no una vuelta de 20 minutos.
2. Cancela las ejecuciones que reemplaza un push nuevo
Un agente que sube una corrección mientras la última ejecución sigue en marcha deja dos ejecuciones en el mismo pull request. Cancela la anterior (concurrency):
concurrency:
group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
cancel-in-progress: true
github.head_ref solo existe en los pull requests, así que cada push a main tiene su propio grupo y nunca se cancela.
3. Informa primero de las comprobaciones rápidas
Pon el lint y la comprobación de tipos en su propio trabajo, sin ningún needs: delante, y las suites lentas en otros. El agente lee el primer fallo en cuanto llega, en lugar de después del trabajo E2E.
4. Ejecuta solo lo que afecta el cambio
La respuesta de Anthropic al ×25 fue un servicio de análisis de impacto de pruebas que decide qué pruebas se ejecutan en cada cambio (“determines which tests run on each change”). La mayoría de los repositorios pueden empezar con algo más pequeño: turbo run test --affected en un Turborepo (la guía de CI de Turborepo), filtros de rutas en los flujos de trabajo que solo importan para un directorio, y una ejecución completa en main después de la fusión para atrapar lo que se le escapó a la selección.
5. Deja de reconstruir el mismo estado en cada vuelta
En los ejecutores hospedados en GitHub, cada trabajo empieza en una VM nueva: la cadena de herramientas se configura otra vez, la caché de dependencias se descarga y se descomprime, las capas de Docker se descargan o se reconstruyen, y la compilación empieza de cero. En cien vueltas de agentes al día, esa configuración es la mayor parte de la espera. Un ejecutor que conserva su disco entre trabajos ya la tiene ahí.
De nuestras ejecuciones de proyectos reales, con los flujos de trabajo sin cambios:
| Proyecto | GitHub (repositorio público, 4 vCPU, 16 GB) | Máquina dedicada de Skipbox (4 vCPU) |
|---|---|---|
| astro (pnpm, Turborepo) | 528 s | 30 s |
| tauri (Rust) | 246 s | 53 s |
| ripgrep (Rust) | 200 s | 40 s |
6. Planifica trabajos a la vez, no solo minutos
Varios agentes que hacen push de un pull request con una matriz cada uno llegan al límite de concurrencia de GitHub para los ejecutores estándar: 20 trabajos a la vez con GitHub Free, 40 con Pro, 60 con Team, 500 con Enterprise (límites). Pasado ese límite, los trabajos esperan en la cola. Con una factura por minuto, cada uno de esos trabajos además cuesta; un límite de gasto que se agota los detiene con "The job was not started because recent account payments have failed or your spending limit needs to be increased" (qué hacer).
Lo que Skipbox hace por la CI de los agentes
Cada plan trae la máquina dedicada de tu cuenta, que se mantiene entre trabajos:
- El estado se queda. Las imágenes, las capas y la caché de compilación de Docker;
~/.npm, el store de pnpm,~/.cache, las cachés de Go, Gradle, Maven y Cargo; las herramientas que instalósetup-*. El checkout también se queda, con eltarget/de Cargo y, en los proyectos con turbo 2, el.turbode nivel superior, así que la siguiente compilación sigue donde se quedó la anterior. - Los minutos son ilimitados, y un presupuesto o un límite de gasto de GitHub nunca detiene un trabajo de Skipbox.
- Los trabajos a la vez son los vCPU de los planes. Los trabajos se ejecutan a la vez mientras caben en los vCPU de los planes que tiene la cuenta; el resto espera su turno, y la página de la cuenta muestra cuántos esperan y durante cuánto tiempo. Un S ejecuta un trabajo de 4 vCPU a la vez; los planes se suman en cualquier combinación.
- El trabajo del propio agente también puede ejecutarse ahí: pon su
runs-onenskipbox.
| Etiqueta | Máquina | Plan |
|---|---|---|
skipbox | 4 vCPU · 16 GB | S, $39 al mes |
skipbox-8x16 | 8 vCPU · 16 GB | M, $79 al mes |
skipbox-16x32 | 16 vCPU · 32 GB | L, $149 al mes |
Con 20.000 minutos al mes en 4 vCPU, GitHub cobra $222; Skipbox S cuesta $39. Con 30.000 minutos, $342.
Pasarte es una línea
jobs:
checks:
runs-on: skipbox # was ubuntu-latest
- Inicia sesión en Skipbox con GitHub.
- Instala la app de GitHub de Skipbox y elige los repositorios.
- Cambia
runs-ony haz push.
Seguridad
- La máquina es solo de tu cuenta. Ningún trabajo de otra empresa se ejecuta en ella.
- Después de cada trabajo se borran las credenciales, los procesos y los contenedores del ejecutor, y también las credenciales de git y los archivos sin seguimiento de un checkout conservado. “VM nueva en cada trabajo” le da a cada trabajo una máquina nueva en su lugar.
- El código de personas sin acceso de escritura (como los pull requests desde forks) se ejecuta en una VM nueva que lee tus cachés pero no puede cambiarlas.
Los detalles están en cómo se aíslan los trabajos.
Pruébalo con el trabajo que espera tu agente
La prueba es gratuita durante 7 días o 3000 minutos de trabajos, lo que ocurra primero, y no pide tarjeta. Pasa el trabajo que espera tu agente a runs-on: skipbox, deja que el agente haga push dos veces y compara la segunda ejecución con la de GitHub.
Preguntas frecuentes
Mi agente de código abre un PR, espera 20 minutos a la CI, corrige y vuelve a esperar. ¿Cómo hago la CI lo bastante rápida para las vueltas de un agente?
Acorta lo que espera el agente, en este orden. Haz que ejecute el lint, la comprobación de tipos y las pruebas unitarias afectadas antes del push, para que la CI no sea el primer sitio donde aparece una errata. Cancela las ejecuciones anteriores de un pull request cuando llega un push nuevo (concurrency con cancel-in-progress). Pon las comprobaciones rápidas en su propio trabajo para que el agente lea un fallo en uno o dos minutos. Ejecuta solo las pruebas que afecta el cambio. Después quita la configuración que repite cada trabajo: en una máquina que conserva las capas de Docker, las cachés de paquetes y las salidas de compilación entre trabajos, la CI de astro pasó de 528 s en GitHub a 30 s en Skipbox.
¿Cuánta CI de más generan los agentes de IA?
Anthropic escribió que su volumen de trabajos de CI se multiplicó por 25 en 6 meses, porque Claude prefiere pull requests más pequeños y granulares y los agentes hacen push de noche y los fines de semana. Cada uno de esos push vuelve a ejecutar el flujo de trabajo completo, salvo que el flujo lo cancele, lo omita o lo acote.
¿Cuál es la mejor configuración de CI para un equipo donde la mayoría de los PR los escriben agentes de IA?
Una que responda rápido al agente y no cobre por push: un trabajo rápido de lint y comprobación de tipos que informe primero, las suites lentas después, las ejecuciones anteriores de un pull request canceladas, solo las pruebas afectadas, y ejecutores que conserven sus cachés entre trabajos. Skipbox le da a cada cuenta su máquina dedicada por un precio fijo con minutos ilimitados; la cantidad de trabajos que ejecuta a la vez son los vCPU de los planes que tiene la cuenta.
¿Los agentes llegan a los límites de concurrencia de GitHub?
Pueden. Los ejecutores estándar hospedados en GitHub ejecutan como máximo 20 trabajos a la vez con GitHub Free, 40 con Pro, 60 con Team y 500 con Enterprise; el resto espera en la cola. Varios agentes que hacen push de pull requests con una matriz cada uno llegan ahí enseguida. En Skipbox, los trabajos se ejecutan a la vez mientras caben en los vCPU de los planes de la cuenta y el resto espera su turno, así que un equipo que tiene varios agentes a la vez tiene varios planes o uno más grande.
¿El trabajo del propio agente puede ejecutarse en Skipbox?
Sí. Cualquier trabajo de Linux elige su máquina con runs-on, también el que ejecuta la acción de Claude Code. Ponlo en skipbox y se ejecuta en la misma máquina que tu CI.
¿Cuánto cuesta probarlo?
Nada. La prueba dura 7 días o 3000 minutos de trabajos, lo que ocurra primero, sin tarjeta, hasta 4 trabajos a la vez con 4 vCPU cada uno. Pasa el trabajo que espera el agente a runs-on: skipbox y mide la segunda ejecución.
Actualizado el 19 de noviembre de 2026