Aqui está o guia de configuração sobre como criar um agente de IA terrível com o GPT-6 Astra

Tenho pensado em uma coisa um pouco desconfortável desde que o GPT-6 Astra foi lançado.

Passamos anos aprendendo como conversar com a IA. Prompts melhores. Contexto melhor. Perguntas melhores. E, justamente quando ficamos bons nisso, a parte útil mudou para outro lugar.

Astra pode continuar trabalhando depois da primeira resposta.

Isso muda muita coisa.

Se você continuar usando apenas para escrever, explicar e responder coisas, ainda pode ser muito útil. Mas parece um pouco como comprar um computador muito potente e usá-lo apenas como calculadora.

Existe uma camada muito maior por baixo.

A parte interessante começa quando você para de pedir respostas

Astra foi criado para trabalhos longos e de ponta a ponta. Ele consegue raciocinar, usar ferramentas, pesquisar, trabalhar com arquivos, operar softwares, escrever e executar códigos, além de prosseguir através de várias etapas do mesmo trabalho. A OpenAI o descreve como seu modelo para os trabalhos de ponta a ponta mais complexos, com uma janela de contexto de 1,05 milhão de tokens e até 128.000 tokens de saída.

Mais importante ainda, o Astra agora pode realizar algumas ações estranhas enquanto trabalha.

Uma ferramenta lenta pode ser executada em segundo plano enquanto o Astra continua outra parte do trabalho.

Você pode dar a ele uma nova instrução enquanto ele já está trabalhando.

Ele pode usar diferentes níveis de raciocínio dependendo de quão difícil é a etapa atual.

Então, a unidade útil de IA está mudando.

Costumava ser:

Prompt → Resposta

Agora pode ser:

Objetivo → Planejar → Fazer → Verificar → Corrigir → Continuar → Finalizar

Esse segundo sistema é um agente.

E construir um é muito mais fácil quando você para de pensar na palavra agente.

Abaixo está a configuração prática: um agente, memória seletiva, habilidades reutilizáveis, direcionamento em tempo real, chamadas de ferramentas paralelas, armadilhas de tokens ocultas, portões de aprovação e o padrão de grafo que transforma o Astra de um chatbot em um trabalhador real.

Construa um trabalhador, não um “agente de IA”

Aqui está um ponto de partida melhor.

Imagine que você gerencia pedidos para uma pequena empresa.

Toda manhã alguém precisa:

• abrir a lista de pedidos;
• encontrar pedidos que estão atrasados;
• verificar quais clientes precisam de uma atualização;
• analisar notas anteriores;
• preparar as próximas ações;
• esboçar mensagens de acompanhamento;
• atualize a lista de tarefas.

Nenhuma dessas tarefas é muito difícil.

A parte chata é ter que fazer toda a sequência de novo amanhã.

Esse é exatamente o tipo de trabalho que eu daria a um agente da Astra.

Não:

Gerenciar meu negócio.

Algo muito mais claro:

Verifique os pedidos em aberto todas as manhãs. Encontre qualquer item atrasado. Leia as notas. Prepare os acompanhamentos. Atualize a lista de tarefas. Pare antes de enviar qualquer coisa.

Agora temos algo útil.

---

Um agente consiste realmente em seis partes simples

A OpenAI define um agente como um sistema com instruções, diretrizes de segurança e ferramentas que pode agir em nome do usuário.

Para construir um de fato, acho esta versão mais fácil:

1. Uma tarefa

O que ele deve concluir?

2. Astra

O modelo que decide o que fazer a seguir.

3. Ferramentas

As coisas que ele tem permissão para usar.

4. Contexto

O que ele precisa para este trabalho.

5. Memória

O que deve manter para trabalhos futuros.

6. Um loop

O que acontece após cada ação.

Isso nos dá:

Trabalho + Modelo + Ferramentas + Contexto + Memória + Loop

Todo o resto vem depois.

---

Comece com este agente

Nós vamos construir um Agente de Acompanhamento de Pedidos simples.

Imagine este arquivo:

