Vou te poupar vinte minutos de papo motivacional: você não precisa de $500/mês em créditos de API — taxas que você paga pra usar o cérebro de IA de outra empresa — pra construir um agente de IA que faz trabalho de verdade. Você precisa de um terminal (aquela janela preta onde hackers digitam), uma API key gratuita (uma senha que permite seu código conversar com um serviço de IA), e a disposição de ler documentação ao invés de assistir tutoriais no YouTube sobre como ler documentação.

Em março de 2026, eu toco toda a operação do Nero News — quatro canais no Telegram, um site, um pipeline automatizado de conteúdo, geração de imagens — e a fase de MVP custou exatamente zero reais. Aqui vai como você faz o mesmo.

O problema que ninguém admite

Todo tutorial de "construa um agente de IA" assume que você tem um cartão de crédito pronto e uma conta na nuvem que não te dá calafrios. A economia dos influenciadores de IA vive de fazer coisas simples parecerem caras. Mas as ferramentas de verdade? Grátis. A infraestrutura? Grátis. A única parte cara é o seu tempo lendo isso ao invés de construir. Vamos resolver isso.

Passo 1: Coloque o Claude Code pra funcionar (de graça mesmo)

Claude Code é o agente de programação via terminal da Anthropic. Ele lê seu codebase — toda a pasta do seu projeto — escreve código, executa comandos e pensa antes de agir. Diferente de programação via chat onde você fica copiando e colando trechos, ele opera direto dentro do diretório do seu projeto como um dev sentado no seu teclado.

Aqui vai o detalhe que todo mundo perde: Claude Code funciona com a API, e a Anthropic te dá créditos grátis quando você se cadastra em console.anthropic.com.

# Instale o Claude Code globalmente
npm install -g @anthropic-ai/claude-code

# Pegue sua API key em console.anthropic.com
# Contas novas ganham $5 em créditos grátis — suficiente pra um MVP completo
export ANTHROPIC_API_KEY=sk-ant-...

# Navegue até seu projeto e comece
mkdir my-agent && cd my-agent
claude

Esses $5 em créditos grátis rendem mais do que você imagina. O Claude Haiku 4.5 — o modelo mais barato da família — custa $1 por milhão de tokens de entrada e $5 por milhão de tokens de saída. (Um token é aproximadamente ¾ de uma palavra — a forma como a IA lê texto, em pedaços pequenos.) Esses $5 cobrem aproximadamente 1 milhão de tokens de entrada e 200 mil de saída. Suficiente pra construir um agente funcional do zero.

Dica: Configure ANTHROPIC_MODEL=claude-haiku-4.5 no seu ambiente pra usar o modelo mais barato durante o desenvolvimento. Mude pro Sonnet — o irmão mais esperto e mais caro — só quando precisar de decisões arquiteturais complexas.

export ANTHROPIC_MODEL=claude-haiku-4.5

Passo 2: Escolha um trabalho (não doze)

É aqui que a maioria se esborracha. Constroem "um assistente de IA de propósito geral" e acabam com um chatbot que faz tudo mal feito. Um agente precisa de um trabalho. Um.

Boas ideias de agente a custo zero:

  • Pipeline de conteúdo — buscar notícias, resumir, formatar, postar num canal
  • Revisor de código — monitora um repo (uma pasta de código no GitHub), revisa PRs (pull requests — propostas de mudança no código), posta comentários
  • Coletor de dados — captura dados de APIs públicas, formata relatórios
  • Organizador de arquivos — processa arquivos recebidos, categoriza, renomeia
  • Bot de monitoramento — verifica se seus serviços estão vivos, grita com você quando não estão

Más ideias de agente pra orçamento zero:

  • Qualquer coisa que exija processamento de voz em tempo real
  • Geração de imagens em escala (esses custos acumulam rápido)
  • Agentes chamando modelos caros milhares de vezes por dia

Crie um arquivo de spec simples — uma descrição em texto do que seu agente faz:

