Agno se distingue parmi les bibliothèques d'agents par deux choses. La première est l'accent mis sur la performance, qu'il met fortement en avant et qui mérite une lecture honnête. La seconde est plus intéressante : au-delà de la bibliothèque elle-même, tu obtiens une couche runtime qui expose les agents comme un service réseau, avec stockage des sessions, historique et inspection des exécutions.
Le projet a démarré sous un autre nom, comme un outil plus proche du travail sur les données, et a changé de direction début 2025. Cet historique crée de la confusion quand on cherche des ressources, car les anciens tutoriels décrivent autre chose que ce qu'est le projet aujourd'hui.
La construction repose sur quatre concepts : agent, équipe (team), workflow et runtime. Les trois premiers te sont connus d'autres bibliothèques, le quatrième est ce qui fait la différence ici.
Ton premier agent
pip install agnofrom agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool
@tool
def check_stock(sku: str) -> int:
"""Returns the number of units available in the warehouse."""
return warehouse.count(sku)
agent = Agent(
model=OpenAIChat(id="gpt-4o"),
tools=[check_stock],
instructions="You answer availability questions. Always check stock.",
markdown=True,
)
agent.print_response("Are there still shoes in size 42?")L'interface est concise et ressemble à celle des autres bibliothèques de cette catégorie. Des dizaines de familles de modèles sont prises en charge, y compris celles exécutées en local via Ollama, et changer de fournisseur revient à remplacer un seul objet.
Trois choses que d'autres bibliothèques ajoutent séparément sont intégrées : la mémoire des conversations, une couche de connaissances basée sur la recherche de documents, et la gestion de données au-delà du texte. Cela raccourcit le chemin entre une idée et un prototype fonctionnel.
Les chiffres tapageurs et ce qu'ils signifient
Le projet met en avant des résultats de l'ordre de milliers de fois plus rapides pour la création d'un agent et d'une consommation de mémoire plusieurs fois inférieure à celle de la concurrence. Ces chiffres sont vrais, et tout aussi trompeurs si tu ne sais pas ce qu'ils mesurent exactement.
Ils mesurent le coût de création d'un objet agent en mémoire, c'est-à-dire le temps entre l'appel du constructeur et l'état prêt. Ils ne mesurent pas le temps de réponse à la question d'un utilisateur, puisque celui-ci est dominé par l'appel au modèle, qui prend des centaines de millisecondes ou des secondes.
La proportion tranche. Si créer un agent prend des microsecondes et que l'appel au modèle prend deux secondes, accélérer le premier mille fois change le total d'une quantité non mesurable. Choisir une bibliothèque sur ce chiffre revient à choisir une voiture selon la vitesse d'ouverture de ses portières.
Il existe toutefois des cas où cela compte vraiment, et ils méritent d'être nommés. Le premier : les systèmes qui créent des agents dynamiquement, un par requête, sous un fort trafic. Le deuxième : les simulations avec des milliers d'agents simultanés, où la consommation de mémoire décide du nombre qui tient sur une machine. Le troisième : les environnements où le processus démarre à chaque requête, de sorte que tu paies le coût d'initialisation à chaque fois.
En dehors de ces trois cas, choisis sur autre chose : l'observabilité, la maturité de l'outillage, et la rapidité avec laquelle tu établis la cause après une exécution ratée. La facture du modèle sera de plusieurs ordres de grandeur supérieure au coût de la bibliothèque elle-même.
Ce n'est pas une critique du projet : les chiffres sont honnêtes, et une faible consommation de mémoire a une vraie valeur sur de nombreuses sessions simultanées. Il s'agit seulement de ne pas fonder sur eux une décision qu'ils n'ont jamais été destinés à soutenir. Toute l'industrie publie aujourd'hui de telles comparaisons, et chaque éditeur choisit le chiffre qui le met le plus en valeur.
Équipes et workflows
Deux mécanismes aux buts différents gèrent la combinaison d'agents.
from agno.team import Team
team = Team(
members=[analyst, editor],
model=OpenAIChat(id="gpt-4o"),
instructions="The analyst prepares the numbers, the editor writes the report.",
)
team.print_response("Prepare the June sales report.")Une équipe fonctionne selon l'un de quatre modes : le leader choisit lui-même les membres et synthétise leurs résultats, il route toute la requête vers un seul spécialiste, il envoie la même tâche à tout le monde, ou il tient une liste de tâches partagée jusqu'à épuisement. Le partage des réponses entre membres est un réglage distinct, désactivé par défaut. Cela convient aux tâches qui demandent des spécialités différentes et coûte cher, car la coordination implique des appels au modèle en plus du travail lui-même.
Un workflow sert à autre chose : il décrit les étapes explicitement, dans le code, avec des conditions et des boucles. C'est le choix pour les processus qui doivent s'exécuter à l'identique à chaque fois.
Répartir le travail entre les deux est une ligne directrice pratique pour tout le projet. Décris un processus aux étapes connues comme un workflow, car tu gagnes en répétabilité et en diagnostic moins coûteux. Laisse à un agent ou à une équipe une étape unique qui demande du jugement.
La couche runtime
C'est la partie qui manque généralement à la concurrence et le meilleur argument en faveur de ce projet.
Le runtime enveloppe les agents, les équipes et les workflows dans un serveur qui les expose via une API réseau ordinaire. Tu obtiens des endpoints prêts, la gestion des sessions, le stockage de l'historique des conversations, les traces d'exécution et une vue de ce qui se passe à l'intérieur.
La différence pratique, c'est que tu n'écris pas toi-même la couche serveur. Dans un déploiement d'agent typique, ce sont plusieurs centaines de lignes qui gèrent les sessions, le streaming, le stockage de l'historique et l'authentification, plus des décisions qu'il faut prendre correctement du premier coup.
Une distinction importante : l'état va dans ta base de données plutôt que dans le service de l'éditeur. Cela signifie que les données de conversation restent chez toi et relèvent de tes règles de conservation, ce qui, au regard des exigences sur les données personnelles, est parfois une condition d'entrée.
Note cependant qu'une couche runtime est une dépendance de plus dans l'architecture, avec son propre cycle de versions. Si tu as déjà une couche serveur mature, y brancher les agents est souvent plus simple que d'ajouter un runtime distinct à côté.
L'inspecteur d'exécutions mérite aussi l'attention, car c'est la partie la plus pratique de cette solution. Tu vois une exécution sous forme d'arbre : appels au modèle, appels d'outils, arguments, résultats, durées et consommation de tokens. Sans cela, la seule méthode de diagnostic consiste à rejouer l'exécution et à fixer la console, et avec des agents, où la même entrée produit des exécutions différentes, cette méthode échoue tout simplement.
Mémoire et connaissances
Deux choses disponibles immédiatement, pour lesquelles d'autres bibliothèques exigent des paquets séparés.
La mémoire stocke l'historique des conversations ainsi que les conclusions qu'on en tire, rattachés à un utilisateur et à une session. L'agent se souvient de ce que vous avez réglé hier sans qu'on lui repasse tout l'historique à chaque requête.
C'est un enregistrement que la bibliothèque tient : l'agent l'utilise mais ne le gère pas. Letta prend la voie opposée : l'agent modifie des blocs de sa propre mémoire avec des outils et décide lui-même ce qui reste dans le contexte et ce qui en est sorti. Cela fonctionne mieux sur une longue relation avec un même utilisateur, au prix d'appels au modèle supplémentaires à chaque écriture, mais note que les auteurs ont décrit le serveur Python de ce projet comme déprécié en juillet 2026 et ont déplacé le développement vers une variante Node.js.
La couche de connaissances est la recherche de documents branchée à l'agent comme source de contexte. Tu charges des documents, tu nommes un vector store, et l'agent y puise quand c'est nécessaire.
Prévois deux choses pour ces deux mécanismes dès le départ. La première est le coût : la mémoire demande des appels au modèle à l'écriture, et les connaissances en demandent au calcul des vecteurs, donc les deux s'ajoutent à la facture en plus de la conversation elle-même. La seconde est la suppression des données. Un enregistrement rattaché à une personne relève du droit à l'oubli, donc la possibilité d'effacer tout ce qui concerne un utilisateur devrait exister dès le premier jour plutôt que d'apparaître après la première demande.
Ce qui vaut vraiment la peine d'être mesuré
Puisque les chiffres de création d'agent en disent peu, voici les chiffres qui tranchent réellement un choix de bibliothèque et la préparation à la production.
Le premier est le coût par tâche, mesuré sur des cas réels de ton propre système plutôt que sur un exemple de documentation. Prends dix vraies requêtes, additionne les tokens utilisés et multiplie par l'échelle prévue. Ce seul chiffre en dit plus que n'importe quelle comparaison de bibliothèques.
Le deuxième est le nombre de tours par tâche. Un agent qui termine en trois tours et un autre qui en demande douze diffèrent d'un facteur quatre en coût, et la différence vient généralement des descriptions d'outils et des instructions plutôt que de la bibliothèque.
Le troisième est le délai avant le premier caractère visible. Les utilisateurs jugent la vitesse au moment où quelque chose commence à se passer plutôt qu'à la durée totale. Diffuser en streaming des événements intermédiaires peut changer la perception d'une tâche de trente secondes plus que n'importe quelle optimisation.
Le quatrième, le plus important et le moins souvent mesuré, est la part de tâches menées à bien sur un ensemble fixe de cas aux résultats attendus. Seul ce chiffre établit si une modification des instructions a amélioré quoi que ce soit. Sans lui, le jugement se réduit à une impression tirée de quelques essais manuels, et les impressions trompent régulièrement.
Le cinquième est le temps nécessaire pour établir la cause après une exécution ratée. Difficile à mesurer et le plus durement ressenti au quotidien, il décide généralement si une équipe reste avec sa bibliothèque après trois mois.
Déploiement et coûts d'exploitation
Quelques points que cette catégorie d'outils exige de régler avant que quoi que ce soit n'atteigne les utilisateurs.
Un plafond de coût par exécution devrait exister dès le premier lancement. Un agent pris dans une boucle peut faire des dizaines d'appels au modèle avant que quiconque s'en aperçoive, et un plafond est le seul mécanisme qui fonctionne sans ton attention.
Enregistrer les exécutions coûte moins cher ici qu'ailleurs, puisque la couche runtime le fait elle-même, mais la durée de conservation de ces données mérite une décision. Stocker chaque conversation sans expiration fait grossir la base à un rythme que personne n'avait prévu, et avec des données personnelles l'obligation de les supprimer arrive aussi.
Réfléchis à ce qui se passe quand tu déploies une nouvelle version avec des sessions en cours. Changer les instructions système en pleine conversation produit un agent qui se comporte autrement qu'il y a deux tours, ce qui ressemble à un défaut du point de vue d'un utilisateur. Épingler une session à une version de configuration règle cela une fois pour toutes.
Le dernier point est l'isolation des outils qui modifient l'état. Une fonction qui envoie un message ou modifie des données devrait exiger une confirmation ou opérer sur un périmètre explicitement borné, car ses arguments viennent d'un texte généré par le modèle, sur lequel les données d'entrée influent aussi.
Agno face aux alternatives
| Option | Atout | Faiblesse | Choisis-la quand |
|---|---|---|---|
| Agno | Couche runtime incluse, mémoire et connaissances intégrées | Écosystème plus jeune, beaucoup de concepts d'un coup | Tu veux un chemin rapide de l'agent à un service fonctionnel |
| LangGraph | Graphe explicite, diagnostic mature, grande communauté | Le serveur et les sessions sont à toi | Un processus à l'état complexe |
| CrewAI | Rôles aux tâches clairement attribuées, simplicité | Moins flexible sur les tâches ouvertes | Une automatisation aux étapes connues |
| Pydantic AI | Typage, abstraction minimale | Périmètre d'orchestration plus étroit | Un agent avec une structure de résultat fixe |
Le premier critère est ce que tu as déjà construit. Si une couche serveur, des sessions et un stockage d'historique fonctionnent déjà dans ton système, ajouter un runtime distinct est superflu, et seule l'interface de la bibliothèque compte alors.
Le deuxième est la maturité de l'outillage de diagnostic. Avec les agents, le plus gros coût est d'établir pourquoi une exécution a mal tourné, et là les projets à l'histoire plus longue et à la communauté plus large ont l'avantage.
Erreurs courantes
La première est de choisir une bibliothèque sur les chiffres de création d'agent. Ils mesurent le coût de création d'un objet plutôt que le temps de réponse, dominé par l'appel au modèle.
La deuxième est de chercher des ressources sous l'ancien nom du projet. Les anciens tutoriels décrivent un outil à la finalité différente et induisent en erreur.
La troisième est une équipe d'agents là où un workflow suffit. La coordination implique des appels au modèle supplémentaires, donc avec des étapes connues tu ajoutes du coût sans gain.
La quatrième est d'activer la mémoire et la couche de connaissances sans les chiffrer. Les deux ajoutent des appels en plus de la conversation elle-même, et cela n'apparaît que sur la facture.
La cinquième est de n'avoir aucun moyen de supprimer les données d'un utilisateur. La mémoire rattachée à une personne relève des règles sur les données personnelles, et l'ajouter plus tard est plus difficile que de la prévoir au départ.
La sixième est d'ajouter une couche runtime à un système qui en a déjà une. Deux runtimes côte à côte, c'est deux cycles de versions et deux endroits où quelque chose peut casser.
FAQ
Agno est-il l'ancien Phidata ?
Oui, le projet a été renommé début 2025 et a changé de direction en même temps : d'un outil plus proche du travail sur les données, il est devenu un framework d'agents avec sa propre couche runtime. Les ressources sous l'ancien nom décrivent autre chose et valent la peine d'être ignorées.
Ces chiffres de performance comptent-ils ?
Dans trois cas, oui : la création dynamique d'agents à chaque requête, les simulations avec des milliers d'agents simultanés, et les environnements qui démarrent un processus à chaque requête. En dehors, le temps de réponse est dominé par l'appel au modèle et la différence n'est pas mesurable.
Qu'est-ce que la couche runtime ?
Un serveur qui expose les agents via une API réseau, avec gestion des sessions, stockage de l'historique et inspection des exécutions. L'état va dans ta base de données, donc les données de conversation restent chez toi et relèvent de tes règles de conservation.
Fonctionne-t-il avec des modèles de plusieurs fournisseurs ?
Oui, des dizaines de familles de modèles sont prises en charge, y compris celles exécutées en local. Changer de fournisseur revient à remplacer l'objet modèle passé à l'agent, sans modification ailleurs.
Quand choisir autre chose ?
Quand tu as déjà une couche serveur mature avec sessions et stockage d'historique, car le principal avantage de ce projet est alors superflu pour toi. Quand le diagnostic des exécutions prime, regarde LangGraph, qui a une histoire plus longue et un outillage d'observabilité plus riche.
La documentation se trouve sur le site du projet, et le code dans le dépôt GitHub.