orders.csv

contém:

order_id,customer,status,days_waiting
1001,John,shipped,2
1002,Sarah,processing,8
1003,Maria,processing,11
1004,David,delivered,1

Nosso agente deve:

1. ler os pedidos;
2. encontrar qualquer coisa que pareça atrasada;
3. decidir o que precisa de atenção;
4. prepare um acompanhamento;
5. salve a ação;
6. diga-nos o que ele fez.

Mais tarde, podemos conectar o mesmo agente a um sistema de pedidos real, e-mail, CRM ou banco de dados.

Comece localmente primeiro.

Isso torna os erros baratos.

---

Passo 1: Coloque o Astra em funcionamento

Crie uma pasta:

mkdir astra-agent
cd astra-agent

Crie um ambiente Python:

python3 -m venv .venv
source .venv/bin/activate

Instale o SDK da OpenAI:

pip install openai python-dotenv

Crie:

.env

e adicione:

OPENAI_API_KEY=your-key-here

Agora faça um pequeno teste:

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Give me one sentence confirming that you are ready."
)

print(response.output_text)

Execute:

python agent.py

Nada de agente ainda.

Estamos apenas verificando se o Astra funciona.

---

Passo 2: Dê mãos ao Astra

Uma IA sem ferramentas pode sugerir uma ação.

Um agente com ferramentas pode realizar uma.

Para o nosso exemplo, ele precisa de duas ferramentas simples:

read_orders()
save_followup()

Pense nas ferramentas como botões que a Astra tem permissão para pressionar.

O modelo não precisa conhecer todo o código por trás de um botão.

Ele só precisa entender:

read_orders me dá os pedidos atuais.

e:

save_followup registra o acompanhamento que preparei.

Essa é uma das formas mais úteis de pensar sobre a construção de agentes.

Não ensine ao modelo como todo o seu sistema funciona. Dê a ele ferramentas limpas para as ações de que ele precisa.

A pilha de agentes da OpenAI suporta ferramentas integradas, bem como suas próprias funções, incluindo pesquisa na web, pesquisa de arquivos, uso de computador, execução de código e conexões MCP.

---

Passo 3: Dê a ele uma função adequada

Este é o tipo de instrução que eu usaria:

You are the Order Follow-up Agent.

Your job is to check open orders and find the ones
that need attention.

For every run:

1. Read the current orders.
2. Ignore completed orders.
3. Look carefully at orders waiting unusually long.
4. Prepare a short next action.
5. Save the follow-up task.
6. Check your work before finishing.

Do not send emails.
Do not refund orders.
Do not change payments.
Do not delete anything.

If an action could affect a customer or money,
ask for approval first.

Finish with a short report:
- what you found
- what you added
- what needs human attention

Note como isso é comum.

Não existem palavras mágicas de prompt.

As partes importantes estão bem claras:

• trabalho
• processo
• limites
• definição de pronto

Isso é o que um agente precisa.

---

O loop é o agente real

Agora imagine que a Astra começa.

Ele lê as ordens.

Sarah está esperando há oito dias.

Maria está esperando há onze dias.

Astra cria duas tarefas de acompanhamento.

Então, verifica:

Eu processei todos os pedidos em aberto que precisam de atenção?

Se sim, ele para.

Se não, ele continua.

Esse é o loop.

Read
 ↓
Decide
 ↓
Act
 ↓
Check result
 ↓
Finished?
 ↙       ↘
No       Yes
↓         ↓
Repeat   Stop

Esse pequeno loop é a base de sistemas muito maiores.

Um agente de codificação faz a mesma coisa:

Read code
→ change code
→ run test
→ inspect failure
→ change code
→ test again

Um agente de navegador:

Open page
→ inspect
→ click
→ observe
→ decide
→ continue

Um agente de operações:

Read work
→ find issue
→ take allowed action
→ verify
→ continue

O trabalho muda.

O ciclo permanece.

---

Memória não é o mesmo que contexto

Isso se torna importante muito rapidamente.

