Un agente de Inteligencia Artificial (IA) es un programa capaz de percibir su entorno y tomar decisiones autónomas para realizar tareas con el fin de lograr ciertos objetivos predeterminados
A diferencia de un software tradicional con un flujo fijo, un agente de IA elige sus acciones en función de la información que obtiene de su entorno, utilizando técnicas de inteligencia artificial (por ejemplo, algoritmos o modelos entrenados) para determinar la mejor respuesta en cada situación. – aws.amazon.com
Estos agentes encuentran aplicación en diversos campos. Por ejemplo, en robótica y transporte, un agente IA puede ser el encargado de conducir un coche autónomo: el vehículo recopila datos de sus sensores (cámaras, radares) y el agente decide en tiempo real cómo girar, frenar o acelerar para llegar a su destino de forma segura
En el ámbito del entretenimiento, los personajes controlados por IA en los videojuegos actúan como agentes que reaccionan a las acciones del jugador. También en aplicaciones cotidianas, como los asistentes virtuales (Siri, Alexa) o los chatbots de servicio al cliente, se emplean agentes de IA capaces de analizar las consultas de usuarios y generar respuestas útiles de manera automática. Incluso en finanzas o seguridad informática existen agentes que monitorean sistemas en busca de anomalías y toman medidas cuando detectan problemas. En resumen, un agente IA es cualquier entidad de software autónoma y racional que percibe, decide y actúa para cumplir una misión en un entorno dado.
Creación de un Agente IA desde Cero en Python
A continuación, te muestro cómo desarrollar un agente básico desde cero usando Python y sus bibliotecas estándar. Construiremos un ejemplo sencillo para ilustrar los pasos fundamentales: la percepción del entorno, la toma de decisiones y la interacción con el entorno. Para ello, imaginemos un entorno muy simple inspirado en el clásico “mundo de la aspiradora”: tenemos dos habitaciones (A y B) que pueden estar limpias o sucias, y un agente que es una aspiradora automática. El objetivo del agente es limpiar ambas habitaciones. El agente puede percibir si la habitación donde se encuentra está limpia o sucia, y puede ejecutar acciones simples: limpiar la habitación actual, o moverse a la otra habitación.
Ejemplo en código: Agente de limpieza simple
# Definimos el estado inicial del entorno
estado = {"pos": "A", "A": "sucio", "B": "sucio"} # Agente en A, ambas habitaciones sucias.
# Función de percepción: obtiene la posición y la situación (limpio/sucio) de esa habitación
def percibir(entorno):
pos_actual = entorno["pos"]
situacion = entorno[pos_actual]
return pos_actual, situacion
# Función de decisión del agente (agente reactivo simple)
def decidir_accion(percepcion):
pos, situacion = percepcion
if situacion == "sucio":
return "limpiar" # Si la habitación actual está sucia, limpiar
elif pos == "A":
return "ir_B" # Si está en A (y está limpia), ir a B
else:
return "ir_A" # Si está en B (y está limpia), ir a A
# Bucle de simulación del agente en el entorno
pasos = 0
while True:
pasos += 1
# 1. Percepción del entorno
percepcion = percibir(estado)
# 2. Decisión del agente según la percepción
accion = decidir_accion(percepcion)
# 3. Ejecución de la acción y actualización del entorno
if accion == "limpiar":
estado[estado["pos"]] = "limpio"
elif accion == "ir_A":
estado["pos"] = "A"
elif accion == "ir_B":
estado["pos"] = "B"
# 4. Verificar si el objetivo está cumplido (ambas limpias) para detenerse
if estado["A"] == "limpio" and estado["B"] == "limpio":
break
print(f"Agente terminado en {pasos} pasos. Estado final: {estado}")
En este código definimos un entorno muy sencillo con un diccionario estado que contiene la posición actual del agente ("pos") y la limpieza de cada habitación ("A" y "B" pueden valer "sucio" o "limpio"). La función percibir(entorno) simula la percepción del agente devolviendo la información relevante: su posición actual y el estado de limpieza de esa posición. La función decidir_accion(percepcion) implementa la toma de decisiones del agente de forma determinista (es un agente reactivo simple): si la habitación donde está está sucia, la acción elegida es "limpiar"; si está limpia, el agente decide moverse a la otra habitación (acciones "ir_B" o "ir_A" según corresponda). Luego, en el bucle principal de simulación, el agente percibe el entorno, decide una acción y actúa actualizando el estado del entorno. Este ciclo se repite hasta que ambas habitaciones están limpias, momento en el cual el bucle se rompe y la simulación termina.
Pasos clave del agente: En cada iteración, el agente sigue el ciclo de percepción-decisión-acción:
- Percepción: obtención de datos del entorno. En el ejemplo, el agente “ve” en qué habitación está y si está limpia o sucia (
percibir(estado)). - Toma de decisiones (razonamiento): el agente evalúa la percepción y elige una acción acorde a su objetivo. En nuestro código, esto se realiza con reglas if/else en
decidir_accion(percepcion). Este podría considerarse el “cerebro” del agente: aquí aplicamos la inteligencia (aunque en este caso sea una estrategia fija) para seleccionar la acción más apropiada. - Acción (interacción con el entorno): ejecutar la acción elegida y modificar el estado del entorno. Por ejemplo, si la acción es
"limpiar", el código marca la habitación actual como limpia; si es"ir_B"o"ir_A", se cambia la posición del agente. Esta es la forma en que el agente afecta su entorno mediante actuadores (en la vida real podría ser mover un motor, aquí es simplemente cambiar una variable). - Bucle y objetivo: el proceso se repite continuamente, lo que hace que el agente actúe autónomamente paso a paso. Hemos incluido una condición de parada cuando logra su objetivo (ambas habitaciones limpias). En un agente más complejo, podría existir una acción explícita de “no hacer nada” cuando no hay más tareas, pero aquí simplemente terminamos la simulación.
Veamos cómo se desarrolla la ejecución con el código anterior, paso a paso:
- Paso 1: El agente está en la habitación A, que está “sucia”. Percepción = (
"A","sucio"). Decide limpiar. Tras la acción, el estado pasa a: A limpia, B sucia, agente sigue en A. - Paso 2: El agente está en A, que ahora está “limpia”. Percepción = (
"A","limpio"). Como la habitación actual está limpia, decide ir_B (moverse a B). Ahora el agente se encuentra en B; el estado: A limpia, B sucia. - Paso 3: El agente está en B, que está “sucia”. Percepción = (
"B","sucio"). Decide limpiar B. Tras limpiar, estado: A limpia, B limpia, agente en B. Objetivo logrado.
El agente termina en 3 pasos con ambas habitaciones limpias. Aunque este es un ejemplo muy básico (sin aprendizaje ni planificación compleja), ilustra la estructura fundamental de un agente IA sencillo. A partir de aquí, podríamos extender la complejidad: por ejemplo, agregando más habitaciones, haciendo que el agente lleve un modelo interno del entorno (memoria de qué habitaciones ya limpió), o incorporando cierta aleatoriedad o aprendizaje en la toma de decisiones. No obstante, incluso para agentes más avanzados, la idea central de percibir -> decidir -> actuar permanece vigente.
Creación de un Agente IA Usando Herramientas Auxiliares
Desarrollar un agente desde cero brinda un entendimiento profundo y control total sobre su funcionamiento, pero a medida que los requisitos crecen, también aumenta la complejidad de implementarlo todo manualmente. Por suerte, existen herramientas y frameworks auxiliares que simplifican la creación de agentes de IA al proporcionar componentes ya construidos para percepción, decisión y acciones. Estas herramientas pueden ahorrarnos tiempo al encargarse de muchos detalles bajo el capó, permitiendo que nos enfoquemos más en la lógica de alto nivel o en configurar comportamientos, en lugar de programarlos completamente desde cero.
Una de estas herramientas es n8n, una plataforma de automatización de flujos de trabajo (workflow) de bajo código (low-code) que se ha extendido para soportar casos de uso con IA.
Por aquí escribí un artículo sobre cómo instalar n8n en un Synology NAS y disfrutar de esta herramienta sin restricciones ni pagos.
Con n8n es posible diseñar un agente IA mediante una interfaz visual: en lugar de escribir todo el bucle de percepción y acción en código, uno puede arrastrar y conectar nodos que representan pasos del agente. Por ejemplo, podríamos tener un nodo desencadenador (trigger) que actúa como sensor o evento inicial (una nueva consulta de usuario, o la llegada de ciertos datos), luego un nodo de procesamiento con un modelo de lenguaje o lógica de decisión, y finalmente nodos de acción que interactúan con servicios externos (enviar una respuesta, ejecutar una tarea, etc.). De hecho, n8n integra internamente muchos componentes de la librería LangChain como nodos listos para usar, lo que permite crear agentes basados en modelos de lenguaje con muy poco esfuerzo de codificación
Esta aproximación visual facilita la creación de agentes complejos orquestando varias tareas: por ejemplo, un agente de atención al cliente podría construirse en n8n combinando nodos que analizan el mensaje del usuario, consultan una base de conocimientos y retornan una respuesta, todo sin programar explícitamente cómo pasar de un paso a otro, ya que la herramienta gestiona el flujo de datos entre nodos. – blog.n8n.io
¿Desde cero o con herramientas?
Usar herramientas auxiliares cambia la forma de desarrollo. A modo de comparación general:
- Desarrollo desde cero: ofrece máxima flexibilidad y control. El desarrollador define cada detalle (formatos de percepción, estrategias de decisión, cómo se realizan las acciones). Esto permite adaptar el agente a cualquier situación o optimizar su rendimiento, pero implica más esfuerzo y conocimiento técnico. Hay que programar y mantener gran parte de la lógica, lo cual puede ser propenso a errores si el sistema es complejo. Es la mejor opción cuando se requiere un comportamiento muy específico o no hay herramientas que cubran esa necesidad.
- Desarrollo con herramientas/frameworks: ofrece rapidez y facilidad. Muchas decisiones de diseño ya están resueltas por la herramienta, que proporciona componentes predefinidos (por ejemplo, interpretadores de lenguaje, planificadores, conectores a sensores/actuadores, etc.). Esto acelera el prototipado y facilita la integración con otros sistemas. Por otro lado, puede tener limitaciones: estamos restringidos a lo que la herramienta permite hacer o a sus componentes disponibles (aunque las herramientas más avanzadas suelen ser extensibles). Además, es necesario invertir tiempo en aprender la herramienta en sí misma (su configuración, su modo de trabajo) en lugar de trabajar a bajo nivel en código. En resumen, las herramientas auxiliares sacrifican algo de flexibilidad a cambio de conveniencia y velocidad de desarrollo.
La elección entre construir un agente desde cero o usar un framework dependerá del caso de uso, los recursos y conocimientos disponibles, y la necesidad de personalización. En muchos escenarios prácticos, se adopta un enfoque híbrido: por ejemplo, usar una librería de IA para la toma de decisiones (como un modelo de machine learning preentrenado) pero integrar eso en un agente escrito a medida; o usar una plataforma visual como n8n para orquestar varios agentes especializados que se comunican entre sí. Lo importante es entender que las herramientas son exactamente eso: ayudas que nos permiten crear agentes IA de forma más sencilla, aprovechando soluciones ya existentes, sin perder de vista los fundamentos de cómo funciona un agente bajo la superficie.
Tabla Comparativa de Herramientas para Crear Agentes IA
Existen diversas plataformas y frameworks para desarrollar agentes de IA, cada una con enfoques y propósitos distintos. A continuación, comparamos cuatro opciones populares – n8n, LangChain, Rasa y Auto-GPT – evaluando su facilidad de uso, flexibilidad, capacidad de integración y principales casos de uso. (Cada herramienta está pensada para ciertos contextos: por ejemplo, Rasa se enfoca en asistentes conversacionales, mientras Auto-GPT representa agentes autónomos impulsados por modelos de lenguaje de última generación).
- n8n: Es una plataforma de automatización visual de flujo de trabajo, orientada a low-code, que ahora incluye nodos de IA para construir agentes.
- LangChain: Es un marco de trabajo de código abierto para desarrollar aplicaciones basadas en modelos de lenguaje de gran tamaño (LLM), facilitando la creación de agentes conversacionales y con razonamiento mediante lenguaje natural.
- Rasa: Es un framework open source escrito en Python para crear chatbots y asistentes virtuales altamente personalizables. Proporciona componentes de NLU (comprensión del lenguaje natural) y Core (gestión del diálogo) para estructurar conversaciones inteligentes.
Ahora, veamos comparativamente estas herramientas:
| Herramienta | Facilidad de uso | Flexibilidad | Integraciones | Casos de uso típicos |
|---|---|---|---|---|
| n8n | Muy alta – Interfaz visual, no requiere casi programación. | Moderada – Limitada a los nodos y lógica que ofrece (extensible con código JavaScript si es necesario). | Muy alta – Cuenta con cientos de integraciones predefinidas (APIs, servicios web, bases de datos, etc.), ideal para conectar el agente con múltiples sistemas externos. | Automatización de flujos con IA, prototipado rápido de agentes que interactúan con servicios (ej. agente que procesa emails y responde, asistentes simples conectados a Slack, etc.). |
| LangChain | Media – Requiere conocimientos de programación (Python o JavaScript), pero simplifica mucho el uso de modelos de lenguaje y herramientas en la aplicación. | Alta – Es un framework altamente personalizable; permite configurar distintos modelos de lenguaje, memorias conversacionales, herramientas externas, etc., adaptándose a necesidades complejas. | Alta – Integración nativa con múltiples proveedores de LLM, APIs (búsqueda web, calculadoras), almacenes de vectores para conocimiento, y otros componentes modulares. | Aplicaciones con LLM sofisticadas: chatbots conversacionales contextuales, agentes que pueden hacer tool use (por ejemplo, responder preguntas buscando información externa), asistentes con conocimiento específico (mediante recuperación de información), prototipos tipo Auto-GPT personalizados. |
| Rasa | Media – Tiene una curva de aprendizaje (requiere definir intents, entidades, historias de diálogo), pero no exige programar algoritmos ML desde cero; ofrece interfaz de línea de comandos y algunas herramientas visuales de depuración. | Alta (en su dominio) – Muy flexible para diálogos: se pueden personalizar los modelos de NLU, reglas de conversación, y acciones personalizadas en Python para comportamientos específicos. Menos adecuada fuera del contexto de bots de conversación. | Alta – Soporta integración con numerosos canales de mensajería (Web, Telegram, WhatsApp, Slack, etc.). Permite llamar APIs externas o bases de datos mediante actions personalizadas, integrando fácilmente lógica de negocio. | Chatbots y asistentes virtuales orientados a conversaciones estructuradas: asistentes de soporte al cliente, bots de reservas, FAQ automatizados, asistentes de voz. Casos donde se necesite control detallado del diálogo y mantenimiento del contexto conversacional. |
No existe un única manera de crear agentes IA
No existe una única manera “correcta” de crear un agente de IA: la elección dependerá de las necesidades del proyecto. Si se requiere un alto grado de control o se está aprendiendo sobre los fundamentos de la IA, construir un agente paso a paso en Python puede ser muy educativo. En cambio, si el objetivo es desarrollar rápidamente un asistente inteligente o incorporar IA en un proceso existente, aprovechar herramientas como las comparadas puede ahorrarnos mucho tiempo. En última instancia, entender los principios clave de los agentes (cómo perciben, razonan y actúan) nos permitirá utilizar cualquier enfoque de manera efectiva para crear sistemas inteligentes que operen de forma autónoma y cumplan con éxito sus objetivos.
