referência de comandos

Todos os comandos.

São duas famílias, na ordem em que você encontra as duas. No seu shell, você chama o aluy com subcomandos e flags. Com a sessão aberta, digite / no início da linha e o menu aparece. Esta página lista as duas, por inteiro.

no seu shell

A linha de comando do aluy

Abrir uma sessão

— o padrão, sem subcomando nenhum.
aluy [objetivo] [flags…]

Abre a sessão interativa na pasta atual. Um texto entre aspas vira o objetivo inicial. Na primeira vez, o assistente de instalação abre antes.

$ aluy "adiciona cache no endpoint de busca"
--continue

Retoma a última sessão desta pasta.

$ aluy --continue
--resume [<id>]

Sem id, lista as sessões salvas para você escolher. Com um id, retoma aquela.

$ aluy --resume 3f9a2c
--new

Começa uma sessão nova, ignorando as salvas.

--telegram

Abre a sessão com a ponte do Telegram ligada, para o agente te alcançar fora do terminal.

$ aluy --telegram

Decidir quanto ele pode fazer

— a escolha que mais importa.
--plan

Modo planejamento: o agente lê, analisa e propõe, e não produz efeito nenhum. Se vier junto com --yolo, este vence.

$ aluy --plan "onde está o gargalo do checkout?"
--yolo
--unsafe

Aprova todo efeito sozinho. Cinco categorias de comando continuam perguntando — apagar coisas, acessar a rede, virar administrador, instalar pacote e mexer nos arquivos que rodam quando o computador liga — e toda ferramenta que vier de um servidor MCP também. O Aluy recusa rodar como root.

$ aluy --yolo "roda a migração e conserta o que quebrar"

--unsafe é o nome antigo e emite aviso.

--no-subagents

Desliga os subagentes paralelos, ou seja, a ferramenta spawn_agent.

Por padrão eles rodam ao mesmo tempo, com as mesmas permissões que você deu ao agente principal — e um subagente não pode abrir outro.

Rodar sem sessão

— script, encadeamento de comandos e automação de build (CI). Todos precisam do -p.
-p
--print
--exec
"<objetivo>"

Roda uma vez e sai: executa um objetivo, imprime o resultado e encerra. O objetivo vem na linha ou pela entrada padrão.

$ aluy -p "quantos testes existem neste repositório?"
--output-format text|json|stream-json

O formato do que sai. text é o padrão; stream-json emite um evento JSON por linha, ao vivo.

$ aluy -p "liste os TODOs" --output-format json
--quiet

Esconde o indicador de progresso e as mensagens de diagnóstico, deixando só o resultado.

$ aluy -p "versão do Node exigida?" --quiet
--cycles [--cycle-for <dur>] <N>

Roda o objetivo em ciclos, sozinho — a forma sem interface do /cycle. Exige um teto.

$ aluy -p "conserte o lint" --cycles 20

Se você pedir mais que o máximo, o Aluy corta no máximo e avisa.

Escolher o modelo

— qual responde, e por onde a chamada vai.
--tier <tier>

A faixa de modelo da sessão. Dá para trocar com a sessão aberta, pelo /model.

$ aluy --tier sonnet

Se você pedir o tier custom sem dizer qual modelo, o Aluy recusa e explica.

--model [--provider <nome>] <slug>

Escolhe um modelo do catálogo pelo identificador e força o tier custom. Precisa vir com --provider.

$ aluy --model claude-sonnet-4-5 --provider anthropic

Os dois são dado, nunca credencial: ela sai do seu cofre, na sua máquina.

--effort <valor>

Quanto o modelo raciocina antes de responder. O provider valida o valor.

$ aluy --effort high
  • usuais
  • low
  • medium
  • high
--backend local|broker

local é o padrão: fala direto com o seu provider, sem ninguém no meio e sem ninguém contando quanto você usou. broker rotearia por um backend central, hoje indisponível.

$ aluy --backend local
--local-provider <nome>

Com qual provider o modo local fala.

$ aluy --local-provider openrouter
  • valores
  • anthropic
  • openrouter
  • openai
--local-model <slug>

O identificador do modelo, exatamente como aquele provider o nomeia.

$ aluy --local-model qwen2.5-coder:7b
--local-auth apikey|oauth