A Astra pode aceitar uma quantidade enorme de contexto.

Mas isso não significa que você deva continuar colocando tudo em cada execução.

A janela de contexto da Astra é de 1,05 milhão de tokens.

Isso é enorme.

Mas um contexto grande também custa dinheiro e pode conter muita informação que não tem nada a ver com o trabalho atual.

Uso uma distinção muito simples.

Contexto = o que a Astra precisa agora

Por exemplo:

Today's orders
Current task
Customer notes for these orders
Rules for handling delays

Memória = algo que vale a pena guardar

Por exemplo:

Customer Sarah prefers email.

Order 1002 was delayed because stock arrived late.

Never offer refunds without approval.

Armazenamento = onde a memória vive

Isso pode ser:

• SQLite;
• Postgres;
• um banco de dados vetorial;
• seu CRM;
• um banco de dados normal;
• estado gerenciado pela OpenAI.

Recuperação = encontrar a memória certa novamente

Esta é a parte inteligente.

Se o seu agente tiver 30.000 memórias armazenadas, a Astra não deve ler todas as 30.000.

Ele deve recuperar apenas as poucas que importam para a tarefa atual.

Portanto:

Armazene muito. Recupere pouco.

Essa é uma regra muito boa para agentes de longa duração.

---

A retenção de longo prazo precisa de um filtro

Não deixe um agente se lembrar de tudo.

Isso cria outro problema: memória ruim.

Imagine que a Astra armazene:

O cliente está bravo.

Talvez isso fosse verdade antes.

Seis meses depois, o agente recupera a informação e trata o cliente de forma diferente.

Essa não é uma memória útil.

Uma regra de memória melhor é assim:

SAVE

Stable preferences
Confirmed decisions
Important history
Repeated rules
Useful outcomes from previous work

DO NOT SAVE

Temporary guesses
Old task details
Raw reasoning
Unconfirmed information
Information that will quickly expire

Você pode até dar à Astra uma pequena decisão de memória:

Before saving a memory, ask:

Will this information probably help in a future task?

If no, do not save it.

A qualidade da memória importa mais do que o tamanho da memória.

---

Habilidades ensinam ao agente como você trabalha

Agora imagine que você finalmente acerta o processo de pedido.

Você não quer explicar isso de novo todos os dias.

Transforme o processo em uma Habilidade.

OpenAI Skills são pacotes reutilizáveis de instruções e arquivos, geralmente construídos em torno de um SKILL.md arquivo.

Exemplo:

skills/
└── delayed-orders/
    └── SKILL.md

Dentro:

# Delayed Order Skill

Use this process when checking delayed orders.

1. Read the order status.
2. Check how long it has been waiting.
3. Read previous customer notes.
4. Find the likely reason for delay.
5. Prepare the next useful action.
6. Do not promise a delivery date unless it is confirmed.
7. Do not issue refunds without approval.

Esse pequeno arquivo pode se tornar o procedimento operacional padrão do agente.

Isso é muito mais limpo do que colocar cada regra da empresa dentro de um prompt enorme.

Pense nisso desta forma:

Prompt = pedido de hoje

Habilidade = como esse tipo de trabalho deve ser sempre feito

---

As ferramentas dão alcance ao agente

Nossa primeira versão lê um CSV local.

Eventualmente, isso se torna limitante.

Um agente real pode precisar de:

• Gmail;
• Google Calendar;
• Dropbox;
• um CRM;
• Shopify;
• Slack;
• seu banco de dados;
• um sistema interno da empresa.

É aqui que conectores, plugins e o MCP se tornam úteis.

Os conectores e servidores MCP remotos da OpenAI permitem que modelos se conectem a serviços e ferramentas externos.

Você não precisa entender profundamente o MCP para usar a ideia.

Pense:

Astra
  ↓
MCP / Connector
  ↓
Outside service

Em vez de dar a Astra todo o seu banco de dados, você pode expor ações úteis:

get_order()
find_customer()
create_task()
draft_email()
update_status()

Isso é muito mais seguro.

