mrkeyoor.com_
Thu 17 Sept 23:19 UTC
AI Toolsevaluationupdated 25 Aug 2026

agno review

Agno is a Python framework and runtime for building agents, serving them through an API, and operating them from a web interface. It bundles storage, traces, permissions, integrations, scheduling, and several agent protocols so a team can own more of its agent platform.

+64stars / 7d
Verdict

Our Agno quickstart installed 135 packages into 482 MB and pip-audit found 3 known vulnerabilities, so adopting it means accepting a real platform dependency, not adding a tiny agent helper. It is a strong candidate for Python teams that need agents, APIs, storage, permissions, and operations in one system. For a single tool-calling agent, start with a narrower library and add infrastructure only when the application proves it needs it.

We ran it

Lab card: what happened when we ran agnoScreenshot of agno (docs.agno.com)
Install✓ · 59s135 packages · 482 MB
Build✓ · 8s
Testsn/ano test script
Known vulns3(pip-audit)
Repo5260 files~896,024 lines of source · 47.8 MB · 7 CI workflows

Answers from our run

Does agno build from source?

Dependencies installed in 59 seconds (135 packages), and the build succeeded in 8 seconds. We cloned commit 7b8e530 into a clean Debian container with 3 CPUs and no project-specific setup.

Does agno have tests you can run?

Not through a standard command: the project exposes no test script or target that our harness could run.

Does agno have known vulnerabilities in its dependencies?

pip-audit flagged 3 known advisories in the dependency tree at the time of our run.

Who should not use agno?

Developers who only need a small function-calling loop: Agno's runtime, control plane, storage, and 100-plus integrations add a much larger dependency and operating surface.

What are the alternatives to agno?

LangGraph, Pydantic AI, CrewAI. Our Agno quickstart installed 135 packages into 482 MB and pip-audit found 3 known vulnerabilities, so adopting it means accepting a real platform dependency, not adding a tiny agent helper.

Setup3/559-second quickstart install, but a full platform needs several services
Docs4/5Clear overview and extensive linked guides, with details split across sites
Community5/5Current release, same-day pushes, and heavy issue and PR activity
Maturity4/5Broad production runtime, though v3 interfaces are still moving

Discussed on

  1. hnShow HN: Agno – A full-stack framework for building Multi-Agent Systems76 points
  2. hnAgno Agents startup 5000x faster than Langgraph, use 50x less memory11 points
  3. hnMCP Agents: Connect your Agents to 100s of MCP-compatible services6 points
  4. hnShow HN: Agno – lightweight framework for building Multimodal Agents6 points

Who it’s for

Python teams turning a working agent into a multi-user service.
Platform engineers who want agents, sessions, memory, traces, and permissions under one runtime.
Product teams that need REST, streaming, websocket, MCP, A2A, or chat-app interfaces.
Organizations willing to run Postgres and containers to keep agent data in their own environment.

Who it’s NOT for

Developers who only need a small function-calling loop: Agno's runtime, control plane, storage, and 100-plus integrations add a much larger dependency and operating surface.
Teams expecting a no-account local demo: useful agents still need credentials for their chosen model and any external tools.
Organizations that cannot accept usage telemetry by default: the README says one event is sent per agent run unless AGNO_TELEMETRY=false is set.
Buyers demanding a quiet, settled API: v3.0.0 was released on 2026-08-24 while current pull requests were still changing MCP schemas, session caching, hooks, and authorization.
Security-sensitive deployments without time for dependency review: our pip-audit result contained 3 known vulnerabilities.

Setup reality

Our sandbox install at commit 7b8e530 finished in 59 seconds, pulled 135 packages, and occupied 482 MB. The build succeeded in 8 seconds. The quickstart subtree had no test target, so tests were skipped, and pip-audit reported 3 known vulnerabilities.

A useful agent needs a model-provider key. The platform path described in the README also brings Docker, Postgres, an MCP server, and a control plane; cloud templates add their own accounts and deployment configuration.

The project under our harness lived in cookbook/00_quickstart/, not at the repository root. That makes the measured build a quickstart check rather than proof of the full 5,260-file repository. Production users also need to decide whether to disable per-run telemetry and how to configure JWT roles and tenant isolation.

Agno combines an agent SDK with the service around it

Agno is broader than a library for calling a language model. The Python SDK defines agents and teams, while AgentOS exposes them through a production API and a web control plane. Storage covers sessions, memory, knowledge, and traces. The runtime adds scheduling, human approval, audit logs, JWT-based roles, and tenant isolation. More than 100 integrations connect agents to data and external tools.

That scope solves a familiar transition problem. A prototype can survive as a script with one provider key. A product needs persistent sessions, access rules, observability, background work, and a stable client interface. Agno places those concerns in one project and offers more than 50 API endpoints with server-sent events and websockets. It can also present agents through Slack, Telegram, WhatsApp, Discord, AG-UI, A2A, and MCP.