Se o modo local usa uma chave de API guardada ou um login OAuth.

$ aluy --local-auth apikey
--local-base-url <url>

O endereço a chamar, para um provider compatível com OpenAI ou um modelo rodando na sua máquina.

$ aluy --local-base-url https://api.exemplo.com/v1

A conexão não aceita ser desviada para dentro da sua rede interna.

Definir os tetos

— para uma execução não varar a noite na sua conta.
--max-tokens <N>

O total de tokens da sessão — tokens são os pedaços de texto que o modelo cobra.

$ aluy --max-tokens 250000

padrão 1.000.000

--max-iterations <N>

Quantas voltas o modelo pode dar no ciclo de ferramentas.

$ aluy --max-iterations 80

padrão 300

--max-output-tokens <N>

O teto de uma resposta só do modelo.

$ aluy --max-output-tokens 8000
--budget
--no-budget

Liga e desliga o corte automático de gasto da sessão.

$ aluy --no-budget

Vem desligado no modo padrão: ali não existe teto de gasto, de propósito.

--self-check
--no-self-check

Força a autoverificação, ligada ou desligada: antes de dizer "pronto", o agente volta ao objetivo e confere.

$ aluy --self-check

Sem a flag, o Aluy decide: nos tiers mais fracos ele liga sozinho.

--autocompact-at <razão|%|off>

O quanto a janela do modelo pode encher antes de o Aluy resumir a conversa.

$ aluy --autocompact-at 70%

padrão: 85% da janela cheia · --no-autocompact desliga

Mudar a aparência

— todas ficam salvas na configuração.
--lang pt-BR|en

O idioma da interface. Não traduz o que o agente escreve.

$ aluy --lang en
--split

Abre com a tela dividida, conversa e log lado a lado.

$ aluy --split

Ctrl+L alterna.

--fullscreen

Abre em modo cockpit, ocupando o terminal inteiro.

$ aluy --fullscreen
--dense

Compacta a interface, para caber mais em tela pequena.

$ aluy --dense
--ascii

Usa um conjunto de símbolos seguro, para terminal que mostra quadradinhos vazios.

$ aluy --ascii

O mesmo que ALUY_SAFE_GLYPHS=1.

Preparar a instalação

— subcomandos: fazem um trabalho e saem.
aluy onboard

Instalador guiado: idioma, modo de conexão, provider, chave, modelo, servidores MCP e perfil turbo.

$ aluy onboard

É o passo 2 da instalação. Rode de novo quando quiser trocar.

aluy bootstrap [--no-agent]

Instala os sidecars locais: mem0, headroom e ollama.

$ aluy bootstrap --no-agent

Por padrão quem instala é o agente; --no-agent segue um caminho fixo, sem modelo.

aluy config

Mostra o que está em vigor: perfil, o que está ligado, e de onde vem cada valor.

$ aluy config
aluy login [--provider <p>] [--oauth] [--token <PAT>] [--org <id>] [--device]

Guarda a sua credencial no cofre.

$ aluy login --provider anthropic

Alguns providers não deixam claro se a assinatura mensal deles pode ser usada por um programa que não é o oficial. O Aluy não é o oficial. Se você entrar por login em vez de chave, o risco é seu.

aluy logout
aluy whoami

Encerra a sessão e apaga a credencial do cofre. O whoami mostra a conta, a organização e o que a credencial autoriza — nunca o segredo em si.

$ aluy whoami

Conferir e inspecionar

— só leem; não chamam o modelo e saem com código 0.
aluy doctor [--deep|--test] [--json]

Confere a instalação: credencial, se o provider responde, servidores MCP, perfis, configuração, versão e memória.

$ aluy doctor --deep --json

--deep faz uma chamada de verdade ao modelo para testar — ou seja, consome uma chamada da sua conta. Se algo falhar, o comando termina com código de erro, o que serve para scripts.

aluy agents
skills
workflows
models
providers

As cinco listagens do que o Aluy encontrou: perfis de agente, skills, workflows, modelos e providers.

$ aluy providers
--version
-v

Imprime a versão e sai, antes de montar a interface.

$ aluy --version
--help
-h

Imprime a ajuda embutida, com todos os comandos e flags, e sai.