Astra vê as portas que você escolhe abrir para ela.

Não o prédio inteiro.

---

Não lhe dê todas as ferramentas que você possui

Esta é uma das maneiras mais fáceis de tornar um agente pior.

Imagine que a Astra veja 80 ferramentas.

Ela precisa escolher uma.

Os nomes se sobrepõem.

Vários podem executar ações semelhantes.

Agora você criou outro problema de raciocínio.

Para o agente de pedidos, eu começaria com:

read_orders
get_customer_history
save_followup

Então talvez:

draft_email

Mais tarde:

send_email

E send_email deve exigir aprovação.

Isso é o suficiente.

Adicione ferramentas porque o fluxo de trabalho precisa delas.

Não porque a ferramenta exista.

---

O novo truque: Astra nem sempre precisa esperar

Este é um dos recursos de agente mais úteis do Astra.

Imagine que o agente precisa:

check warehouse stock
check courier status
read customer history

O sistema de armazém leva 20 segundos.

O agente não precisa necessariamente ficar ocioso.

O Astra suporta chamadas de ferramenta assíncronas. Ele pode continuar raciocinando ou trabalhar em outra parte independente enquanto sua aplicação executa a ferramenta lenta.

Portanto, isto:

Check stock
↓
WAIT
↓
Check courier

pode se tornar mais próximo de:

Start stock check ───────┐
                         │
Check courier            │
                         │
Read customer history    │
                         │
Stock result arrives ←───┘
        ↓
Make decision

Isso parece pequeno.

Em dezenas de chamadas de ferramenta, isso pode fazer muita diferença.

O aviso importante é que o trabalho paralelo também pode criar novos problemas.

Se duas ferramentas alteram os mesmos dados ao mesmo tempo, você precisa controlar isso.

Portanto, use o trabalho paralelo para tarefas independentes.

---

Você pode alterar o trabalho enquanto a Astra o está executando

Há outro novo recurso do Astra que acho mais interessante do que parece à primeira vista.

Direção no meio da curva.

Suponha que seu agente já esteja processando 300 pedidos.

Então você percebe:

Não processe pedidos internacionais hoje. O sistema de correios está fora do ar.

Normalmente, você poderia interromper a tarefa e reiniciá-la.

Com o Astra, você pode enviar uma nova instrução enquanto o trabalho já está sendo executado. O trabalho concluído pode ser preservado e a nova instrução torna-se parte da continuação.

Isso muda os agentes de longa execução.

Eles se tornam mais fáceis de supervisionar.

Em vez de:

START
↓
hope everything is correct
↓
FINISH

você pode ter:

START
↓
observe
↓
correct
↓
continue
↓
correct again if needed
↓
FINISH

Isso parece muito mais com a gestão do trabalho.

---

Nem todo passo merece o máximo de raciocínio

Astra suporta:

• baixo
• médio
• alto
• muito alto
• máximo

esforço de raciocínio.

Não escolha automaticamente o máximo.

Considere nosso agente.

Lendo:

O pedido 1003 está aguardando há 11 dias.

é fácil.

Decidindo:

Este pedido tem registros conflitantes de depósito, transportadora e pagamento. O que provavelmente aconteceu?

é mais difícil.

Um sistema útil pode tratá-los de forma diferente.

Reading / sorting
→ low

Normal decisions
→ medium

Complex exception
→ high

Very difficult investigation
→ xhigh or max

Use inteligência onde o trabalho precise de inteligência.

Isso é tanto mais rápido quanto mais barato.

---

Monitore a fatura de tokens antes que o agente se torne grande

Um agente pode chamar o Astra repetidamente dentro de um mesmo trabalho.

Portanto, o custo importa mais do que em um chat normal.

A precificação padrão atual de texto do Astra é:

Tokens —> Preço por 1M

• Entrada > $10
• Entrada em cache > $1
• Gravações em cache > $12,50
• Saída > $50

Prompts acima de 272 mil tokens de entrada mudam para um preço maior de contexto longo para toda a solicitação.

As regras de custo mais simples são:

Mantenha o contexto pequeno

Envie o que importa para esta etapa.

Recupere a memória

Não cole o histórico inteiro.

Mantenha as instruções repetidas estáveis

Isso ajuda no cache.

Mantenha as respostas intermediárias curtas

O agente não precisa explicar tudo para si mesmo.

Coloque um limite nos loops

Por exemplo:

Maximum tool calls: 20

Maximum retries per failed action: 2

If still blocked:
stop and ask for help.

Nunca crie:

Keep trying until successful.

Essa é uma sentença cara.

---

Depois dos loops vem o pensamento em grafos

Um loop pode te levar surpreendentemente longe.

Então o trabalho se torna mais complicado.

Nosso agente de pedidos pode eventualmente fazer isto:

                    ┌→ Check stock ────────┐
                    │                       │
New order → Inspect ┼→ Check payment ──────┼→ Decide
                    │                       │
                    └→ Check courier ───────┘
                                                ↓
                                      ┌─────────┴─────────┐
                                      ↓                   ↓
                                  Normal              Problem
                                      ↓                   ↓
                                  Continue          Human review

Isso é um grafo.

Um grafo simplesmente diz ao sistema:

o que pode acontecer a seguir.

Isso está se tornando uma habilidade importante em IA.

O design de prompt diz à Astra o que fazer.

O design de contexto diz à Astra o que ela precisa saber.

O design de gráfico diz a todo o sistema para onde o trabalho deve ir em seguida.

Se você já entende ferramentas como n8n, Make ou Zapier, esta ideia parecerá familiar.

A diferença é que a IA agora pode tomar algumas dessas decisões de roteamento por conta própria.

---

Use esta arquitetura de agente simples

Eu construiria um primeiro agente Astra sério assim:

JOB
↓
Astra
↓
Get relevant context
↓
Retrieve useful memory
↓
Choose tool
↓
Run tool
↓
Inspect result
↓
Need another step?
    ↓
   YES → continue loop
    ↓
    NO
↓
Verify
↓
Human approval if needed
↓
Finish
↓
Save useful memory

Isso é arquitetura suficiente para um agente muito capaz.

Você não precisa começar com 12 subagentes.

---

Quando um agente se torna três

Divida o sistema apenas quando um agente estiver fazendo tarefas demais.

Por exemplo:

ORDER AGENT

checks the order

CUSTOMER AGENT

reads customer history
and prepares communication

REVIEW AGENT

checks the final action
before anything happens

Agora você tem:

Order Agent
      ↓
Customer Agent
      ↓
Review Agent
      ↓
Human approval

Isso é um fluxo de trabalho multiagente.

A OpenAI oferece suporte à orquestração multiagente como parte de sua pilha atual de agentes.

Mas eu não começaria por aqui.

Um bom agente supera cinco agentes confusos.

---

A ferramenta mais importante ainda é o botão PARAR

Quanto mais capaz o agente se torna, mais importantes se tornam seus limites.

Para nosso agente de pedidos:

Seguro sem aprovação

Read orders
Search records
Read customer history
Create internal task
Prepare draft
Summarize

Requer aprovação

Send customer message
Issue refund
Cancel order
Change payment
Delete record
Change account

As ferramentas MCP da OpenAI definem a aprovação como padrão para chamadas de ferramentas, porque ferramentas externas podem enviar dados e realizar ações reais. A OpenAI também recomenda o uso de servidores confiáveis e a revisão de quais dados estão sendo compartilhados.

Um agente poderoso não deveria significar:

Que ele pode fazer qualquer coisa.

Deveria significar:

Que ele pode fazer tudo o que é necessário para este trabalho, dentro de limites muito claros.

---

Meu modelo de prompt de agente

Para um novo agente Astra, eu começaria com isto:

ROLE

You are the [NAME] Agent.

JOB

Your job is to:
[ONE CLEAR JOB]

SUCCESS

The job is finished when:
[EXACT RESULT]

TOOLS

You may use:
[TOOLS]

PROCESS