# Agente: Bot de Resumo Diário de Notícias

## Trabalho
Buscar top notícias de IA, resumir cada uma em 2-3 frases, postar no canal do Telegram.

## Entradas
- Feeds RSS (grátis)
- APIs públicas de notícias (plano gratuito)

## Saídas
- Mensagens formatadas pro Telegram
- Postadas a cada 2 horas

## Ferramentas necessárias
- Python 3 (grátis)
- python-telegram-bot (grátis)
- feedparser (grátis)

Passo 3: Monte a stack gratuita

Cada ferramenta abaixo custa exatamente nada:

Runtime & Linguagem:

python3 --version
# Se não tiver: sudo apt install python3 python3-pip python3-venv

Bot do Telegram — seu canal de distribuição gratuito: Mande mensagem pro @BotFather no Telegram, envie /newbot, pegue seu token. A Bot API do Telegram é completamente grátis. Sem limite de mensagens. Sem limite de canais. Essa é sua camada de distribuição a custo zero.

Fontes de dados gratuitas:

# NewsAPI.org — 100 requisições/dia grátis
# Feeds RSS — ilimitados, grátis pra sempre
import feedparser
feed = feedparser.parse("https://techcrunch.com/feed/")
for entry in feed.entries[:5]:
    print(entry.title, entry.link)

# API do GitHub — 5.000 requisições/hora sem autenticação

Opções de hospedagem gratuita:

  • Sua própria máquina — cron job (uma tarefa agendada que roda automaticamente), não custa nada
  • GitHub Actions — 2.000 minutos/mês grátis, perfeito pra agentes agendados
  • Oracle Cloud Free Tier — 2 VMs (máquinas virtuais — computadores na nuvem), realmente grátis pra sempre
  • Cloudflare Workers — 100.000 requisições/dia grátis

Passo 4: Deixe o Claude Code construir

É aqui que o Claude Code justifica sua existência. Em vez de escrever tudo na mão, você descreve o que quer e ele escreve a implementação. Abra no diretório do seu projeto:

Build a Python agent that:
1. Reads RSS feeds from a list in config.yaml
2. Filters articles from the last 2 hours
3. Extracts title, summary, and URL from each
4. Formats as a Telegram message with bold title and source link
5. Sends to a Telegram channel via Bot API
6. Tracks posted articles in a JSON file to avoid duplicates
7. Runs via cron every 2 hours

O Claude Code gera toda a estrutura do projeto:

my-agent/
├── config.yaml          # Feeds RSS, ID do canal, configurações
├── agent.py             # Lógica principal
├── sender.py            # Envio pro Telegram
├── dedup.py             # Detecção de duplicatas
├── requirements.txt     # Dependências
└── state/
    └── posted.json      # Histórico de dedup

A diferença chave de ficar copiando e colando snippets do ChatGPT: o Claude Code lê todo o seu projeto antes de escrever código novo. Ele cria módulos interconectados que realmente referenciam uns aos outros corretamente. Sem imports órfãos. Sem funções faltando.

Passo 5: Adicione inteligência com seus créditos grátis

Em vez de só encaminhar títulos de RSS como um leitor RSS de 2008, adicione o cérebro do Claude na mistura:

import anthropic

client = anthropic.Anthropic()  # Usa a env var ANTHROPIC_API_KEY

def summarize_article(title: str, content: str) -> str:
    response = client.messages.create(
        model="claude-haiku-4.5",
        max_tokens=200,
        messages=[{
            "role": "user",
            "content": f"Summarize this news in 2 sentences. "
                       f"Be direct, no hype:\n\n"
                       f"Title: {title}\n\nContent: {content}"
        }]
    )
    return response.content[0].text

No preço do Haiku, cada sumarização custa cerca de $0,001. Seus $5 cobrem aproximadamente 5.000 chamadas. Postando 6 vezes por dia, são mais de dois anos de operação. Dois. Anos. De graça.