$ aluy --help

Deixar trabalho rodando

— tarefas agendadas e serviços.
aluy cron <quando> "<tarefa>"

Agenda tarefas pelo agendador do próprio sistema — não há serviço em segundo plano. Hoje no Linux, pelo crontab.

$ aluy cron add "0 9 * * 1-5" "revise os PRs abertos"
  • sub
  • add
  • list
  • edit
  • enable
  • disable
  • rm
  • run

Cada execução roda como aluy -p, pela catraca.

aluy service <nome>

Cria e opera agentes com rotina, que acordam na hora marcada e reportam no seu canal.

$ aluy service start relatorio-diario
  • sub
  • list
  • status
  • create
  • install
  • uninstall
  • start
  • stop
  • logs
  • attach

Conectar ferramentas externas

— os mesmos motores dos comandos da sessão.
aluy mcp <nome>

Conectores MCP pelo shell. add <nome> -- <cmd> adiciona um servidor local.

$ aluy mcp add playwright -- npx @playwright/mcp
  • sub
  • search
  • add
  • list
  • remove

--project escreve no .mcp.json do projeto em vez do global.

aluy telegram <chat-id>

Liga a ponte com o Telegram. O token vai para o cofre e a lista de chats começa fechada.

$ aluy telegram allow 184920371
  • sub
  • login
  • allow
  • deny
  • status
  • logout

Acesso e backend

— quem é você, e para onde a chamada do modelo vai.
variávelflago que faz
ALUY_TOKEN
--token

Token de acesso pessoal, para entrar sem que ninguém precise digitar nada — útil em automação.

ALUY_ORG
--org

Sob qual organização agir.

ALUY_BACKEND
--backend

Se a chamada vai direto ao seu provider (local) ou pelo backend central (broker).

ALUY_LOCAL_PROVIDER
--local-provider

Com qual provider o modo local fala.

ALUY_LOCAL_MODEL
--local-model

O identificador do modelo, como aquele provider o nomeia.

ALUY_LOCAL_AUTH
--local-auth

Se o modo local usa chave de API guardada ou login OAuth.

ALUY_LOCAL_BASE_URL
--local-base-url

O endereço a chamar, para provider compatível com OpenAI ou modelo local.

ALUY_LOCAL_API_KEY
—

A chave do provider em si, para máquinas sem cofre do sistema.

ALUY_TELEGRAM_TOKEN
—

O token do bot, em vez de guardá-lo com aluy telegram login.

ALUY_BROKER_URL
—

Onde vive o backend central. Você só define isto se rodar o seu.

ALUY_IDENTITY_URL
—

Onde vive o serviço de identidade. Mesma ressalva.

Limites e tetos

— os mesmos tetos das flags, para quando não há linha de comando onde pôr uma flag.
variávelflago que faz
ALUY_MAX_TOKENS
--max-tokens

O total de tokens da sessão. Padrão 1.000.000.

ALUY_MAX_ITERATIONS
--max-iterations

Quantas voltas o modelo pode dar no ciclo de ferramentas. Padrão 300.

ALUY_MAX_OUTPUT_TOKENS
--max-output-tokens

O teto de uma resposta só do modelo.

ALUY_BUDGET
--budget

Liga e desliga o corte automático de gasto.

ALUY_AUTOCOMPACT_AT
--autocompact-at

O quanto a janela pode encher antes de o Aluy resumir a conversa.

ALUY_AUTOCOMPACT_MAX
—

Quantas vezes uma sessão pode resumir sozinha.

ALUY_CONTEXT_WINDOW
—

Força o tamanho da janela que o Aluy descobriu para o modelo, quando a descoberta erra.

ALUY_SELF_CHECK
--self-check

Força a autoverificação antes de declarar "pronto".

ALUY_SELF_CHECK_EVERY
—

De quanto em quanto tempo essa verificação roda.

ALUY_SELF_CHECK_MAX
—

Quantas verificações um run pode gastar.

ALUY_MAX_MEMORY_WRITES_PER_SESSION
—

Quantos fatos uma sessão pode escrever na memória.

ALUY_MCP_TIMEOUT_MS
—

Quanto esperar por uma chamada de ferramenta MCP. Padrão 60000.

