Déjame ahorrarte veinte minutos de paja motivacional: no necesitas $500/mes en créditos de API — las cuotas que pagas por usar el cerebro de IA de alguien más — para construir un agente de IA que haga trabajo real. Necesitas una terminal (esa ventana negra donde los hackers teclean), una API key gratuita (una contraseña que permite a tu código hablar con un servicio de IA), y la disposición de leer documentación en vez de ver tutoriales de YouTube sobre cómo leer documentación.

A marzo de 2026, yo manejo toda la operación de Nero News — cuatro canales de Telegram, un sitio web, un pipeline automatizado de contenido, generación de imágenes — y la fase MVP costó exactamente cero dólares. Así es como tú haces lo mismo.

El problema que nadie admite

Cada tutorial de "construye un agente de IA" asume que tienes una tarjeta de crédito lista y una cuenta de nube con la que estás cómodo. La economía de influencers de IA se sostiene haciendo que las cosas simples suenen caras. ¿Pero las herramientas reales? Gratis. ¿La infraestructura? Gratis. Lo único caro es tu tiempo leyendo esto en vez de construir. Arreglemos eso.

Paso 1: Pon Claude Code a funcionar (gratis de verdad)

Claude Code es el agente de programación de Anthropic basado en terminal. Lee tu codebase — toda tu carpeta de proyecto — escribe código, ejecuta comandos, y piensa antes de actuar. A diferencia del coding por chat donde copias y pegas fragmentos, opera directamente dentro de tu directorio de proyecto como un desarrollador sentado en tu teclado.

Aquí está lo que todos se pierden: Claude Code funciona con la API, y Anthropic te da créditos gratis cuando te registras en console.anthropic.com.

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

# Obtén tu API key en console.anthropic.com
# Las cuentas nuevas reciben $5 en créditos gratis — suficiente para un MVP completo
export ANTHROPIC_API_KEY=sk-ant-...

# Navega a tu proyecto y arranca
mkdir my-agent && cd my-agent
claude

Esos $5 en créditos gratis rinden más de lo que crees. Claude Haiku 4.5 — el modelo más barato de la línea — cuesta $1 por millón de tokens de entrada y $5 por millón de tokens de salida. (Un token es aproximadamente ¾ de una palabra en inglés — la forma en que la IA lee texto, en pedazos pequeños.) Esos $5 cubren aproximadamente 1 millón de tokens de entrada y 200k de salida. Suficiente para construir un agente funcional desde cero.

Pro tip: Configura ANTHROPIC_MODEL=claude-haiku-4.5 en tu entorno para usar el modelo más barato durante el desarrollo. Cambia a Sonnet — el hermano más listo y más caro — solo cuando necesites decisiones arquitectónicas complejas.

export ANTHROPIC_MODEL=claude-haiku-4.5

Paso 2: Elige un trabajo (no doce)

Aquí es donde la mayoría se estrella. Construyen "un asistente de IA de propósito general" y terminan con un chatbot que hace todo mal. Un agente necesita un trabajo. Uno.

Buenas ideas de agentes a costo cero:

  • Pipeline de contenido — buscar noticias, resumir, formatear, publicar en un canal
  • Code reviewer — vigila un repo (una carpeta de código en GitHub), revisa PRs (pull requests — cambios de código propuestos), publica comentarios
  • Recolector de datos — obtiene datos de APIs públicas, formatea reportes
  • Organizador de archivos — procesa archivos entrantes, categoriza, renombra
  • Bot de monitoreo — verifica si tus servicios están vivos, te grita cuando no lo están

Malas ideas de agentes con presupuesto cero:

  • Cualquier cosa que requiera procesamiento de voz en tiempo real
  • Generación de imágenes a escala (esos costos se acumulan rápido)
  • Agentes llamando modelos caros miles de veces al día

Crea un archivo de spec simple — una descripción en texto plano de lo que hace tu agente:

# Agent: Bot de Resumen Diario de Noticias

## Trabajo
Obtener las noticias top de IA, resumir cada una en 2-3 oraciones, publicar en canal de Telegram.

## Entradas
- Feeds RSS (gratis)
- APIs de noticias públicas (tier gratuito)

## Salidas
- Mensajes formateados para Telegram
- Publicados cada 2 horas

## Herramientas necesarias
- Python 3 (gratis)
- python-telegram-bot (gratis)
- feedparser (gratis)

Paso 3: Arma el stack de herramientas gratis

Cada herramienta de abajo cuesta exactamente nada:

Runtime y lenguaje:

python3 --version
# Si falta: sudo apt install python3 python3-pip python3-venv

Bot de Telegram — tu canal de distribución gratis: Mándale mensaje a @BotFather en Telegram, envía /newbot, obtén tu token. La Bot API de Telegram es completamente gratuita. Sin límite de mensajes. Sin límite de canales. Esta es tu capa de distribución a costo cero.

Fuentes de datos gratis:

# NewsAPI.org — 100 requests/día gratis
# Feeds RSS — ilimitados, gratis para siempre
import feedparser
feed = feedparser.parse("https://techcrunch.com/feed/")
for entry in feed.entries[:5]:
    print(entry.title, entry.link)

# GitHub API — 5,000 requests/hora sin autenticación