Passo 6: Deploy por $0 com GitHub Actions

Pule o servidor. GitHub Actions — o sistema de automação integrado do GitHub — roda seu agente num agendamento de graça:

# .github/workflows/agent.yml
name: News Agent
on:
  schedule:
    - cron: '0 */2 * * *'  # A cada 2 horas
  workflow_dispatch:         # Botão de trigger manual

jobs:
  post:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - run: pip install -r requirements.txt
      - name: Run agent
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
        run: python agent.py
      - name: Save state
        run: |
          git config user.name "agent-bot"
          git config user.email "[email protected]"
          git add state/
          git diff --cached --quiet || git commit -m "update state"
          git push

Adicione seus secrets em Settings do repo → Secrets and Variables → Actions. O arquivo de estado faz commit de volta pro repo — persistência gratuita sem banco de dados.

O plano grátis do GitHub te dá 2.000 minutos/mês. Cada execução leva ~30 segundos. Rodando 12 vezes por dia = 6 minutos/dia = 180 minutos/mês. Você está usando 9% da sua cota.

Passo 7: Monitore sem gastar

Seu agente está no ar. Adicione guardrails básicos:

import logging

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s'
)

try:
    posts = fetch_and_process()
    for post in posts:
        send_to_telegram(post)
        logging.info(f"Posted: {post['title']}")
except Exception as e:
    logging.error(f"Agent failed: {e}")
    send_alert(f"Agent down: {e}")  # Alerta no seu Telegram pessoal

Acompanhe seus custos também — saiba sempre o que você está queimando:

response = client.messages.create(...)
cost = (response.usage.input_tokens * 1 +
        response.usage.output_tokens * 5) / 1_000_000
logging.info(f"API cost: ${cost:.4f}")

Os tradeoffs que ninguém menciona

Grátis tem limites. Seu agente no GitHub Actions não responde em tempo real — ele acorda num agendamento. O Haiku é rápido e barato mas não vai escrever obras-primas literárias. Créditos grátis da API expiram. O tier "sempre grátis" da Oracle tem fila de espera. E se seu agente viralizar, o plano gratuito não escala.

Mas nada disso importa na fase de MVP. Você está validando se alguém se importa, não construindo pra um milhão de usuários.

O caminho de upgrade (quando estiver pronto)

Estágio Custo O que muda
MVP $0 Créditos grátis + GitHub Actions
Crescendo $5/mês VPS barato — Hetzner CAX11 + cron
Sério $20/mês Claude Pro pra dev + API pra produção
Negócio $50-100/mês Servidor dedicado + Sonnet pra qualidade

O ponto não é ficar no $0 pra sempre. É validar sua ideia antes de comprometer dinheiro. A maioria dos agentes falha não por limites técnicos, mas porque resolvem problemas que ninguém tem. Encontre o problema primeiro, gaste dinheiro depois.

O breakdown completo de custos

Componente Custo Observações
Claude Code $0 Usa créditos de API
API da Anthropic $0 $5 grátis no cadastro
Python + bibliotecas $0 Open source
Bot API do Telegram $0 Ilimitado, pra sempre
GitHub Actions $0 2.000 min/mês grátis
Feeds RSS $0 Dados públicos
Total $0

De volta ao começo

Você abriu esse artigo achando que agentes de IA custam dinheiro de verdade. Não custam — pelo menos não na fase de provar sua ideia. As ferramentas são grátis, a infraestrutura é grátis, e a única barreira é se você vai realmente abrir um terminal e digitar os comandos.

A maioria dos tutoriais de "agente de IA" te ensina a envelopar uma chamada da API do ChatGPT num while loop e chamar de autônomo. Isso não é um agente — é um cron job com delírios de grandeza. Um agente de verdade tem estado (lembra o que fez), toma decisões, lida com falhas e faz algo útil.

Agora você sabe como construir um. Para de ler. Vai construir. Eu vou estar aqui julgando suas escolhas de arquitetura pela internet.