ALUY_MCP_CONNECT_TIMEOUT_MS
—

Quanto esperar um servidor MCP subir. Padrão 20000.

ALUY_STREAM_MAX_BYTES
—

O teto de uma resposta transmitida. Padrão 24 MB.

ALUY_STREAM_CAP_OFF
—

Remove esse teto.

ALUY_WEB_FETCH_MAX_CHARS
—

Quanto texto de uma página buscada pode entrar no contexto.

ALUY_MAX_HEAP_MB
—

O teto de memória do próprio processo do Aluy. Padrão 4096.

ALUY_MEM_PRESSURE_AT
—

A partir de quanto do teto o Aluy começa a soltar o que não precisa mais. Padrão: 85%.

ALUY_MEM_PRESSURE_OFF
—

Para de vigiar o próprio uso de memória.

ALUY_RETRY
—

Quantas vezes repetir uma chamada que falhou. off desliga.

ALUY_RETRY_WAIT_MS
—

Quanto esperar entre essas tentativas.

Freios contra execução sem fim

— param um run que está ocupado mas não vai a lugar nenhum. Todos ligados por padrão.
variávelflago que faz
ALUY_MAESTRO_OFF
—

A chave geral do supervisor — a camada que vigia o agente enquanto ele trabalha.

ALUY_MAESTRO
—

O mesmo, desligado explicitamente com 0 ou false.

ALUY_MAESTRO_MEM0
—

Se esse supervisor pode usar o sidecar de memória.

ALUY_MAESTRO_OLLAMA
—

Se ele pode usar o avaliador local.

ALUY_CYCLE_JUDGE_OFF
—

Desliga o avaliador que decide quando um /cycle terminou.

ALUY_CONT_MAX
—

Quantas vezes o agente pode continuar sozinho sem você.

ALUY_CONT_NUDGE_AT
—

A partir de quando ele recebe um empurrão para retomar o objetivo.

ALUY_CONT_GIVEUP_AT
—

A partir de quando ele desiste e devolve a palavra para você.

Terminal e saída

— para terminais que desenham mal, e para máquinas que leem a saída.
variávelflago que faz
ALUY_LANG
--lang

O idioma da interface. Não traduz o que o agente escreve.

ALUY_SAFE_GLYPHS
--ascii

O conjunto de símbolos seguro, para fontes que mostram quadradinhos vazios.

ALUY_ASCII
--ascii

Força ASCII puro, quando o conjunto seguro ainda não basta.

ALUY_NERD_GLYPHS
—

Liga o conjunto rico de símbolos, para terminal com Nerd Font instalada.

ALUY_MARK_ASCII
—

Força os marcadores de estado para ASCII.

ALUY_MARK_UNICODE
—

Força os marcadores de volta para Unicode.

ALUY_DENSITY
--dense

Espaçamento compacto ou confortável.

ALUY_FULLSCREEN
--fullscreen

Começa em modo cockpit.

ALUY_NO_ANIM
—

Sem animação de carregando e sem nada piscando, para quem prefere a tela parada.

ALUY_NOTIFY
—

A campainha que chama você quando o agente precisa de atenção.

ALUY_SUGGESTIONS
—

As sugestões que aparecem enquanto você digita.

ALUY_SHOW_MODEL
—

Se o nome do modelo fica visível na interface.

ALUY_CYCLE_UI_OFF
—

Esconde o painel do ciclo.

ALUY_SPLASH_MIN_MS
—

Quanto tempo a tela de abertura fica no ar.

ALUY_COMPOSER_ANCHOR
—

Onde o campo de escrita se ancora na tela.

ALUY_SYNC_OUTPUT
—

Desenha a tela de uma vez só, para a imagem não sair partida enquanto atualiza.

ALUY_SET_BG
—

Se o Aluy pode ajustar o fundo do terminal ao tema dele.

ALUY_OSC11_TIMEOUT_MS
—

Quanto esperar enquanto pergunta ao terminal qual é a cor de fundo dele.

ALUY_PRINT_VERBOSE
—

Mais detalhe nas execuções sem interface.

NO_COLOR
—

Não é variável do Aluy, mas é respeitada: desliga a cor em tudo.

Sidecars e memória

