> For the complete documentation index, see [llms.txt](https://docs.skail.dev/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.skail.dev/referencia/limites-e-cotas.md).

# Limites e cotas

O que tem limite em uma execução, por que o limite existe, o que fazer quando ele é atingido e como o skail cobra.

Os valores em vigor são informados pela equipe do skail.

## Por execução

| Dimensão                                                         | Por que existe                                                                                                                                  | O que fazer                                                                                                                                                                       |
| ---------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Tamanho dos argumentos e resultados (trigger, commands, eventos) | Fazem parte do histórico da execução e são lidos a cada retomada; valores grandes deixam a retomada lenta                                       | Passe ids e valores de decisão; carregue o resto dentro do command. Ver [Como passar dados entre função e commands](/construa/como-fazer/passar-dados-entre-funcao-e-commands.md) |
| Quantidade de passos por execução                                | A retomada reexecuta a function sobre o histórico inteiro; históricos muito longos degradam a retomada. Laços (loops) sem fim são o caso típico | Divida em functions filhas ou reinicie por trigger a cada ciclo. Ver [Antipadrões](/construa/como-fazer/padroes-e-antipadroes/antipadroes-o-que-nao-fazer-e-por-que.md)           |
| Esperas longas (delay, espera por evento)                        | Esperas de dias são suportadas e não ocupam a sua aplicação enquanto duram                                                                      | Toda espera com prazo: esperar o evento ou o prazo, o que vier primeiro. Ver [Como esperar com timeout](/construa/como-fazer/esperar-um-evento-com-prazo.md)                      |
| Reentregas por passo                                             | `retryCount`: 5 em command, 15 em function, por padrão                                                                                          | Falha de negócio como resultado (ou `retryCount: 0` e tratamento na function); chave de idempotência nas chamadas externas. Cada tentativa de command conta na cobrança           |

## Por workload e environment

| Dimensão                             | Por que existe                                                                                                                                                                                                         | O que fazer                                                                                                                                                                                                                        |
| ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Execuções processadas ao mesmo tempo | Cada processo da sua aplicação processa até `SKAIL_MAX_PARALLEL_TASKS` execuções de uma vez, 1 por padrão. Execuções em delay ou esperando evento não ocupam vaga; as que estão prontas para rodar aguardam em Na fila | Aumente `SKAIL_MAX_PARALLEL_TASKS` ou escale com réplicas. Ver [Variáveis de ambiente do runtime](/referencia/variaveis-de-ambiente-do-runtime.md) e [Como hospedar](/opere/configurar-e-hospedar/container-kubernetes-e-azure.md) |
| Chamadas à API HTTP (trigger e fire) | Proteção da API                                                                                                                                                                                                        | Retry com backoff no chamador                                                                                                                                                                                                      |

## Cobrança

O skail cobra por operação. Cada plano inclui uma quantidade mensal de operações cobráveis, que o [painel de cobrança do portal](https://dash.skail.dev/settings/billing) chama de actions. O painel mostra a franquia de cada plano e os tipos de operação que entram na conta.

Cada tentativa de um command conta como uma operação, inclusive as que falham: um command que falha duas vezes e conclui na terceira conta três. Por isso o `retryCount` de cada command também pesa no consumo, e uma falha de negócio devolvida como resultado custa menos que uma exceção retentada.

Quando a franquia do plano acaba, o skail bloqueia a execução dos fluxos. Para não chegar a esse ponto, acompanhe o painel de cobrança e mude de plano antes do limite.

## Próximos passos

[Garantias de execução](/referencia/garantias/garantias-de-execucao.md) para o que está prometido dentro desses limites. [Monitoramento e alertas](/opere/monitoramento-e-alertas.md) para acompanhar quando um limite está perto de ser atingido.