`.
4. **Ficheiro de definições**: o campo `model` em `~/.claude/settings.json`.
Comandos básicos:
```bash
# Iniciar com o modelo sénior (atualmente Opus 5.5)
claude --model opus
# Mudar para Sonnet durante uma sessão
/model sonnet
# Abrir o menu de seleção (para seleção interativa)
/model
# Mudar para Opus com contexto de 1M
/model opus[1m]
# Mudar para uma versão específica (fixar)
/model claude-opus-5-5
```
Aliases e modelos para que apontam na API da Anthropic (a 23 de setembro de 2026):
- `opus` → Opus 5.5 (requer Claude Code v2.1.280 ou posterior)
- `sonnet` → Sonnet 5
- `haiku` → Haiku 4.5
- `best` → o modelo disponível mais inteligente
- `default` → Opus 5.5 em Pro, Max, Team, Enterprise e na API da Anthropic
- `opusplan` → uma combinação de Opus + Sonnet (explicada separadamente abaixo)
⚠️ As predefinições diferem nos fornecedores de cloud: na Amazon Bedrock e no Google Cloud, o alias `sonnet` aponta para Sonnet 4.5; no Microsoft Foundry, `opus` continua a resolver para Opus 4.6. Se trabalhar através de um fornecedor de cloud, fixe uma versão específica (`claude-opus-5-5`) ou defina a variável `ANTHROPIC_DEFAULT_OPUS_MODEL`.
A partir da versão 2.1.144, a principal mudança é que `/model` já não grava a seleção nas definições. Aplica-se à sessão atual e desaparece quando a sessão é fechada. Para guardar permanentemente uma predefinição, prima `d` na linha realçada do menu de seleção. Isto grava o campo `model` em `~/.claude/settings.json`.
As sessões resumidas (`claude --resume`, `--continue`, `/resume`) mantêm o modelo usado nessa sessão, independentemente da definição atual. Isto impede que outra sessão altere o modelo quando retoma a anterior.
Para verificar que modelo está ativo, use `/status` — apresenta a conta e o modelo atual.
## `/model opusplan`: comparar separadamente os custos de planeamento e execução
Pontos principais
`opusplan` é um alias híbrido: enquanto está no Plan Mode, a Claude pensa com Opus (arquitetura, análise da tarefa); assim que o Plan Mode é desativado e começa a execução propriamente dita, muda automaticamente para Sonnet. A poupança depende das tarifas e dos tokens reais de cada fase. No exemplo histórico abaixo, $3/$15 do Sonnet são 60% de $5/$25 do Opus: uma redução de 40% na parte de execução substituída, não 75–80% da tarefa completa.
Na prática descrita aqui, este modo é usado para tarefas que demoram mais de 10 passos.
A lógica:
- No Plan Mode (`/plan`), discute a arquitetura e as opções e acorda uma abordagem. O Opus é caro nesta fase, mas justifica o preço porque o seu raciocínio é fundamentalmente diferente.
- Assim que o Plan Mode termina e a Claude começa a editar ficheiros, escrever testes e executar comandos, isso é execução. Na execução, o Sonnet 4.6 iguala a qualidade do Opus.
Para ativar:
```bash
# No arranque
claude --model opusplan
# Ou durante uma sessão
/model opusplan
```
Um cálculo específico. Suponha que uma refatoração de 50 passos tem uma distribuição típica:
- Planeamento (5 passos, ~30 000 tokens de entrada + 8 000 de saída): Opus 4.7
- Execução (45 passos, ~200 000 tokens de entrada + 50 000 de saída): Sonnet 4.6
| Opção | Custo do planeamento | Custo da execução | Total |
|----|----|----|----|
| Só Opus | \$0.15 + \$0.20 = \$0.35 | \$1.00 + \$1.25 = \$2.25 | **\$2.60** |
| Opusplan (Opus + Sonnet) | \$0.15 + \$0.20 = \$0.35 | \$0.60 + \$0.75 = \$1.35 | **\$1.70** |
A base usa 230 000 tokens de entrada e 58 000 de saída: $2.60 às tarifas históricas Opus da tabela. Opusplan mantém 30 000 de entrada e 8 000 de saída no Opus ($0.35) e usa 200 000 de entrada e 50 000 de saída no Sonnet ($1.35), totalizando $1.70. A poupança é ($2.60 − $1.70) / $2.60 = 34.6%. Com as mesmas contagens e tarifas, substituir a execução poupa 40% dessa parcela; mesmo com execução a 90% do custo base, a poupança total seria 36%. Uma diferença de tokenizador exige contagens explícitas de entrada/saída por modelo e não justifica, por si só, 75–80%.
⚠️ Um detalhe: o Opus no plan mode de `opusplan` usa o contexto padrão de 200K. A atualização automática para 1M, disponível com o alias `opus`, NÃO se aplica ao `opusplan`. Se planear uma tarefa enorme com milhões de tokens de contexto (por exemplo, analisar um monorepo grande), use explicitamente `/model opus[1m]` ou mude para opusplan DEPOIS do planeamento.
## O comando `/effort`: 5 níveis de raciocínio adaptativo
Pontos principais
`/effort` controla a profundidade de pensamento do modelo em cada passo. Os níveis são low, medium, high, xhigh (apenas Opus 4.7) e max. A partir da versão 2.1.117, as predefinições são xhigh para o Opus 4.7 e high para os outros modelos. low/medium/high/xhigh são guardados entre sessões; max aplica-se apenas à sessão atual. Em low, o Opus torna-se quase tão rápido e barato como o Sonnet.
Este é o segundo comando mais importante, depois de `/model`. O esforço é raciocínio adaptativo: em cada passo, o modelo decide quão profundamente pensar com base na complexidade da tarefa. Quanto mais alto o nível, mais profundo o raciocínio e mais tokens são usados.
Níveis (consoante a tarefa):
| Nível | Quando usar | O que muda |
|----|----|----|
| **low** | Tarefas curtas sem exigências intelectuais: mudar nomes de ficheiros, pesquisas simples com grep, «o que faz esta função?», comando de compilação | O modelo quase não pensa e responde rápida e economicamente |
| **medium** | Trabalho em que poupar tokens importa mais do que uma pequena perda de precisão | Reduz o consumo de tokens; por vezes perde precisão nas nuances |
| **high** | O mínimo para tarefas que exigem raciocínio real: programação, refatoração, revisão de código | Equilibra tokens e qualidade. Predefinição do Sonnet 4.6 e do Opus 4.6 |
| **xhigh** | Melhores resultados para a maioria das tarefas de programação e de agentes | Predefinição do Opus 4.7. Disponível apenas no Opus 4.7 |
| **max** | Tarefas muito exigentes. Pode melhorar os resultados, mas tende a pensar demasiado | Sem limite de tokens. Repõe-se no fim da sessão |
São suportados três modelos: Opus 4.7, Opus 4.6 e Sonnet 4.6. O esforço não está disponível nos restantes.
O que mudou até setembro de 2026. Os níveis `low`, `medium`, `high`, `xhigh` e `max` estão disponíveis no Opus 5.5, Opus 5, Sonnet 5, Opus 4.8 e Opus 4.7; o Opus 4.6 e o Sonnet 4.6 não têm `xhigh`, e um `xhigh` pedido funciona como `high` nesses modelos. O nível predefinido é `high` em todos os modelos que suportam esforço, exceto no Opus 5.5 (`medium`) e no Opus 4.7 (`xhigh`). Isto significa que é necessário pedir explicitamente uma análise aprofundada ao atual modelo sénior. Também surgiu um modo separado, `ultracode`: é uma definição do Claude Code, não um nível do modelo — envia `xhigh` e também pede à Claude que crie fluxos de trabalho dinâmicos para tarefas grandes.
Como definir:
```bash
# Abrir o seletor interativo
/effort
# Definir diretamente o nível
/effort high
/effort xhigh
# Repor a predefinição do modelo
auto
# Através de uma opção de arranque
claude --effort high
# Através de uma variável de ambiente (aplica-se no arranque)
export CLAUDE_CODE_EFFORT_LEVEL=high
# Nas definições (max não funciona — é apenas para a sessão)
{
"effortLevel": "high"
}
# Nos metadados de skill / subagente
---
name: my-skill
effort: low
---
```
O nível aparece junto ao logótipo e ao indicador de atividade no Claude Code, por exemplo, «with low effort», pelo que não é necessário abrir `/model` para o verificar.
O seletor de esforço também aparece no menu de seleção de `/model` — use as setas esquerda/direita para o definir.
Um detalhe importante. Quando muda para o Opus 4.7 a partir de qualquer outro modelo, o esforço é forçado para xhigh — mesmo que tivesse definido high para o Opus 4.6 ou para o Sonnet 4.6. Para repor o nível pretendido, execute novamente `/effort`.
Mais uma técnica: **ultrathink** no pedido. Se incluir a palavra `ultrathink` no texto do pedido, a Claude usará um raciocínio mais aprofundado nesse turno, sem alterar o esforço da sessão. Expressões semelhantes («think», «think hard», «think more») não ativam este comportamento — são simplesmente transmitidas como texto normal.
## O comando `/fast`: o Opus é 2.5× mais rápido por 6× o preço — quando compensa?
Pontos principais
`/fast` é uma configuração alternativa da API para os modelos sénior Opus. Não é um modelo diferente — é o mesmo Opus, mas pode gerar resultados até 2.5 vezes mais depressa. A 23 de setembro de 2026, é suportado no Opus 5.5, Opus 5 e Opus 4.8; custa \$8 / \$40 por milhão de tokens no Opus 5.5 e \$10 / \$50 no Opus 5 e Opus 4.8. Não está disponível no Sonnet nem no Haiku e foi removido do Opus 4.7 a 24 de julho de 2026. Destina-se à depuração em direto e ao trabalho interativo, em que a latência importa mais do que o dinheiro.
O modo Fast é uma funcionalidade de pré-visualização de investigação. Requer Claude Code v2.1.36+ e pode ser verificado com `claude --version`.
Para ativar:
```bash
# Alternar o modo Fast (disponível na CLI Claude Code e na extensão VS Code)
/fast
# Ou nas definições
{
"fastMode": true
}
```
Depois de ativado:
- Se estiver noutro modelo, o Claude Code muda automaticamente para Opus.
- Aparece uma confirmação «Fast mode ON».
- Surge um ícone `↯` junto ao pedido.
Opções e detalhes:
- O modelo predefinido no modo Fast é o Opus disponível mais capaz. A 23 de setembro de 2026, é o Opus 5.5; o modo Fast não funciona de todo no Opus 4.7 e, se mudar para este, o modo Fast é desligado.
- Por predefinição, o modo Fast é mantido entre sessões. Os administradores de Team/Enterprise podem exigir uma ativação explícita em cada sessão com `fastModePerSessionOptIn: true`.
- Quando desativa o modo Fast ao executar novamente `/fast`, mantém-se no Opus — o modelo não volta ao anterior. Para mudar, use `/model`.
- Ativá-lo a meio de uma conversa implica cobrar o preço do modo Fast para todo o contexto da conversa. Por isso, é mais económico ativá-lo logo no início de uma sessão, não a meio.
Quando usar o modo Fast:
- **Depuração em direto**: está a observar um trace e o tempo de resposta é crítico.
- **Prazo apertado para trabalho interativo**: está a preparar uma demonstração para as 18:00 e precisa de iterar rapidamente.
- **Iteração rápida de código**: está a testar hipóteses uma após outra.
Quando não o usar:
- **Tarefas autónomas longas** em que a velocidade não seja crítica. Paga 6 vezes mais por 2.5 vezes a velocidade — não compensa se for almoçar enquanto a Claude trabalha.
- **Processamento em lote, pipelines CI/CD** — não se destinam de todo ao modo interativo.
- **Cargas de trabalho sensíveis ao custo** — a escolha é óbvia.
Disponibilidade:
- NÃO funciona no Bedrock, Vertex nem Foundry.
- Requer **créditos de utilização** na conta (faturação para além do limite incluído no plano). Nas contas individuais, ativa-se nas definições de faturação da Console. Nas contas Team/Enterprise, tem de ser ativado por um administrador.
- Os tokens do modo Fast NÃO são descontados do limite incluído no plano. São debitados diretamente dos créditos de utilização, aos preços do modo Fast desde o primeiro token.
Se atingir o limite de pedidos do modo Fast ou ficar sem créditos de utilização, o modo Fast muda automaticamente para a velocidade e o preço normais, o ícone `↯` fica cinzento e o trabalho continua. Quando o limite for reposto, o modo Fast volta a ativar-se.
O modo Fast e o esforço não são definições concorrentes. Pode combiná-los: modo Fast + low effort = velocidade máxima em tarefas simples.
## Quanto custa realmente cada modelo: análise da fatura mensal
Pontos principais
Preços base por milhão de tokens: Haiku 4.5 — \$1 / \$5, Sonnet 4.6 — \$3 / \$15, Opus 4.7 — \$5 / \$25. Modo Fast — \$30 / \$150. A colocação de pedidos em cache reduz a entrada repetida para 0.1×. A Batch API oferece um desconto de 50%. A principal fonte de poupança não é o modelo em si, mas evitar o Opus quando o Sonnet consegue fazer o trabalho.
Preços por milhão de tokens (Anthropic API, USD):
| Modelo | Entrada | Escrita na cache de 5 min | Escrita na cache de 1 hora | Cache hit | Saída |
|------------------|-------|-------------------|-----------------|-----------|--------|
| Haiku 4.5 | \$1 | \$1.25 | \$2 | \$0.10 | \$5 |
| Sonnet 4.6 | \$3 | \$3.75 | \$6 | \$0.30 | \$15 |
| Opus 4.6 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Opus 4.7 | \$5 | \$6.25 | \$10 | \$0.50 | \$25 |
| Modo Fast (Opus) | \$30 | n/a | n/a | n/a | \$150 |
O que reduz realmente a fatura:
1. **Colocação de pedidos em cache.** A Anthropic guarda em cache secções repetidas dos pedidos: o pedido de sistema, CLAUDE.md e as descrições das ferramentas. Um cache hit custa 10% do preço de entrada. No Sonnet, isso reduz \$3 por milhão de tokens para \$0.30 — dez vezes mais barato. É ativado automaticamente através de `cache_control: { type: "ephemeral" }` no pedido à API. No Claude Code, funciona por predefinição.
2. **Batch API**: desconto de 50% na entrada e na saída para tarefas cujo resultado possa esperar (relatórios, geração de texto em lote). Sonnet através da Batch API = \$1.50 / \$7.50. Não funciona diretamente no Claude Code, mas, se criar automatizações com o Anthropic SDK, use-a.
3. **opusplan em vez de apenas Opus**: cerca de 34,6% de poupança no exemplo histórico; o total real depende da parcela de execução, tokens, tarifas, cache e repetições.
4. **Sonnet por predefinição + Opus quando necessário**: a principal fonte de poupança. Se o Opus estiver ativado «por precaução», a prática descrita aqui muda para o Sonnet. Se a tarefa exigir Opus, isso torna-se evidente ao terceiro ou quarto passo e mudo explicitamente com `/model opus`.
5. **Lembre-se do novo tokenizador do Opus 4.7.** No mesmo ficheiro, o Opus 4.7 usa até mais 35% de tokens do que o Sonnet 4.6. O custo real da mesma tarefa aumenta mais do que a tabela poderá sugerir.
Um exemplo específico: uma tarefa típica de uma agência imobiliária que está a criar um protótipo de site para um novo cliente: «cria uma página com três secções, um formulário e integração com gateway de pagamento». Os resultados foram:
- Só Opus 4.7 (high effort): ~\$4.80 por sessão (1.5 horas de trabalho).
- opusplan: ~\$1.90 (o Opus planeia, o Sonnet executa).
- Só Sonnet 4.6 (high effort): ~\$1.30, mas a decisão arquitetural foi pior (o Sonnet adotou uma abordagem baseada num modelo predefinido, enquanto o Opus em opusplan propôs uma solução própria para os requisitos não convencionais).
Para esta tarefa, o vencedor é opusplan. A poupança é de 60%, com a qualidade do Opus na parte crítica.
O Claude Code não mostra diretamente as contagens de tokens dos limites — são dinâmicas e dependem do plano. Mas em `/status` pode ver o seu plano e a utilização atual. Para um controlo mais detalhado, existe um guia completo: [Como evitar esgotar os limites do Claude Code num dia](https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/).
## Que fluxo de trabalho diário deve configurar? 4 predefinições prontas a usar
Pontos principais
Quatro predefinições prontas a usar para diferentes tipos de tarefa. Programação diária — Sonnet + high effort. Refatoração complexa — opusplan. Correção rápida — Haiku + low effort. Sessão de arquitetura — Opus 4.7 + xhigh effort + Plan Mode. Pode guardar cada uma como alias, associá-la a uma skill ou simplesmente tê-la à mão como primeiro comando ao iniciar uma sessão.
Estas quatro predefinições podem ser alternadas consoante o dia de trabalho e a tarefa.
**Predefinição 1. Programação diária — 80% do tempo de trabalho na prática descrita.**
```bash
claude --model sonnet --effort high
# Durante a sessão, passe para Opus se necessário
/model opus
```
Para quê: novas funcionalidades, pequenas refatorações, depuração de erros simples, documentação. Sonnet com high effort é o ponto ideal.
**Predefinição 2. Refatoração complexa — uma grande alteração arquitetural.**
```bash
claude --model opusplan
# Primeiro use /plan para discutir a estrutura
# Depois de sair do Plan Mode, o Sonnet trata da execução
```
Para quê: reescrever um módulo em mais de 15 ficheiros, mudar uma integração de um gateway para outro. O Opus trata da arquitetura (analisa as dependências) e o Sonnet da execução (edita rapidamente os ficheiros). Estas tarefas podem poupar 70%+.
**Predefinição 3. Correção rápida — edições de uma linha e scripts.**
```bash
claude --model haiku --effort low
```
Para quê: «altera o nome de uma variável em todos os ficheiros», «escreve um script bash para reiniciar o nginx», «o que faz esta função?». O Haiku trata destas tarefas e custa três vezes menos do que o Sonnet.
**Predefinição 4. Sessão de arquitetura — uma decisão estratégica.**
```bash
claude --model opus --effort xhigh
# Use o esforço máximo ao entrar no Plan Mode:
/plan
# Para questões críticas, acrescente a palavra ultrathink ao pedido
```
Para quê: «X deve ser um serviço separado?», «que ferramentas devemos usar para o protótipo?», «como devemos organizar um esquema de base de dados multi-tenant?». É aqui que o Opus 4.7 é caro — e vale a pena, porque um erro nesta fase pode custar semanas de trabalho.
Estas predefinições podem ser guardadas como Skills (um modelo por skill) ou como aliases em `~/.zshrc`:
```bash
alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'
```
Se trabalhar em equipa, pode uniformizar através das definições geridas. Um administrador define `availableModels: ["sonnet", "haiku", "opusplan"]` na política da organização e os utilizadores ficam tecnicamente impedidos de escolher Opus diretamente, só podendo fazê-lo com ativação explícita. É uma boa proteção contra o esgotamento acidental do limite.
Para quem estiver a criar [subagentes](https://ailoot.ai/blog/pt-pt/claude-code-subagents/), também é possível definir modelos diferentes para cada subagente através de `CLAUDE_CODE_SUBAGENT_MODEL` ou do campo `model` nos metadados da definição do agente. Isto acrescenta outro nível de otimização.
## O que fazer quando ficar sem capacidade: 5 técnicas práticas
Pontos principais
Quando atingir o limite do Opus, não entre em pânico. Há cinco maneiras de continuar a trabalhar: mudar para Sonnet, usar opusplan, ativar a colocação de pedidos em cache, transferir algum trabalho para a Batch API ou mudar as tarefas secundárias para Haiku. Os limites foram duplicados em maio de 2026 e o estrangulamento nas horas de ponta foi removido, tornando mais difícil esgotar a capacidade do Opus.
Se `/status` indicar que atingiu o limite do Opus:
1. **Mude para o Sonnet 4.6**: `/model sonnet`. Tem um conjunto de utilização separado e não notará diferença em 80% das tarefas. Na Anthropic API, mesmo quando atinge o limite do Opus, o Claude Code poderá mudar automaticamente para o Sonnet se estiver a aproximar-se do limite.
2. **Use opusplan para o trabalho que falta**: `/model opusplan`. Se ainda tiver tarefas em Plan Mode para esse dia, usarão o Opus apenas o mínimo necessário (só para o planeamento); a execução será toda feita com Sonnet.
3. **Verifique a colocação de pedidos em cache**: confirme que não a desativou com `DISABLE_PROMPT_CACHING=1`. Se o seu CLAUDE.md ou pedido de sistema tiver um megabyte de definições, deverá estar em cache. Com 90% de leituras, isto reduz o consumo dez vezes.
4. **Transfira as tarefas em lote**: se tiver geração em massa (relatórios, textos, traduções), passe-a para um script com a Batch API — 50% de desconto na entrada e na saída. Não funciona diretamente no Claude Code, mas demora 30 minutos a configurar com um script `tsx` + Anthropic SDK.
5. **Use Haiku para tarefas secundárias**: para tarefas rotineiras como «escreve uma mensagem de commit» ou «explica o que faz este ficheiro», mude o Claude Code para Haiku. Consome três vezes menos do que o Sonnet e cinco vezes menos do que o Opus.
E o lembrete principal: **desde 6 de maio de 2026, os limites dos planos Pro, Max, Team e Enterprise foram duplicados** e o estrangulamento nas horas de ponta foi removido. Se o Opus esgotar a sua capacidade em meio dia, o problema não são os limites — é estar a usar o Opus onde o Sonnet faria o trabalho. O mapa de decisão na segunda secção deste guia ajuda-o a retomar o controlo.
Para uma análise aprofundada dos limites e oito regras práticas para poupar tokens, consulte este artigo principal: [Como evitar esgotar os limites do Claude Code num dia: 8 regras para poupar tokens em 2026](https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/). Outro guia complementar útil é [Plan Mode no Claude Code: um guia passo a passo](https://ailoot.ai/blog/pt-pt/claude-code-plan-mode/), porque o opusplan não funciona sem Plan Mode. E a base para todos os modelos é [Como configurar CLAUDE.md em 2026](https://ailoot.ai/blog/pt-pt/claude-md-template/).
### Fontes
- [Anthropic — anúncio do Claude Opus 5.5 (22 de setembro de 2026)](https://www.anthropic.com/news/claude-opus-5-5)
- [Anthropic API: visão geral dos modelos, preços e níveis de esforço](https://platform.claude.com/docs/en/about-claude/models/overview)
- [Anthropic Claude Code: configuração do modelo](https://code.claude.com/docs/en/model-config)
- [Anthropic Claude Code: acelerar respostas com o modo Fast](https://code.claude.com/docs/en/fast-mode)
- [Anthropic Claude Code: novidades](https://code.claude.com/docs/en/whats-new)
- [Anthropic API: preços](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic API: níveis de esforço](https://platform.claude.com/docs/en/build-with-claude/effort)
- [Anthropic API: janela de contexto de 1M de tokens](https://platform.claude.com/docs/en/build-with-claude/context-windows)
- [Suporte Anthropic: modelos, utilização e limites no Claude Code](https://support.claude.com/en/articles/14552983-models-usage-and-limits-in-claude-code)
- [Blog da Anthropic: novidades nos agentes geridos Claude (Code with Claude 2026)](https://claude.com/blog/new-in-claude-managed-agents)
Uma configuração funcional para vibe coding: **clone de IA + Segundo Cérebro + Engenharia de Contexto**. Materiais práticos: [documentação Ailoot](https://ailoot.ai/docs/).
Mais materiais e ferramentas: [Ailoot](https://ailoot.ai/).
## Perguntas frequentes
### Quanto poupa o exemplo calculado de opusplan?
Às tarifas e contagens históricas da tabela, apenas Opus custa $2.60 e opusplan $1.70. A poupança é $0.90 / $2.60, cerca de 34,6%; não prova poupanças universais de 75–80%.
### Escolher um modelo de execução mais barato garante uma tarefa bem-sucedida mais barata?
Não. Use contagens reais de entrada, saída, cache e repetições às tarifas aplicáveis e as mesmas verificações de sucesso. Uma tarifa inferior por token é só uma parte do custo final.
## Ailoot · A empresa e a sua carteira de projetos
A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.
A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.
A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.