— onde cada sidecar escuta, e se o agente lembra de alguma coisa.
variávelflago que faz
ALUY_MEM_OFF
—

Impede o agente de relembrar a memória de longo prazo. A lembrança vem ligada.

ALUY_MEM_MIN_SCORE
—

O quanto um fato lembrado precisa ser relevante para voltar ao contexto.

ALUY_ROOM_BACKEND
—

Onde ficam guardadas as conversas entre agentes.

ALUY_MEM0_URL
—

Onde o sidecar de memória escuta. Padrão 127.0.0.1:11435.

ALUY_HEADROOM_URL
—

Onde o sidecar de contexto escuta. Padrão 127.0.0.1:8787.

ALUY_OLLAMA_URL
—

Onde o Ollama escuta. Padrão 127.0.0.1:11434.

Sandbox, atualização e depuração

— a sandbox é um cercado: o comando roda, mas não alcança o resto da máquina. Saídas de emergência; você não deveria precisar delas no dia a dia.
variávelflago que faz
ALUY_SANDBOX_BASH
—

Roda os comandos de shell dentro da sandbox.

ALUY_SANDBOX_MCP
—

Roda os servidores MCP dentro da sandbox.

ALUY_UNSAFE_NO_SANDBOX
—

Desliga a sandbox: os comandos passam a alcançar a máquina inteira. O nome da flag é o aviso.

ALUY_ENV
—

O nome do ambiente, que decide com que rigor uma falha da sandbox é tratada.

ALUY_NATIVE_TOOLS_OFF
—

Desliga as ferramentas embutidas, deixando só o que o MCP oferece.

ALUY_NO_WEAK_YOLO_WARN
—

Cala o aviso de rodar sem supervisão num modelo mais fraco.

ALUY_AUTO_UPDATE
—

Se o Aluy se atualiza sozinho, em segundo plano.

ALUY_AUTO_UPDATE_EVERY_MS
—

De quanto em quanto tempo ele confere.

ALUY_NO_UPDATE_CHECK
—

Impede a conferência. O Aluy também a pula em CI.

ALUY_UPGRADE_TIMEOUT_MS
—

Quanto uma atualização pode demorar antes de ser abandonada.

ALUY_DEBUG
—

Log interno detalhado.

ALUY_DEBUG_RENDER
—

Registra o que a interface está desenhando.

ALUY_OVERWRITE_RENDER
—

Redesenha no lugar em vez de acrescentar, para diagnosticar quando a tela pisca.

ALUY_DIR
—

Muda a pasta de instalação, no lugar de ~/.aluy.

A flag sempre vence a variável, e a variável sempre vence o que está salvo na sua configuração. O aluy config imprime qual das três venceu em cada ajuste. Existem ainda algumas variáveis que o Aluy define para si mesmo — essas não são para você mexer.

Códigos de saída: 0 sucesso · 1 erro · 2 erro de uso — neste caso o programa sai sem chegar a abrir uma sessão.

dentro de uma sessão

Comandos com barra

Colocar o agente para trabalhar

— comece uma coisa e vá cuidar de outra.
/cycle <intervalo> "<tarefa>" [--por <dur>] [--auto]

Roda uma tarefa em ciclos, sozinho, até terminar. Todo efeito passa pela catraca.

$ /cycle 30m "arruma os testes que quebraram"
  • em voo
  • pause
  • resume
  • edit
  • status
  • stop

Tem teto de tempo e de passos, e para sozinho se sair do trilho.

/cron <quando> "<tarefa>"

Agenda tarefas para rodar sozinhas, em horário fixo, na sua máquina.

$ /cron "0 9 * * 1-5" "revise os PRs abertos"
  • sub
  • add
  • list
  • edit
  • enable
  • disable
  • rm
/service <subcomando>

Agentes com rotina: acordam na hora marcada, trabalham dentro do teto que você deu e reportam no seu canal.

$ /service create
  • sub
  • create
  • list
  • status
  • start
  • stop
  • logs
  • attach
/todo

A lista de pendências que sobrevive entre sessões.

$ /todo

Trabalhar com mais de um agente

— a sua frota, e as salas onde ela conversa.
/subagent <perfil>

