Agno es un framework de Python para construir agentes de IA cuyo mayor argumento de venta es el rendimiento: crea cada agente en unos dos microsegundos y apenas ocupa memoria. Antes se llamaba Phidata y en enero de 2025 pasó a llamarse Agno. En esta guía verás qué es Agno, cómo organiza el trabajo en agentes, equipos y flujos de trabajo, por qué presume de un consumo de memoria tan bajo, un ejemplo con herramientas y en qué se diferencia de CrewAI. La misma explicación está disponible en inglés.

Puntos clave

  • Agno es un framework de agentes de código abierto (licencia Apache-2.0) escrito en Python; supera las 41 200 estrellas en GitHub y va por la versión v2.7.3, publicada el 14 de julio de 2026.
  • Antes se llamaba Phidata: el proyecto se renombró a Agno en enero de 2025 y la organización de GitHub se movió a agno-agi, así que muchos tutoriales antiguos siguen citando el nombre viejo.
  • Su bandera es el rendimiento: instancia un agente en unos 2 microsegundos y consume alrededor de 3,75 KiB de memoria, cifras que el equipo mide con tracemalloc sobre mil ejecuciones.
  • Organiza el trabajo en tres piezas: agentes individuales, equipos de varios agentes que colaboran y flujos de trabajo deterministas por pasos, todo servido por su tiempo de ejecución AgentOS.
  • Es agnóstico del modelo: funciona con más de veinte proveedores (OpenAI, Anthropic, Gemini, DeepSeek, Mistral, Groq, Bedrock y modelos que ejecutes en tu propia máquina con Ollama) y requiere Python 3.9 o superior.

¿Qué es Agno (antes Phidata)?

Agno es un framework y un tiempo de ejecución para plataformas de agentes de IA. Nació como Phidata, una herramienta más orientada a datos, y en enero de 2025 se renombró a Agno; la organización de GitHub se movió a agno-agi y el paquete de PyPI pasó a llamarse agno. El cambio no es solo cosmético: la versión 2 reescribió el núcleo con la obsesión de reducir la sobrecarga del framework al mínimo.

El proyecto es software libre bajo licencia Apache-2.0 y ha tenido una acogida enorme: reúne más de 41 200 estrellas en GitHub y va por la versión v2.7.3, publicada el 14 de julio de 2026. Necesita Python 3.9 o superior y se instala con una sola orden:

pip install agno

# Junto con el cliente del proveedor que uses, p. ej. OpenAI
pip install openai

La documentación oficial lo describe como «un framework y un tiempo de ejecución para plataformas de agentes»: no solo escribes agentes, también los despliegas como servicio y los gestionas desde una interfaz web. Esa vocación de producto lo distingue de otras bibliotecas que se quedan en la capa de código.

Agentes, equipos y flujos de trabajo

Agno organiza el trabajo en tres abstracciones que conviene tener claras desde el principio. Un agente es la unidad básica: un modelo con instrucciones, herramientas y, opcionalmente, memoria y conocimiento. Es lo que usarás para tareas sueltas.

Cuando un problema pide varias especialidades, montas un equipo (Team): varios agentes que colaboran y se reparten el trabajo, un enfoque parecido al que popularizó CrewAI con sus tripulaciones de agentes. Y cuando necesitas un proceso repetible y predecible, defines un flujo de trabajo (Workflow): una secuencia de pasos donde la salida de cada paso alimenta al siguiente, con estado persistente entre ejecuciones. A diferencia de un agente, que decide sobre la marcha, el flujo de trabajo es determinista y fácil de auditar.

Por encima de las tres vive AgentOS, el tiempo de ejecución que sirve agentes, equipos y flujos como API de producción. Es de ejecución sin estado y escalable en horizontal: el estado (las sesiones) se guarda en una base de datos que tú controlas, no en el proceso. Trae además una interfaz web para observar y gestionar la plataforma. Si vienes de los grafos de estado de LangGraph, reconocerás la idea de separar la lógica del agente de su despliegue.

Rendimiento y bajo consumo de memoria

Aquí está el motivo por el que Agno se hace notar. Sus cifras de referencia son llamativas: instancia un agente en unos 2 microsegundos y ese agente ocupa alrededor de 3,75 KiB de memoria. El equipo lo mide con la biblioteca tracemalloc de Python: calcula la memoria base con una función vacía, crea el agente mil veces y mide la diferencia para aislar el coste real del framework.

Comparado con LangGraph, Agno declara ser unas 10 000 veces más rápido al crear el agente y usar unas 50 veces menos memoria. Conviene entender bien qué miden esas cifras: la sobrecarga del framework, es decir, el tiempo y la memoria que cuesta montar el agente antes de llamar al modelo. En una petición real, la latencia la domina la llamada al modelo de lenguaje, que tarda cientos de milisegundos o más. Entonces, ¿para qué sirve tanto ahorro?

