Como rodar o GPT-6 Astra no terminal com o llm 0.35

Fala aí, beleza? O GPT-6 Astra acabou de chegar no seu terminal, e você não precisa de nenhum wrapper mirabolante pra isso

A versão 0.35 do llm, a ferramenta de linha de comando do projeto simonw/llm mantida por Simon Willison, adicionou o modelo da OpenAI gpt-6-astra. As notas de release são diretas: "New OpenAI model: gpt-6-astra for GPT-6 Astra"

O modelo foi anunciado pela OpenAI em 3 de setembro de 2026, e o modelo de API gpt-6-astra ficou disponível em 4 de setembro

Aqui você vai ver como atualizar o llm, configurar a chave da OpenAI, fazer a primeira chamada e encadear tudo isso com outros comandos do shell, mandando texto por pipe

Bora? 🙂

O que você precisa antes de começar

A lista é curta:

• O llm instalado na máquina
• Uma chave de API da OpenAI
• Um terminal, e só

Se você nunca usou o llm, se liga no que ele é: um utilitário de linha de comando E uma biblioteca Python pra acessar modelos de linguagem, tanto via APIs remotas quanto modelos rodando localmente. E ele registra os resultados em SQLite, o que vai ser importante lá na frente

Se você conhece o npm ou o composer, a lógica de plugin do llm vai te soar familiar: ele tem ecossistema próprio instalado no mesmo ambiente da ferramenta

Formação Recomendada

Formação Claude Code

Domine Claude Code do absoluto zero até o avançado

• 120 aulas
• 4 projetos
• 9h 45min

Conhecer formação

Não quer instalar nada permanente?

Dá pra rodar via uvx:

uvx llm

Todos os comandos normais funcionam nesse modo

Tome cuidado! Se você instalou o llm como ferramenta do uv, atualizar com uv tool upgrade llm remove os plugins que você tinha instalado. Vai precisar reinstalar tudo depois

Melhor saber disso antes de perder a configuração, né?

Passo a passo: do llm 0.35 até a primeira resposta do GPT-6 Astra

1. Atualize o llm para a 0.35

O próprio llm tem um comando de instalação que trabalha no mesmo ambiente dele, e a flag -U/--upgrade faz a atualização:

llm install -U llm

A 0.35 é a versão mais recente do pacote publicada no PyPI (não existe 0.36 publicada até agora), então é essa que você quer

O erro comum deste passo: atualizar com uv tool upgrade llm por costume e descobrir depois que os plugins sumiram. Se você foi por esse caminho, reinstale os plugins antes de seguir

2. Guarde a chave da OpenAI

A forma recomendada é essa:

llm keys set openai

O comando vai pedir a chave pra você colar ali no prompt. Ela fica salva em um arquivo keys.json no diretório de configuração da ferramenta

Onde esse arquivo mora?

Se você não quiser usar o keys.json, existem duas alternativas: a variável de ambiente OPENAI_API_KEY ou a opção --key direto na chamada

llm "prompt" --key sk-sua-chave

Pra conferir o que já está guardado:

llm keys get openai

O erro comum deste passo: achar que a chave foi salva quando na verdade você só exportou a variável de ambiente naquela sessão do terminal. Fechou o terminal, foi embora. O llm keys get openai mata a dúvida em um segundo

3. Confirme que o modelo existe aí

Atualizou, mas será que o gpt-6-astra apareceu mesmo? O llm lista os modelos disponíveis:

llm models

E dá pra filtrar por termo de busca com -q/--query, que é bem mais rápido que ficar caçando com o olho:

llm models list -q astra

Se você quer a saída estruturada pra jogar em outro script, tem o --json:

llm models list --json

O erro comum deste passo: o modelo não aparecer porque a atualização não pegou de verdade (ambiente diferente, instalação duplicada). Se o -q astra voltar vazio, o problema é o passo 1, não a chave

4. Faça a primeira chamada

O modelo de uma chamada é escolhido com -m/--model:

llm -m gpt-6-astra "explique o que é um heredoc em bash em 3 linhas"

É isso. Resposta no terminal, sem navegador, sem aba aberta

O erro comum deste passo: escrever o id do modelo errado. É gpt-6-astra, com hífen entre tudo

5. Opcional: deixe ele como padrão

Se o GPT-6 Astra virou seu daily driver, define ele como modelo padrão e para de digitar -m toda vez:

llm models default gpt-6-astra

O comando aceita qualquer alias suportado do modelo

O erro comum deste passo: definir o padrão e esquecer, aí meses depois a conta de API chega diferente do esperado. Mais pra frente eu falo dos números

Encadeando o llm com outros comandos do shell

Agora vem a parte que faz o terminal valer a pena

O llm aceita texto por stdin. E tem uma regra que você PRECISA entender antes de sair pipando qualquer coisa: quando o texto vem por stdin junto com argumentos, o prompt final é o conteúdo do pipe seguido dos argumentos

Ou seja:

cat myscript.py | llm 'explain this code'

vira, na prática, um prompt assim: <conteúdo do arquivo> explain this code

O texto entra ANTES da instrução. Guarda isso

Mandando um log de erro pro modelo

Mesma mecânica, outro conteúdo:

cat erro.log | llm -m gpt-6-astra 'qual a causa raiz desse erro?'

Mandando a saída do git diff

git diff | llm -m gpt-6-astra 'revise essas mudanças e aponte riscos'

Simples assim, o diff inteiro vai como contexto e a pergunta vem depois

Só fica esperto com o tamanho do que tu joga no pipe: acima de 272.000 tokens de entrada a cobrança muda de faixa, e eu detalho isso na seção de preço mais pra frente

Usando system prompt pra dar o enquadramento

A opção -s/--system define o system prompt, e é o jeito padrão de instruir o modelo sobre o conteúdo que chegou por pipe:

cat README.md | llm -s 'You are groot; summarize this README.'

O exemplo é o da própria documentação, e a ideia se aplica igual pro seu caso: o -s diz COMO tratar o que veio, enquanto o pipe entrega o QUE tratar

O erro comum desta seção: escrever a instrução como se ela viesse primeiro. Se você monta o texto pensando "analise o seguinte log:" e o log já entrou antes, a leitura do prompt muda e a resposta sai torta. Ou você escreve a instrução pensando no conteúdo já apresentado, ou joga o enquadramento no -s

Como verificar que você usou mesmo o gpt-6-astra

Essa é a pergunta que quase ninguém faz e depois vira dor de cabeça: o modelo que respondeu foi o que você achava que era?

Por padrão, o llm registra todo prompt e resposta em um banco SQLite. Então a verificação é uma consulta, não um achismo

Pra ver a última entrada:

llm logs list -n 1

O -n/--count controla quantas entradas aparecem. O padrão é 3, e 0 traz todas

Dá pra filtrar por modelo com -m, o que é ótimo quando você tem vários modelos configurados e quer isolar só as chamadas de um deles

Abrindo o banco inteiro

O caminho do banco de logs sai com:

llm logs path

E dá pra abrir no Datasette direto:

datasette "$(llm logs path)"

Aí você navega pelos registros com calma. Se você leva a sério a ideia de registrar chamadas de modelo desde o primeiro dia, esse banco é um ponto de partida que já vem de graça

E se eu não quiser registrar nada?

Prompt sensível acontece. O registro pode ser desligado, religado e consultado:

llm logs off
llm logs on
llm logs status

O erro comum deste passo: desligar o log "só nessa vez" e esquecer religado… digo, esquecer desligado. O llm logs status te diz em que pé está

Onde o GPT-6 Astra no terminal compensa (e onde não)

Agora os números, que é onde a conversa fica honesta

O GPT-6 Astra tem 1.050.000 tokens de janela de contexto e 128.000 tokens de saída máxima. Isso é o que sustenta o caso de uso de pipe: jogar um log gigante ou um diff extenso inteiro, sem picotar em pedacinhos

O corte de conhecimento dele é abril de 2026, então pra biblioteca que mudou depois disso, você precisa mandar a documentação junto no prompt

E o preço?

E tem um detalhe importante, que muda tudo justamente no caso de pipe: requisições acima de 272.000 tokens de entrada são cobradas com tarifas de contexto longo, mais altas que as padrão. Ou seja, a tabela acima é a tarifa padrão, não um preço fixo pra qualquer tamanho de requisição

Traduzindo isso pra decisão prática

Compensa quando:

• Você quer contexto grande de uma vez só (log inteiro, diff extenso, arquivo comprido)
• A resposta esperada é curta e objetiva ("qual a causa raiz?", "tem risco aqui?")
• Você já está no terminal e não quer trocar de contexto mental

Pesa mais quando:

• Você pipa arquivo enorme por hábito, sem precisar. Acima de 272K tokens de entrada, a tarifa muda de patamar
• Você pede saída longa. Olhando a tabela, a saída é o item mais caro da conta: US$ 50,00 contra US$ 10,00 da entrada

Resumindo sem rodeio: entrada grande e saída curta é o formato que mais aproveita o modelo. Entrada grande E saída longa é o combo que dói no bolso

E tem um ponto que vale pensar antes de automatizar qualquer coisa em cima disso: resposta de modelo varia entre execuções, então antes de confiar cegamente em um resultado, vale rodar o mesmo prompt mais de uma vez e comparar

Vídeo: entendendo modelos de LLM na prática

Pra começar do zero com comparação entre modelos de linguagem, este vídeo do canal coloca modelos frente a frente e mostra como avaliar o que cada um entrega

Próximo passo

Recapitulando o fluxo inteiro:

1. Atualizar com llm install -U llm
2. Guardar a chave com llm keys set openai
3. Conferir o modelo com llm models list -q astra
4. Chamar com llm -m gpt-6-astra "prompt"
5. Pipar o que você já tem no shell (cat erro.log | llm ..., git diff | llm ...)
6. Conferir no log com llm logs list -n 1

O próximo passo depende do seu uso. Se o GPT-6 Astra virou o modelo do dia a dia, define ele como padrão com llm models default e economiza digitação. Se você quer controlar custo e escolher modelo por tarefa, mantém o -m gpt-6-astra em cada chamada, fica mais consciente

Pra acompanhar o que muda daqui pra frente, a página oficial do modelo é a do anúncio na OpenAI, e as notas de release ficam no repositório simonw/llm

Até o próximo post! 😀