# CI para agentes de IA: quando o agente espera 20 minutos pelo GitHub Actions a cada volta

> A volta de um agente de IA para programação é push, esperar o CI, ler a falha, corrigir, push de novo, então um pipeline de 20 minutos custa 100 minutos em cinco correções. Encurte a espera nesta ordem: verificações que o agente roda antes do push, execuções superadas canceladas, verificações rápidas primeiro, só os testes afetados e uma máquina que guarda os caches entre os trabalhos. O Skipbox roda esses trabalhos na sua máquina dedicada a partir de $39 por mês, com minutos ilimitados.

A volta de um agente de IA para programação é push, esperar o CI, ler a falha, corrigir, push de novo. Um pipeline de 20 minutos em cinco correções são 100 minutos de espera, e os agentes fazem mais push que as pessoas: o volume de trabalhos de CI da Anthropic cresceu 25x em seis meses. Encurte a espera nesta ordem. Faça o agente rodar o lint, a checagem de tipos e os testes unitários afetados antes do push. Cancele as execuções antigas de um pull request quando chegar um push novo. Ponha as verificações rápidas em um trabalho próprio, para uma falha voltar em um ou dois minutos. Rode só os testes que a mudança afeta. Depois, corte a configuração que cada trabalho repete em uma VM nova: em uma máquina que guarda as camadas do Docker, os caches de pacotes e as saídas de build entre os trabalhos, o trabalho de CI do astro foi de 528 s no GitHub para 30 s no Skipbox.

O Skipbox roda os seus trabalhos na máquina dedicada da sua conta, que guarda esse estado entre os trabalhos. Troque uma linha, `runs-on: skipbox`, por $39 fixos por mês com minutos ilimitados: um agente que faz push vinte vezes em uma tarde não acrescenta nada à fatura, e um orçamento do GitHub nunca para os trabalhos dele.

- O CI do astro: 528 s no GitHub, 30 s no Skipbox, com as saídas de build guardadas desde o último trabalho
- Minutos ilimitados: cada push de agente, cada correção de revisão e cada nova execução estão dentro do preço fixo
- As camadas do Docker, os caches de pacotes e as ferramentas ficam na sua máquina, então cada volta pula a reinstalação

**GitHub Actions a preço fixo, minutos ilimitados** O Skipbox roda os seus trabalhos do GitHub Actions na sua própria máquina dedicada: $39 por mês, não importa quantos minutos você rode. As camadas Docker e o cache de dependências ficam entre os trabalhos, então o próximo trabalho começa na hora.

Um executor de 4 vCPU, 20.000 minutos por mês: GitHub $222 → Skipbox $39. Você economiza $183 todo mês.

A mudança é uma linha: `runs-on: skipbox`.