La respuesta es la concurrencia. Si tu servicio arranca miles de agentes por segundo (uno por petición de usuario, por ejemplo), un coste de arranque de microsegundos y unos pocos KiB por agente marcan la diferencia entre un servidor holgado y uno que se ahoga. Para un agente que ejecutas de vez en cuando, la diferencia es imperceptible; para una plataforma multiinquilino a gran escala, es justo lo que necesitas.

Un ejemplo con herramientas

Un agente útil necesita actuar sobre el mundo, y en Agno eso se hace pasándole herramientas: funciones de Python, o kits ya hechos de su catálogo de más de cien integraciones. El siguiente ejemplo crea un agente con un modelo de OpenAI y una herramienta de búsqueda web, y le pide un resumen con fuentes:

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools

agente = Agent(
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    instructions="Responde en espanol y cita siempre tus fuentes.",
    markdown=True,
)

agente.print_response(
    "Resume las novedades del framework Agno en 2026",
    stream=True,
)

El modelo decide por sí mismo cuándo invocar la herramienta de búsqueda; tú solo se la ofreces. Cambiar de proveedor es igual de directo: sustituyes OpenAIChat por Claude, Gemini u Ollama sin tocar el resto del código, porque Agno abstrae la diferencia entre los más de veinte proveedores que soporta. Para dar a un agente varias capacidades, basta con añadir más entradas a la lista tools.

Agno frente a CrewAI

La comparación natural es con CrewAI, otro framework de Python centrado en equipos de agentes. La diferencia de enfoque es clara. CrewAI se articula alrededor de la metáfora del «equipo»: defines roles, tareas y una tripulación que colabora, con una experiencia muy guiada. Agno es más generalista y pone el rendimiento y la puesta en producción en el centro: cubre desde el agente suelto hasta el flujo de trabajo determinista, y lo remata con AgentOS para desplegarlo como servicio.

Si tu caso es un sistema multiagente con roles bien definidos y quieres una curva de aprendizaje suave, CrewAI encaja muy bien. Si te preocupan la concurrencia masiva, el bajo consumo de memoria y tener un tiempo de ejecución de producción desde el primer día, Agno lleva ventaja. No son excluyentes: ambos son agnósticos del modelo y puedes prototipar en uno y migrar si tus necesidades cambian. Para tareas más ligeras y centradas en código, también merece la pena mirar smolagents de Hugging Face, que apuesta por una superficie mínima.

Preguntas frecuentes

¿Es Agno lo mismo que Phidata?

Sí, es el mismo proyecto con otro nombre. Phidata se renombró a Agno en enero de 2025 y su organización de GitHub se movió a agno-agi. Si encuentras tutoriales o dependencias que mencionan phidata, se refieren a la versión antigua; el desarrollo activo está en el paquete agno, que va por la versión v2.7.3. Conviene migrar, porque la versión 2 reescribió el núcleo para reducir la sobrecarga.

¿De verdad es 10 000 veces más rápido que LangGraph?

Esa cifra mide solo la sobrecarga del framework al crear el agente, no la velocidad de las respuestas. En una petición real, la latencia la domina la llamada al modelo de lenguaje, que tarda cientos de milisegundos, así que no notarás respuestas 10 000 veces más rápidas. Donde sí importa es en la concurrencia: si arrancas miles de agentes a la vez, ese arranque de microsegundos y esos 3,75 KiB por agente te ahorran mucha memoria y CPU.

¿Con qué modelos funciona Agno?

Con más de veinte proveedores mediante la misma API: OpenAI, Anthropic, Google Gemini, DeepSeek, Mistral, Groq, Amazon Bedrock, Azure OpenAI y la pasarela LiteLLM, entre otros, además de modelos que ejecutes en tu propia máquina con Ollama. Cambiar de uno a otro es cuestión de sustituir la clase del modelo, sin reescribir la lógica del agente.

Conclusión

Agno lleva al mundo de los agentes de IA una obsesión poco habitual: la eficiencia. Con un arranque de microsegundos, unos pocos KiB por agente y tres abstracciones claras (agentes, equipos y flujos de trabajo) servidas por AgentOS, encaja de maravilla cuando necesitas escalar a mucha concurrencia sin renunciar a poner en producción. Recuerda que su famoso «10 000 veces más rápido» mide la sobrecarga del framework, no la latencia real. El siguiente paso es instalarlo con pip install agno, escribir tu primer agente con una herramienta y compararlo con CrewAI para decidir cuál encaja mejor en tu proyecto.

Fuentes: [1] Documentación oficial de Agno[1], [2] Agno en GitHub[2], [3] Paquete agno en PyPI[3], [4] Análisis independiente de Agno en ChatForest[4].

Visitas: 0

Fuentes

  1. Documentación oficial de Agno
  2. Agno en GitHub
  3. Paquete agno en PyPI
  4. Análisis independiente de Agno en ChatForest

Ruta: Frameworks para construir agentes de IA