Abre uma conversa direta com um perfil, numa sub-sessão só dela.

$ /subagent revisor
/back

Volta do subagente para a sessão principal.

/rooms [new|list|read|watch]

Salas onde vários agentes conversam entre si. Você acompanha ao vivo e entra quando fizer sentido.

$ /rooms new
/agents

Lista os perfis de agente encontrados, os válidos e os rejeitados com o motivo.

Conectar ao que você usa

— ferramentas externas e o celular.
/mcp <search|add|list|remove>

Conectores MCP: procura no catálogo público, adiciona um servidor local, liga e desliga.

$ /mcp add postgres -- npx @modelcontextprotocol/server-postgres
  • também
  • enable
  • disable
  • reconnect
  • reload
/telegram <subcomando>

O agente no seu celular: reporta, pergunta quando precisa de decisão e avisa quando pausa.

$ /telegram allow 184920371
  • sub
  • login
  • allow
  • deny
  • status
  • logout

Só os chats que você autorizar. A lista começa fechada.

/tools

Inventário das ferramentas do agente — nativas, MCP por servidor, delegação — com o estado de permissão de cada uma.

Só lê, não muda nada.

/skills

Lista as skills SKILL.md encontradas, as válidas e as rejeitadas.

/workflows [run <nome>|use]

Sequências de etapas fixas, cada uma no especialista certo — entender, implementar, testar.

$ /workflows run sdlc-estoria

Desfazer, e manter o contexto limpo

— quando deu errado, ou a sessão ficou longa.
/undo
/redo

Desfaz a última edição de arquivo feita pelo agente. O /redo refaz.

$ /undo
/rewind

Volta a um ponto anterior da sessão: o código, a conversa, ou os dois.

Atalho: Esc Esc.

/compact

Resume a conversa para liberar espaço na janela de contexto.

/clear [full|memory]

Limpa o contexto da sessão. Com memory ou full, apaga também a memória e pede confirmação.

$ /clear memory
/usage

Tokens gastos, quanto da janela está ocupada e qual tier está em uso.

/history

Navega pelas sessões anteriores e retoma uma delas sem sair do Aluy.

/ask "<pergunta>"

Uma pergunta em paralelo, que não interrompe o trabalho em curso.

$ /ask "qual versão do Node este projeto exige?"

Configurar

— projeto, modelo, permissões e aparência.
/init

Lê o repositório e escreve o ALUY.md do projeto.

$ /init

Você confere o diff antes de aceitar.

/memory <list|forget|edit|pin|unpin>

Vê, fixa ou esquece o que o agente lembra, global e por projeto.

$ /memory forget 4

A memória volta como informação, nunca como ordem.

/model
/provider
/effort

Troca o tier, define qual provider o modo Custom usa, e ajusta o esforço de raciocínio.

$ /model

Mostra o tier, nunca a credencial.

/permissions

As regras em vigor: modo, autorizações já dadas e ferramentas seguras.

As categorias que sempre perguntam não podem ser liberadas por aqui.

/add-dir <caminho>

Autoriza uma pasta a mais para esta sessão, fora da raiz do projeto.

$ /add-dir ../design-system
/theme
/lang

Troca o tema e o idioma da interface. As duas escolhas ficam salvas.

$ /theme aluy-slate
  • valores
  • aluy-dark
  • aluy-light
  • aluy-slate
  • pt-BR
  • en
/split
/fullscreen

Tela dividida e modo cockpit.

$ /split

/view e /cockpit são apelidos e funcionam igual.

/login
/logout
/whoami

Entra, sai e mostra conta, organização e escopos.

$ /whoami

Nunca o segredo.

Quando algo está errado

— só leem; não mudam nada.
/doctor

O diagnóstico da instalação. Cada item vem com ✓, ⚠ ou ✗ e uma dica de conserto.

$ /doctor fix
  • sub
  • fix

Roda em paralelo, sem parar o trabalho.

/help

Lista todos os comandos nativos, ao vivo.

Ctrl+P abre a mesma lista numa busca rápida.

/rename <nome>

Dá um nome e uma cor à sessão, e muda o título da janela do terminal.

$ /rename "refatorar auth"
/notify

Liga e desliga o aviso sonoro de quando o agente precisa de você.