1. Understand the job.
2. Get the information you need.
3. Use the correct tool.
4. Read the tool result.
5. Continue only if another step is needed.
6. Check the final result.

MEMORY

Save only information that will probably be useful later.

Retrieve only memories relevant to the current job.

LIMITS

Never:
[LIST FORBIDDEN ACTIONS]

APPROVAL

Ask me before:
[SENDING / DELETING / BUYING / PUBLISHING /
CHANGING IMPORTANT DATA]

FAILURE

If a tool fails:
try one sensible alternative.

Do not repeat the same failed action more than twice.

If still blocked, stop and explain the problem.

FINISH

Tell me:
what you did,
what changed,
what you could not finish,
and what needs my approval.

Isso é o suficiente para começar.

Não gaste três dias aprimorando o prompt.

Construa o loop.

Quatro agentes que vale a pena construir agora

1. Agente de Operações

Verifica o trabalho recebido, encontra informações ausentes, cria tarefas e prepara as próximas ações.

2. Agente de Acompanhamento ao Cliente

Lê o histórico do cliente, encontra casos não resolvidos e prepara o acompanhamento correto.

3. Agente de Projetos

Lê arquivos de projetos, verifica prazos, acompanha tarefas abertas e relata o que está travado.

4. Agente de Site

Abre seu site, verifica fluxos importantes, registra problemas e prepara correções.

Todos os quatro seguem basicamente o mesmo padrão:

Observar → Decidir → Agir → Verificar → Continuar

Assim que você aprende esse padrão, a palavra agente se torna muito menos misteriosa.

O que eu aprenderia para

Eu não tentaria aprender todo o ecossistema de agentes de uma vez.

Aprenda nesta ordem:

Primeiro: ferramentas

Faça com que Astra execute uma ação real.

Depois: loops

Deixe que continue até que um pequeno trabalho seja concluído.

Então: memória

Deixe a informação útil sobreviver à execução.

Então: recuperação

Traga de volta apenas a memória necessária.

Então: Habilidades

Salve maneiras repetíveis de trabalhar.

Depois: MCP e conectores

Dê ao agente acesso a sistemas externos.

Depois: trabalho assíncrono

Permita que tarefas independentes aconteçam simultaneamente.

Então: grafos

Controle fluxos de trabalho maiores.

Então: múltiplos agentes

Divida o trabalho apenas quando um agente ficar genuinamente sobrecarregado.

Esse caminho é muito mais fácil do que começar com diagramas cheios de 20 agentes conversando entre si.

A atualização oculta do Astra é o sistema ao seu redor

A maneira fácil de ver o GPT-6 Astra é perguntar o quanto o modelo se tornou mais inteligente.

Acho que isso deixa passar a parte interessante.

A verdadeira mudança é o que agora podemos construir em torno do modelo.

O Astra pode ter ferramentas.

Pode ter memória.

Pode recuperar informações antigas.

Pode seguir Skills reutilizáveis.

Pode se conectar a sistemas externos.

Pode trabalhar através de um loop.

Ele pode executar ferramentas independentes enquanto outros trabalhos continuam.

Ele pode ser corrigido enquanto o trabalho ainda está sendo executado.

Ele pode pensar mais intensamente apenas quando um passo difícil aparece.

E um grafo pode decidir para onde todo esse trabalho vai em seguida.

Isso começa a parecer menos com um chatbot.

Parece mais um pequeno trabalhador de software.

Eu não começaria tentando construir o agente mais inteligente possível.

Escolha uma tarefa chata que se repete todos os dias.

Faça a Astra dar o primeiro passo útil.

Depois o segundo.

Em seguida, deixe que verifique se essas etapas funcionaram.

Dê a ele memória apenas quando ele precisar de memória.

Dê a ele outra ferramenta apenas quando essa ferramenta eliminar trabalho manual real.

Faça isso por tempo suficiente e algo interessante acontece.

Você para de pensar:

O que eu deveria perguntar à IA?

Você começa a pensar:

Por que ainda estou fazendo este trabalho sozinho?