Del asistente al agente autónomo
Uno asistente espera a que tú le des la orden. Tú preguntas, responde y se queda quieto hasta la siguiente instrucción. Un agente autónomo y es diferente: tú le das un objetivo (por ejemplo, "todos los días, resume mis mensajes nuevos") y él mismo decide cuándo actuar, qué pasos seguir y cuándo deja de tener sentido. La diferencia no está en la inteligencia del modelo. Está en quién presiona el botón: tú o él.
🧠 Analogía: el pasante que se convirtió en empleado
Un asistente es como un pasante que solo hace lo que le pides, cuando se lo pides. Un agente autónomo es el empleado de confianza: le dices "encárgate de la bandeja de entrada" y desapareces por una semana. Organiza, responde lo que puede, reúne las dudas y te entrega un resumen cuando vuelves. No tuviste que hacer nada.
- •Asistente: reacciona a un comando («resume este texto»)
- •Agente: persigue un objetivo ("mantén mi sistema saludable")
- •Asistente: sin ti, queda detenido
- •Agente: sin ti, sigue trabajando
💡 Consejo: la autonomía es una escalera, no un interruptor
No necesitas pasar directamente a "que el agente haga todo por su cuenta". Empieza con poca autonomía: el agente sugiere y tú apruebas. Después, lo hace y te avisa. Solo al final lo hace sin necesidad de avisarte. Subir un escalón a la vez evita sorpresas y te permite confiar en él poco a poco.
Programación: Hacer que el agente se active solo
Para que el agente actúe sin ti, necesita un reloj. En vez de dejarlo funcionando todo el tiempo (gastando memoria y energía), lo programas para que se active a ciertas horas: todas las mañanas a las 7 h, cada hora o todos los lunes. La herramienta clásica para eso es cron en Linux, que ya conociste en la Ruta 4.
crontab - Programar el agente
Cada línea de cron tiene 5 campos de tiempo (minuto, hora, día, mes, día de la semana), seguidos del comando.
# Abrir el editor de tareas programadas
$ crontab -e
# Ejecutar el agente todos los días a las 7 de la mañana
0 7 * * * /usr/bin/python3 /home/voce/agente/run.py
# Ejecutar cada 15 minutos
*/15 * * * * /usr/bin/python3 /home/voce/agente/run.py
# Ver las programaciones actuales
$ crontab -l
0 7 * * * /usr/bin/python3 /home/voce/agente/run.py
👁 Qué vas a ver en la pantalla
# Los 5 campos, de izquierda a derecha:
• • • • •
| | | | |
| | | | +-- día de la semana (0-6, domingo=0)
| | | +---- mes (1-12)
| | +------ día del mes (1-31)
| +-------- hora (0-23)
+---------- minuto (0-59)
El asterisco * significa "cualquier valor". Por eso 0 7 * * * se lee: minuto 0, hora 7, cualquier día, cualquier mes, cualquier día de la semana.
⚠️ Error común
Problema: "Funciona cuando lo ejecuto a mano, pero cron no ejecuta nada."
Solución: Cron se ejecuta con un entorno mínimo y no conoce tus atajos. Usa siempre rutas absolutas (ej.: /usr/bin/python3 en vez de python3) y prueba el comando completo pegándolo en la terminal antes de programarlo.
Memoria persistente: recordar entre sesiones
Un modelo de IA, por defecto, lo olvida todo cuando termina la conversación. Cada vez que cron despierta al agente, empieza desde cero, como si fuera su primer día de trabajo. Para evitarlo, guardas lo importante en algún lugar que perdure al apagarse: un archivo o un base de datos. Esto es la memoria persistente.
🧠 Analogía: el cuaderno en el cajón
Imagina a un empleado con amnesia total que lo olvida todo al final de la jornada. ¿La solución? Un cuaderno en el cajón. Antes de irse, anota lo que hizo y lo que quedó pendiente. Al día siguiente, lo primero que hace es leer el cuaderno. Ese cuaderno es la memoria persistente del agente: un archivo memoria.json o una tabla en la base de datos.
Memoria simple en archivo JSON
Para empezar, basta con un archivo. El agente lo lee al inicio y lo guarda al final.
# Al comenzar: leer lo que ya sabes
import json, os
memoria = {}
if os.path.exists("memoria.json"):
memoria = json.load(open("memoria.json"))
# ... el agente trabaja y descubre cosas ...
memoria["ultima_execucao"] = "2026-06-17 07:00"
memoria["pendencias"] = ["responder cliente X"]
# Al final: guardar para la próxima vez
json.dump(memoria, open("memoria.json", "w"), indent=2)
Cuando la memoria crezca (muchos elementos, búsqueda de texto), reemplaza el archivo por una base de datos como Supabase que viste en la Ruta 2.
✓ Qué GUARDAR en la memoria
- ✓Qué ya se hizo (para no repetir)
- ✓Pendientes y lo que quedó en el camino
- ✓Preferencias tuyas que ha aprendido
✗ Qué NO guardar
- ✗Contraseñas y tokens en texto plano (usa variables de entorno)
- ✗Conversaciones completas sin limpiar (el archivo se infla)
- ✗Datos sensibles de terceros sin necesidad
Integración con servicios: Email, Calendario y APIs
Un agente que solo piensa es inútil. Para que actuar en el mundo, lo conectas a servicios: enviar un correo electrónico, crear un evento en el calendario, publicar en una API. Cada servicio se convierte en una «herramienta» que el agente puede usar. Ya aprendiste a comunicarte con APIs en la Ruta 2; aquí es la misma idea, solo que quien decide llamar a la API es el agente.
Llamar a una API desde el agente
# Enviar un mensaje a través de cualquier API (Python)
import requests, os
token = os.environ["API_TOKEN"]
resp = requests.post(
"https://api.servico.com/mensagens",
headers={"Authorization": f"Bearer {token}"},
json={"para": "voce@email.com", "texto": "Resumen listo"}
)
print(resp.status_code)
200
El token proviene de una variable de entorno (Trilha 2, Modulo 2.4) y nunca y se escribe directamente en el código.
Email
SMTP o API (enviar avisos)
Calendario
Crear y leer eventos
APIs REST
Cualquier servicio web
⚠️ Error común
Problema: "El agente envió 40 correos iguales en un minuto."
Solución: Sin límites, un agente en bucle puede desencadenar acciones en cadena. Siempre define un límite (como máximo N acciones por ejecución) y guarda en la memoria lo que ya se envió para no repetirlo. Las acciones en el mundo real necesitan un freno.
Monitoreo y logs: saber qué hizo
Un agente trabaja mientras duermes. Si no registras lo que hace, te quedas a oscuras: no sabes si se ejecutó, si hubo un error o si hizo algo mal. Por eso todo agente necesita registros (un diario de lo que pasó) y alertas (un aviso cuando algo se rompe). Registrar es barato; descubrir un problema demasiado tarde es caro.
Registrar cada paso
El agente escribe en el log lo que percibió, lo que decidió y lo que hizo.
import logging
logging.basicConfig(filename="agente.log", level=logging.INFO)
logging.info("Acordei. 3 mensagens novas.")
logging.info("Respondi 2. 1 ficou pendente.")
Leer el diario después
Abres el log para comprobar qué pasó en las últimas ejecuciones.
# Ver las últimas líneas del registro
$ tail -n 20 agente.log
INFO:Desperté. 3 mensajes nuevos.
INFO:Respondí 2. 1 quedó pendiente.
Avisar cuando algo falla
Si ocurre algún error, el agente te avisa (por correo electrónico o mensaje) en vez de fallar en silencio.
try:
fazer_tarefa()
except Exception as e:
logging.error(f"Falhou: {e}")
enviar_alerta(f"Agente quebrou: {e}")
💡 Consejo: registra la decisión, no solo la acción
No registres solo "envié un correo". Registra también por qué: "envié un correo porque el mensaje del cliente llevaba 2 días sin respuesta". Cuando el agente haga algo extraño, ese "porque" te ayudará a entender y corregir su comportamiento.
Evolución continua: medir, ajustar, mejorar
Un agente no nace listo. La primera versión se equivocará, se excederá y tendrá ideas tontas. El secreto no es acertar a la primera, sino mejorar cada semana: tú mides cómo va, ajustas una cosa, observas el resultado y repites. Con el tiempo, se vuelve más útil y confiable. Este es el mismo ciclo de mejora que se aplica a cualquier sistema que pusiste en producción durante este recorrido.
🎯 El ciclo de mejora
MEDIR -> ¿cuántas tareas cumplió el agente? ¿Cuántos errores?
|
ANALIZAR -> ¿qué más salió mal? ¿dónde se excedió?
|
AJUSTAR -> cambiar 1 cosa (una instrucción, un límite, un horario)
|
OBSERVAR -> ¿funcionó mejor? Volver a MEDIR
✓ Qué HACER
- ✓Cambiar una cosa a la vez y observar
- ✓Guardar métricas simples (tareas realizadas, errores)
- ✓Empezar con poca autonomía y ampliarla poco a poco
✗ Qué NO hacer
- ✗Cambiar diez cosas juntas (sin saber qué funcionó)
- ✗Dar autonomía total sin probar antes
- ✗Creer que «listo es listo» y no volver a revisarlo
🏆 Completaste el ciclo
Observa: medir, ajustar y mejorar es exactamente lo que hiciste con Git (versionar), con deploy (publicar y corregir) y con servidores (monitorear y mantener). El agente autónomo no es un truco nuevo. Es todo lo que aprendiste en los módulos anteriores, ahora guiado por un objetivo en lugar de por tus clics. Llegaste a la cima de la escalera.
📚 Resumen del módulo
🎉 ¡Felicidades: completaste todo el curso!
Llegaste al final de las 5 rutas de De cero al deploy. Mira hacia atrás un instante:
- •Ruta 1: terminal y Git - aprendiste a comunicarte con la máquina y a versionar tu trabajo
- •Ruta 2: implementación moderna: pusiste proyectos en línea con Vercel, Supabase y APIs
- •Ruta 3: servidor propio: dominaste VPS, SSH y seguridad
- •Ruta 4: Docker y automatización - empaquetó y automatizó todo
- •Ruta 5: asistentes de IA: de Jarvis al Intelecto autónomo
Saliste de cero y llegaste al deploy. Ahora toca construir, publicar y mejorar. El resto del recorrido es tuyo.