Delv
Task AutomationActive· 6dby Agno4.3

Agno

Open-source framework (formerly Phidata) for building high-performance agentic systems with memory, knowledge, tools and reasoning.

B
Safety & Trust

Delv Safety Grade: B

Score 71/100 · assessed 2026-04-18

Maintainer65
Permissions45
Supply chain75
Transparency85
Incidents100

Agno (formerly Phidata) is an open-source Python framework for building autonomous AI agents with memory, knowledge bases, and tool integration. The project shows active development with reasonable documentation and a clear GitHub presence. However, as a framework for autonomous agents, it inherently requires broad permissions including filesystem access, network calls, and potential shell execution depending on configured tools. The maintainer appears to be a smaller commercial entity rather than a major vendor, and the recent rebrand from Phidata to Agno (2024) means less established track record under the current name. Supply chain is standard via PyPI with proper versioning. No known security incidents, but the autonomous agent nature means users must carefully audit any tools and integrations they enable, as the framework itself provides the scaffolding for potentially high-privilege operations.

Green flags

  • Fully open source with active GitHub repository and good documentation
  • Standard PyPI distribution with semantic versioning
  • No known security incidents or CVEs
  • Clear architecture with modular tool system for auditing
  • Active community with regular updates and issue tracking

Red flags

  • Autonomous agent framework can execute arbitrary tools with broad permissions
  • Recent rebrand from Phidata to Agno reduces established reputation
  • Smaller commercial maintainer with limited bus factor
  • Framework nature means security depends heavily on user configuration

Permissions requested

Read filesWrite filesOutbound networkRead envShell executeExternal LLM callDB readDB write
Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

Pricing

FREEOpen source

Platforms

apicli

Review

Agno (the artist formerly known as Phidata) is a Python framework for building agents that actually remember what they've done. Where LangChain gives you chains and LlamaIndex gives you retrieval, Agno gives you structured sessions, persistent memory stores, and a batteries-included runtime for production deployments. I've used it to build a support agent that triages GitHub issues across three repos. The memory layer is the standout feature: agents can recall previous conversations, decisions, and context without you manually stuffing everything into prompts. Sessions persist to Postgres or Redis, so an agent picking up a conversation three days later knows exactly where it left off. This isn't magic, it's just good state management, but most frameworks make you build it yourself. The tool integration is cleaner than LangChain's. You decorate Python functions with @tool and the agent gets a schema automatically. I wired up Jira, Slack, and a custom API in about an hour. The reasoning loop is transparent: you can see which tools the agent considered, why it picked one, and what it learned. Debugging is less painful than with black-box systems. Multi-agent orchestration is where Agno wants to shine. You can spin up specialist agents (one for research, one for code review, one for writing) and have them collaborate. In practice, this works well for bounded tasks but falls apart when agents need to negotiate ambiguous handoffs. I've had better luck keeping one smart agent with a broad toolkit than coordinating three narrow ones. Failure modes: the framework assumes you're comfortable with async Python and database schemas. If you're prototyping in a notebook, the session management feels heavy. The docs are improving but still lean on examples over API references. And because it's open-source with a small team, you're sometimes reading source code to understand behaviour. Compared to AutoGPT or BabyAGI, Agno is far more production-ready. Compared to LangGraph, it's less flexible but faster to ship. If you need an agent that remembers context across sessions and you're already in the Python ecosystem, Agno is the pragmatic choice. If you want maximum control over every decision loop, LangGraph or raw API calls will serve you better.
Verdict

Best for Python teams building stateful agents that need to remember context across sessions. Skip it if you're prototyping in notebooks or need a no-code solution. The memory layer alone justifies the learning curve for production use cases.

Good at

  • Persistent memory across sessions without manual prompt engineering
  • Clean tool integration with automatic schema generation
  • Transparent reasoning logs make debugging tractable
  • Production runtime with Postgres/Redis backing
  • Genuinely open-source with no vendor lock-in

Watch out

  • Assumes comfort with async Python and database setup
  • Multi-agent coordination gets messy with ambiguous handoffs
  • Documentation leans heavily on examples over API references
  • Session management feels heavy for quick prototypes
  • Smaller community than LangChain means fewer third-party integrations

Use cases

  • multi-agent apps
  • production runtime
  • memory-backed agents