[Começar meu teste grátis de 7 dias](https://app.skipbox.dev/sign-in?ref=g-ci-for-ai-coding-agents-pt-br)

## Por que as voltas dos agentes fazem do CI o gargalo

Segundo o [artigo da Anthropic sobre escalar a análise de impacto de testes](https://claude.com/resources/articles/agentic-coding-is-straining-ci-heres-how-we-scaled-test-impact-analysis-at-anthropic), o volume de trabalhos de CI dela cresceu 25x em 6 meses. O artigo dá dois motivos: o Claude prefere pull requests menores e mais granulares, e os agentes fazem push de madrugada e nos fins de semana. Uma pessoa junta as correções; um agente faz push de cada uma e espera. Cada minuto do pipeline é pago uma vez por volta.

## 1. Pegue o que der antes do push

A execução de CI mais rápida é a que não falha. Dê ao agente os mesmos comandos de lint, checagem de tipos e testes unitários que o CI roda, e faça-o rodá-los nos arquivos que mudou antes de cada push. Um erro de digitação passa a custar segundos na máquina dele, não uma volta de 20 minutos.

## 2. Cancele as execuções que um push novo substitui

Um agente que faz push de uma correção enquanto a última execução ainda roda deixa duas execuções no mesmo pull request. Cancele a mais antiga ([concurrency](https://docs.github.com/en/actions/how-tos/write-workflows/choose-when-workflows-run/control-workflow-concurrency)):

```yaml
concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true
```

O `github.head_ref` só existe em pull requests, então cada push no `main` ganha o próprio grupo e nunca é cancelado.

## 3. Responda primeiro com as verificações rápidas

Ponha o lint e a checagem de tipos em um trabalho próprio, sem nenhum `needs:` na frente deles, e as suítes lentas em outros. O agente lê a primeira falha assim que ela chega, em vez de depois do trabalho E2E.

## 4. Rode só o que a mudança afeta

A resposta da Anthropic ao 25x foi um serviço de análise de impacto de testes que decide quais testes rodam em cada mudança. A maioria dos repositórios pode começar menor: `turbo run test --affected` em um Turborepo ([guia de CI do Turborepo](https://turborepo.dev/docs/crafting-your-repository/constructing-ci)), filtros de caminho nos workflows que só importam para um diretório, e uma execução completa no `main` depois do merge para pegar o que a seleção deixou passar.

## 5. Pare de reconstruir o mesmo estado a cada volta

Nos executores hospedados pelo GitHub, cada trabalho começa em uma VM nova: o toolchain é configurado de novo, o cache de dependências é baixado e descompactado, as camadas do Docker são baixadas ou refeitas e o build começa do nada. Em cem voltas de agente por dia, essa configuração é a maior parte da espera. Um executor que guarda o disco entre os trabalhos já tem tudo lá.

Das [nossas execuções de projetos reais](https://skipbox.dev/pt-br/guides/rust-cache-slow-rust-ci), com os workflows sem alteração:

| Projeto | GitHub (repositório público, 4 vCPU, 16 GB) | Máquina dedicada do Skipbox (4 vCPU) |
|---|---|---|
| astro (pnpm, Turborepo) | 528 s | **30 s** |
| tauri (Rust) | 246 s | **53 s** |
| ripgrep (Rust) | 200 s | **40 s** |

## 6. Planeje trabalhos simultâneos, não só minutos

Vários agentes, cada um fazendo push de um pull request com uma matriz, chegam ao limite de concorrência do GitHub para executores padrão: 20 trabalhos ao mesmo tempo no GitHub Free, 40 no Pro, 60 no Team, 500 no Enterprise ([limites](https://docs.github.com/en/actions/reference/limits)). Passando disso, os trabalhos entram na fila. Em uma fatura por minuto, cada um desses trabalhos também custa; um limite de gastos que se esgota os para com "The job was not started because recent account payments have failed or your spending limit needs to be increased" ([o que fazer](https://skipbox.dev/pt-br/guides/github-actions-spending-limit-job-not-started)).

## O que o Skipbox faz pelo CI dos agentes

Cada plano vem com a máquina dedicada da sua conta, mantida entre os trabalhos:

- **O estado fica.** Imagens, camadas e cache de build do Docker; `~/.npm`, o store do pnpm, `~/.cache`, os caches do Go, do Gradle, do Maven e do Cargo; as ferramentas que os `setup-*` instalaram. O checkout também fica, com o `target/` do Cargo e, nos projetos com turbo 2, o `.turbo` da raiz, então o próximo build continua de onde o anterior parou.
- **Os minutos são ilimitados**, e nenhum orçamento ou limite de gastos do GitHub para um trabalho do Skipbox.
- **Os trabalhos simultâneos são as vCPU dos planos.** Os trabalhos rodam ao mesmo tempo enquanto couberem nas vCPU dos planos que a conta tem; o resto espera a vez, e a página da conta mostra quantos esperam e por quanto tempo. Um S roda um trabalho de 4 vCPU por vez; os planos se somam em qualquer combinação.
- **O próprio trabalho do agente também pode rodar lá:** defina o `runs-on` dele como `skipbox`.

| Rótulo | Máquina | Plano |
|---|---|---|
| `skipbox` | 4 vCPU · 16 GB | S, $39 por mês |
| `skipbox-8x16` | 8 vCPU · 16 GB | M, $79 por mês |
| `skipbox-16x32` | 16 vCPU · 32 GB | L, $149 por mês |

Com 20.000 minutos por mês em 4 vCPU, o GitHub cobra $222; o Skipbox S custa $39. Com 30.000 minutos, $342.

## Mudar é uma linha

```yaml
jobs:
  checks:
    runs-on: skipbox # was ubuntu-latest
```

1. Entre no Skipbox com o GitHub.
2. Instale o app do Skipbox no GitHub e escolha os repositórios.
3. Troque o `runs-on` e faça push.

## Segurança

- A máquina é só da sua conta. Nenhum trabalho de outra empresa roda nela.
- Depois de cada trabalho, as credenciais, os processos e os contêineres do executor são apagados, e também as credenciais do git e os arquivos não rastreados de um checkout mantido. Limpar a cada trabalho dá, em vez disso, uma máquina nova a cada trabalho.
- O código de pessoas sem acesso de escrita (como pull requests de forks) roda em uma VM nova que lê os seus caches mas não pode alterá-los.

Os detalhes estão em [como os trabalhos são isolados](https://docs.skipbox.dev/pt-br/isolation).

## Teste no trabalho que o seu agente espera

O teste é grátis por 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, e não pede cartão. Mova o trabalho que o seu agente espera para `runs-on: skipbox`, deixe o agente fazer push duas vezes e compare a segunda execução com a do GitHub.

## Perguntas frequentes

### O meu agente abre um PR, espera 20 minutos pelo CI, corrige e espera de novo. Como deixar o CI rápido o bastante para as voltas de um agente?

Encurte aquilo que o agente espera, nesta ordem. Faça-o rodar o lint, a checagem de tipos e os testes unitários afetados antes do push, para o CI não ser o primeiro lugar onde um erro de digitação aparece. Cancele as execuções antigas de um pull request quando chegar um push novo (concurrency com cancel-in-progress). Ponha as verificações rápidas em um trabalho próprio, para o agente ler uma falha em um ou dois minutos. Rode só os testes que a mudança afeta. Depois, tire a configuração que cada trabalho repete: em uma máquina que guarda as camadas do Docker, os caches de pacotes e as saídas de build entre os trabalhos, o CI do astro foi de 528 s no GitHub para 30 s no Skipbox.

### Quanto CI a mais os agentes de IA geram?

A Anthropic escreveu que o volume de trabalhos de CI dela cresceu 25x em 6 meses, porque o Claude prefere pull requests menores e mais granulares e os agentes fazem push de madrugada e nos fins de semana. Cada um desses pushes roda o workflow inteiro de novo, a menos que o workflow o cancele, pule ou reduza.

### Qual é a melhor configuração de CI para uma equipe em que a maioria dos PRs é escrita por agentes de IA?

Uma que responda rápido ao agente e não cobre por push: um trabalho rápido de lint e checagem de tipos que responde primeiro, as suítes lentas depois dele, as execuções antigas de um pull request canceladas, só os testes afetados rodando, e executores que guardam os caches entre os trabalhos. O Skipbox dá a cada conta a sua máquina dedicada por um preço fixo com minutos ilimitados; o número de trabalhos que ele roda ao mesmo tempo é a soma das vCPU dos planos que a conta tem.

### Os agentes batem nos limites de concorrência do GitHub?

Podem bater. Os executores padrão hospedados pelo GitHub rodam no máximo 20 trabalhos ao mesmo tempo no GitHub Free, 40 no Pro, 60 no Team e 500 no Enterprise; o resto entra na fila. Vários agentes fazendo push de pull requests, cada um com uma matriz, chegam lá rápido. No Skipbox, os trabalhos rodam ao mesmo tempo enquanto couberem nas vCPU dos planos da conta, e o resto espera a vez, então uma equipe que roda vários agentes ao mesmo tempo tem vários planos ou um maior.

### O próprio trabalho do agente pode rodar no Skipbox?

Sim. Qualquer trabalho Linux escolhe a máquina pelo runs-on, inclusive o trabalho que roda a action do Claude Code. Defina-o como skipbox e ele roda na mesma máquina que o seu CI.

### Quanto custa testar?

Nada. O teste dura 7 dias ou 3.000 minutos de trabalhos, o que vier primeiro, sem cartão, até 4 trabalhos por vez com 4 vCPU cada. Mova o trabalho que o agente espera para runs-on: skipbox e cronometre a segunda execução.

Atualizado em 2026-11-19 · https://skipbox.dev/pt-br/guides/ci-for-ai-coding-agents