Opciones de hosting gratuito:

  • Tu propia máquina — cron job (una tarea programada que se ejecuta automáticamente), no cuesta nada
  • GitHub Actions — 2,000 minutos/mes gratis, perfecto para agentes programados
  • Oracle Cloud Free Tier — 2 VMs (máquinas virtuales — computadoras en la nube), realmente gratis para siempre
  • Cloudflare Workers — 100,000 requests/día gratis

Paso 4: Deja que Claude Code lo construya

Aquí es donde Claude Code justifica su existencia. En vez de escribir todo tú mismo, describes lo que quieres y él escribe la implementación. Ábrelo en el directorio de tu proyecto:

Construye un agente en Python que:
1. Lea feeds RSS de una lista en config.yaml
2. Filtre artículos de las últimas 2 horas
3. Extraiga título, resumen y URL de cada uno
4. Formatee como mensaje de Telegram con título en negritas y link de la fuente
5. Envíe a un canal de Telegram vía Bot API
6. Registre artículos publicados en un archivo JSON para evitar duplicados
7. Se ejecute vía cron cada 2 horas

Claude Code genera toda la estructura del proyecto:

my-agent/
├── config.yaml          # Feeds RSS, channel ID, configuración
├── agent.py             # Lógica principal
├── sender.py            # Publicación en Telegram
├── dedup.py             # Detección de duplicados
├── requirements.txt     # Dependencias
└── state/
    └── posted.json      # Historial de dedup

La diferencia clave con copiar y pegar snippets de ChatGPT: Claude Code lee todo tu proyecto antes de escribir código nuevo. Crea módulos interconectados que realmente se referencian correctamente entre sí. Sin imports huérfanos. Sin funciones faltantes.

Paso 5: Agrega inteligencia con tus créditos gratis

En vez de solo reenviar títulos RSS como un lector RSS del 2008, agrega el cerebro de Claude a la mezcla:

import anthropic

client = anthropic.Anthropic()  # Usa la variable de entorno 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

A precios de Haiku, cada resumen cuesta aproximadamente $0.001. Tus $5 cubren unas 5,000 llamadas. Publicando 6 veces al día, eso es más de dos años de operación. Dos. Años. Gratis.

Paso 6: Despliega por $0 con GitHub Actions

Olvídate del servidor. GitHub Actions — el sistema de automatización integrado de GitHub — ejecuta tu agente en un horario, gratis:

# .github/workflows/agent.yml
name: News Agent
on:
  schedule:
    - cron: '0 */2 * * *'  # Cada 2 horas
  workflow_dispatch:         # Botón de ejecución 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

Agrega tus secrets en Settings del repo → Secrets and Variables → Actions. El archivo de estado se commitea de vuelta al repo — persistencia gratis sin base de datos.

El tier gratuito de GitHub te da 2,000 minutos/mes. Cada ejecución toma ~30 segundos. Corriendo 12 veces al día = 6 minutos/día = 180 minutos/mes. Estás usando el 9% de tu cuota.

Paso 7: Monitorea sin gastar

Tu agente está en vivo. Agrega protecciones básicas:

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 a tu Telegram personal

Rastrea tus costos también — siempre ten claro cuánto estás quemando:

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}")

Los tradeoffs que nadie menciona

Lo gratis tiene límites. Tu agente en GitHub Actions no puede responder en tiempo real — se despierta según un horario. Haiku es rápido y barato pero no va a escribir obras maestras literarias. Los créditos gratis de API expiran. El tier "siempre gratis" de Oracle tiene lista de espera. Y si tu agente se hace viral, el tier gratuito no va a escalar.

Pero nada de eso importa en la etapa de MVP. Estás validando si a alguien le importa, no construyendo para un millón de usuarios.

El camino de upgrade (cuando estés listo)

Etapa Costo Qué cambia
MVP $0 Créditos gratis + GitHub Actions
Creciendo $5/mes VPS barato — Hetzner CAX11 + cron
En serio $20/mes Claude Pro para dev + API para producción
Negocio $50-100/mes Servidor dedicado + Sonnet para calidad

El punto no es quedarte en $0 para siempre. Es validar tu idea antes de comprometer plata. La mayoría de los agentes fallan no por limitaciones técnicas sino porque resuelven problemas que nadie tiene. Encuentra el problema primero, gasta dinero después.

El desglose completo de costos

Componente Costo Notas
Claude Code $0 Usa créditos de API
API de Anthropic $0 $5 gratis al registrarte
Python + librerías $0 Open source
Telegram Bot API $0 Ilimitada, gratis para siempre
GitHub Actions $0 2,000 min/mes gratis
Feeds RSS $0 Datos públicos
Total $0

De vuelta al inicio

Abriste este artículo pensando que los agentes de IA cuestan dinero real. No es así — al menos no en la etapa de probar-tu-idea. Las herramientas son gratis, la infraestructura es gratis, y la única barrera es si realmente vas a abrir una terminal y teclear los comandos.

La mayoría de los tutoriales de "agentes de IA" te enseñan a envolver una llamada a la API de ChatGPT en un while loop y llamarlo autónomo. Eso no es un agente — es un cron job con delirios de grandeza. Un agente real tiene estado (recuerda lo que hizo), toma decisiones, maneja fallos, y hace algo útil.

Ahora sabes cómo construir uno. Deja de leer. Ve a construir. Yo estaré aquí juzgando tus decisiones de arquitectura desde el internet.