The starter template creates a platform, not a single script

The README's recommended start is unusual: give a coding agent a prompt that points it to a separate deployment repository. The Railway template creates a REST API, Postgres database, MCP server, and control plane through Docker. Matching starter repositories target plain Docker, AWS, Google Cloud, Azure, Fly, Render, Modal, and Helm. Developers who prefer manual work can follow a 20-line first-agent guide and build upward.

This split is useful once you understand it. The main repository contains the framework and a very large cookbook, while the starter repositories carry deployment choices. It also means a clone of agno-agi/agno is not the whole documented onboarding path. Teams evaluating the project should pick one deployment target, record exactly which template revision they used, and avoid treating an AI-driven setup prompt as a substitute for reading the generated configuration.

What happened when we ran it

Our sandbox tested commit 7b8e530 in cookbook/00_quickstart/. Installation took 59 seconds, added 135 packages, and used 482 MB on disk. The build completed in 8 seconds. There was no test script or target in that quickstart, so the test step was skipped. pip-audit reported 3 known vulnerabilities.

The checkout itself was much larger: 5,260 files, roughly 896,024 lines of source, and 47.8 MB before installation. It had 7 CI workflow files, but no Dockerfile or tests directory at the measured location. Those figures should frame the result correctly. We proved that one quickstart installs and builds in a clean Python 3.12 Debian container; we did not prove every provider, integration, database adapter, or deployment template works.

The 482 MB footprint is reasonable for a modern Python AI environment, yet it is far from a tiny utility. Audit the 3 reported vulnerabilities against the resolved packages before production deployment. Our lab block does not identify their packages or severity, so no stronger conclusion is justified. Pinning the tested dependency set and rerunning the audit in the final image is the practical next step.

Owning the data still requires external model credentials

Agno says users can control their data, memory, and security posture. Self-hosted Postgres and the runtime support that aim, but most useful agents still call a model provider. Toolkits may also need credentials for GitHub, Slack, databases, or other services. The security boundary therefore depends on which model and tools a team connects, not only on where AgentOS runs.

Telemetry is another explicit choice. The README says Agno sends one event per agent run to help prioritize model providers, while excluding prompts, messages, and outputs. Setting AGNO_TELEMETRY=false disables it. Companies with strict outbound-data rules should set and test that variable in deployment policy. Leaving it to each developer makes behavior differ between laptops, CI, and production.

Human approval can pause runs and restrict tools that need administrator permission. That is useful for agents capable of changing outside systems. It does not decide which actions deserve approval, and a long integration catalog increases the number of credentials and permission scopes an operator must review. Start agents with the smallest tool set they need.

Version 3 is active enough to demand careful upgrades

Agno v3.0.0 was released on 2026-08-24, and the repository was pushed again on 2026-08-25. GitHub reported 1,297 open issues and pull requests combined. The number reflects both user reports and a busy contribution queue, so it is not a defect count. Recent work covered MCP structured content, session caching, tool-hook arguments, Postgres concurrency, and more flexible authorization.

That activity is reassuring for support and risky for casual upgrades. Changes around schemas, stateful tools, storage races, and authorization sit on production paths. Pin versions, exercise the exact database and provider mix in staging, and read migration notes before moving a running service to v3. A same-day patch stream is evidence of maintenance, but it also says interfaces are being corrected in public.

Choose Agno when consolidation saves more work than it creates

A team already juggling separate code for agent execution, APIs, memory, traces, roles, schedules, and chat interfaces can get real value from AgentOS. Apache 2.0 licensing also makes internal and commercial adaptation straightforward. The linked documentation covers each subsystem, and the deployment templates give operators concrete starting points.

Smaller applications should resist adopting the whole surface too early. Pydantic AI is a cleaner fit for typed agent code when you want to select infrastructure yourself. LangGraph suits explicit state machines and durable flows. CrewAI puts role-based agent teams nearer the center. Agno earns its weight when the operating platform is the problem you are trying to solve.

Alternatives

ProjectWhat it isPick it when
LangGraph gh↗A graph-based runtime for stateful agent workflows and durable execution.pick this instead when explicit workflow state and branching matter more than an all-in-one agent platform.
Pydantic AIA typed Python agent framework built around Pydantic models and provider portability.pick this instead when you want a smaller application framework and prefer to choose storage and operations separately.
CrewAI gh↗A Python framework centered on teams of role-based agents and task flows.pick this instead when multi-agent delegation is the product concept and you do not need AgentOS's full runtime.

Sources

  1. Agno README
  2. Agno documentation
  3. Agno v3.0.0 release
  4. Agno issues and pull requests

More ai tools reviews

rowboat · skills · superpowers-zh · yolov5 · eve · MemOS · the whole board →