LaunchedEditorial Listing

Agno

Agno Inc. · Agno: Open-Source Python Agent Framework and Self-Hosted AgentOS Runtime

Open Agno

Agno (formerly Phidata) is an open-source, Apache-2.0 Python SDK for building agents, multi-agent teams and workflows, paired with AgentOS, a runtime that serves them as a REST API, MCP server and chat-app integrations from your own cloud. It suits Python teams that want to own their agent stack and data, with an optional hosted control plane for monitoring and operating live deployments.

PricingFreemium
Setupmedium
Runs onSelf-hosted · API · Web
APIYes
Open sourceYes
DocsYes
Agent FrameworkPythonOpen SourceMulti-AgentSelf-HostedModel-AgnosticMCPA2AHuman-in-the-LoopObservabilityPersistent MemoryRAGGovernance

Best for

Python teams that want one open-source stack to build agents, teams and workflows and run them in their own cloud as an API, MCP server and chat-app bot, with data kept in their own database and an optional hosted UI for operating them

Not ideal for

TypeScript-first teams, people who want a fully managed hosted agent service or a no-code builder without running infrastructure, and small projects that only need a thin wrapper around one model API

Who it's for

Python developers and platform teams building agents for their own products or employees who want to self-host the runtime and keep data in their own infrastructure

Capabilities

  • Three building blocks in one Python SDK: single agents, teams where a leader delegates to member agents, and step-based or pure-Python workflows with sequential, parallel, conditional and looping patterns
  • 100+ prebuilt toolkits (GitHub, Slack, Postgres and more), custom tools via an `@tool` decorator, MCP tools, and CodeMode, which lets the model call tools from a persistent Python kernel instead of one schema per tool
  • Knowledge for agentic RAG with chunking, filtering and reranking, plus user memory, session state, chat history, context compression, skills and learning features
  • Model setup by `provider:model_id` string with fallback models, covering native, cloud (AWS Bedrock, Azure, Vertex AI), gateway (OpenRouter, LiteLLM) and local (Ollama, vLLM, LM Studio, llama.cpp) providers
  • AgentOS runtime that serves agents, teams and workflows as a REST API with SSE and WebSocket streaming, background runs, run cancellation and resumable streams
  • Sessions, runs, memory, knowledge, traces, schedules and evals stored in your own database, such as PostgreSQL or SQLite
  • JWT-based authentication with per-endpoint scopes, service accounts, opt-in per-user data isolation, and an RBAC and user-management package added in v3.1
  • Human approval: pause runs for user confirmation and block tools that need admin approval, with approvals resolved in the control plane
  • OpenTelemetry tracing of model calls, tool calls, team delegation and workflow steps, with token metrics and run history
  • Cron scheduling and background jobs without external infrastructure
  • Interfaces that expose agents through an MCP server (for Claude, ChatGPT and other MCP clients), A2A, AG-UI, Slack, Telegram, WhatsApp and Discord
  • Multi-framework serving: AgentOS can run agents built with LangGraph, DSPy, the Claude Agent SDK and Antigravity alongside Agno agents
  • Starter templates for Docker, Railway, AWS, GCP, Azure, Fly, Render, Modal and Kubernetes (Helm), set up by pasting a prompt into a coding agent
  • Hosted AgentOS Control Plane with chat, sessions, trace trees, a no-code Studio for drafting and versioning components, memory, knowledge, evaluations, metrics, approvals and scheduler views

Limitations

  • The SDK is Python-only; no official SDK for TypeScript or other languages is documented
  • On the Free plan the hosted control plane connects only to AgentOS instances on your own machine; operating a live deployment from it requires Pro ($150/month), and a self-hosted control plane is an Enterprise add-on
  • You run the runtime yourself: the container, database, HTTPS and network controls such as rate limiting, WAF and IP allowlists are your responsibility, as the docs place them at your reverse proxy or API gateway
  • Fast-moving releases include breaking changes: v3.0 required a database migration before serving traffic, and v3.1 re-keyed the filesystem table and made MCP default tools opt-in
  • The SDK sends a telemetry event for each agent run by default (no prompts or outputs, per the README); set `AGNO_TELEMETRY=false` to disable it
  • Per-user data isolation for JWT callers is off by default; multi-tenant deployments must enable it (`user_isolation=True`), or callers with read scopes can query data across users
  • End-user identity, end-user audit logs and per-resource RBAC are Enterprise features, and SAML SSO on Pro is a $300/month add-on
  • Feature support varies by model provider adapter and model ID, so capabilities such as structured outputs or built-in tools depend on the model you pick

Use cases

  • Building a customer support agent that answers from product docs and order data, then serving it inside your product over the AgentOS REST API
  • Running a team of research agents that fan a question out to specialists and merge the answers into one brief
  • Publishing an internal agent as an MCP server that employees add to Claude or ChatGPT as a custom connector
  • Scheduling a weekly workflow that summarizes product usage and posts the report to Slack
  • Adding approval gates to an invoice-processing workflow so a person signs off before anything is posted
  • Standardizing on one runtime, database and control plane for agents written in Agno, LangGraph and DSPy

Our take

Agno's distinguishing choice is that the production runtime is part of the open-source package rather than a paid hosting tier. AgentOS gives you the API server, database-backed sessions and memory, JWT auth, approvals, tracing and scheduling, and Agno charges only for the hosted UI that watches live deployments. That makes it attractive for Python teams that would otherwise build that platform layer themselves and want data to stay in their own cloud. The costs are operational: you own the deployment, database and network security, releases move fast and sometimes need migrations, and the most useful control-plane features for a team start at $150 a month. Pin versions, read the release notes before upgrading, and turn off telemetry if your policies require it.

Who should use it

Python developers and platform teams building customer-facing or internal agents who want to run them in their own AWS, GCP, Azure or Kubernetes environment, serve them through an API, MCP and Slack from one runtime, and keep sessions, memory and traces in their own database.

Who should skip it

TypeScript-first teams, anyone who wants a fully managed agent hosting service with no infrastructure to run, non-developers looking for a visual builder as the main way to create agents, and teams that cannot absorb frequent breaking upgrades.

Strengths

  • Apache-2.0 SDK and runtime are free at any scale, with no per-event, token or egress fees from Agno
  • Covers build and run: the same package that defines agents also serves them as an API, MCP server and Slack, Telegram or WhatsApp bot
  • Data stays in your own database, and the hosted control plane reads it from your runtime in the browser
  • Wide model coverage across native providers, cloud platforms, gateways and local runtimes
  • Production pieces such as JWT RBAC, per-user isolation, approvals, tracing and scheduling are built into the runtime

Weaknesses

  • Python only
  • You operate the infrastructure, and a live deployment in the hosted control plane starts at $150/month
  • Frequent breaking releases with database migrations
  • Telemetry is on by default

Agno pricing

Free

$0/month

Billed monthly

  • Open-source SDK and AgentOS runtime (Apache-2.0)
  • Unlimited usage and retention
  • Control plane for AgentOS instances on your own machine
  • Serve agents over REST, MCP and chat interfaces
  • Community support

Pro

$150/month

Billed monthly

  • Control plane for 1 live AgentOS connection
  • 3 team seats with Owner, Admin, Member and Viewer roles
  • Extra seats $30/month, extra live connections $95/month
  • SAML SSO as a $300/month add-on
  • Email support; 14-day free trial

Enterprise

Custom

  • End-user management, identity, roles and audit logs
  • Custom RBAC with per-resource scoping
  • Slack Connect support and SLA
  • Add-ons: self-hosted control plane, custom model training, help building your product agent

Free tier limits: The SDK and runtime are free at any scale. The Free control plane connects only to AgentOS instances running on your own machine (for example at localhost:7777), not to a deployed one.

Note: Agno charges for the hosted control plane by seat and live connection; there are no per-event, token, storage, retention or egress fees, and serving agents costs nothing on any plan. Model provider usage and your own cloud and database costs are billed separately by those providers.

Technical specs

Modalities

text, image, audio, video, files

API pricing

Self-hosted AgentOS REST API, free and open source; model usage is billed by your provider

Available models

OpenAIAnthropic ClaudeGoogle GeminiMistralCohereDeepSeekxAI GrokMeta LlamaAWS BedrockAzure OpenAIAzure AI FoundryVertex AI (Claude)IBM watsonxOpenRouterLiteLLMGroqOllamavLLMLM Studiollama.cpp

Where Agno excels

Shipping a product agent inside an existing app

AgentOS turns the agent into a REST API with streaming, JWT scopes and opt-in per-user data isolation, so a backend team can call it like any other service while sessions and memory stay in its own Postgres database.

Exposing one agent in several places

The same deployment can serve the agent in your product, in Claude or ChatGPT through the MCP server, and in Slack, Telegram or WhatsApp through built-in interfaces, without separate integrations for each channel.

Governing agents that take real actions

Tools can require user or admin approval, approvals and traces are reviewed in the control plane, and scheduled runs keep their history, which helps teams audit what an agent did and why.

Agno vs. competitors

Agno vs. CrewAI

CrewAI centers on role-based crews of agents plus event-driven Flows, and sells a managed platform (AMP) and a self-hosted one (Factory). Agno offers similar agents, teams and workflows, but its production runtime, AgentOS, is open source and self-deployed, with Agno charging for the hosted control plane that operates those deployments rather than for running agents.

Agno vs. LangGraph

LangGraph is a lower-level library where you define agent logic as an explicit state graph with checkpoints and human-in-the-loop interrupts. Agno offers higher-level agent, team and workflow primitives plus its own runtime and control plane. The two can also be combined: AgentOS can wrap a compiled LangGraph graph and serve it alongside Agno agents.

Agno vs. Pydantic AI

Pydantic AI focuses on type-safe agents with validated structured outputs, and leaves hosting to you (with optional Logfire and gateway services). Agno also supports structured input and output, but its emphasis is the platform layer: a built-in runtime with storage, auth, interfaces, scheduling and a control plane.

Agno vs. Google ADK

Google ADK is a code-first framework with SDKs for Python, TypeScript, Go, Java and Kotlin and a close fit with Gemini and Google Cloud. Agno is Python-only but provider-neutral, and ships its own deployable runtime with templates for several clouds instead of steering deployment toward one platform.

Frequently asked questions

What is Agno?

Agno is an open-source Python framework and runtime for agent platforms. You build agents, teams and workflows with the Agno SDK, run them with AgentOS as a REST API, MCP server or chat-app bot in your own cloud, and can manage them from the AgentOS Control Plane web UI.

Is Agno the same as Phidata?

Yes. Phidata was renamed Agno. The old Phidata documentation says "Phidata is now Agno!", and the phidatahq/phidata GitHub repository now redirects to agno-agi/agno. Current releases are published to PyPI as `agno`; the `phidata` package is no longer the active line.

How much does Agno cost?

The SDK and the AgentOS runtime are free and open source under Apache-2.0, and Agno does not charge for serving agents. The hosted control plane has a Free plan for AgentOS instances on your own machine, a Pro plan at $150/month with one live deployment connection and three team seats (extra seats $30/month, extra connections $95/month, SAML SSO $300/month, with a 14-day trial), and custom-priced Enterprise. You also pay your model provider and your own cloud costs.

Can Agno be self-hosted?

Yes. AgentOS runs as a container anywhere you can run one, with templates for Docker, Railway, AWS, GCP, Azure, Fly, Render, Modal and Kubernetes, and stores data in your own database. The control plane is hosted at os.agno.com by default, but it reads from your runtime in the browser rather than copying your data. A self-hosted control plane is an Enterprise add-on.

Which models does Agno support?

Agno's docs list native adapters for OpenAI (Chat Completions and Responses), Anthropic, Google Gemini, Mistral, Cohere, DeepSeek, xAI, Meta, Perplexity and others, cloud platforms such as AWS Bedrock, Azure OpenAI, Azure AI Foundry, Vertex AI and IBM watsonx, gateways such as OpenRouter, LiteLLM, Groq and Fireworks, and local runtimes such as Ollama, vLLM, LM Studio and llama.cpp.

Can AgentOS run agents built with LangGraph or other frameworks?

Yes. Since v2.6.0, AgentOS includes adapters that wrap agents built with LangGraph, DSPy, the Claude Agent SDK and Antigravity so they are routed, streamed and persisted like native Agno agents through one API and UI. Agno-specific features such as memory, knowledge, guardrails and team membership remain limited to native Agno agents.

Agno vs CrewAI: what is the difference?

Both are Python frameworks with multi-agent teams and a commercial platform. CrewAI organizes work as role-based crews and event-driven Flows, with managed (AMP) and self-hosted (Factory) platform options. Agno pairs its SDK with AgentOS, an open-source runtime you deploy yourself, and charges only for the hosted control plane that monitors and operates those deployments.

Integrations & fit

OpenAIAnthropicGoogle GeminiMistralCohereDeepSeekxAIAWS BedrockAzure OpenAIAzure AI FoundryVertex AIGroqOpenRouterLiteLLMOllamavLLMLM StudioMCPA2AAG-UISlackTelegramWhatsAppDiscordPostgreSQLSQLiteOpenTelemetryLangGraphDSPyClaude Agent SDKDockerKubernetesAWSGoogle CloudAzureRailwayFly.ioRenderModalGitHub
Good fit forStartup / small team, Enterprise
Pricing modelFreemium· Free tier available
See pricing on Agno →

Alternatives to consider

About Agno

Agno is the renamed Phidata project: the old Phidata docs now say "Phidata is now Agno!", and the phidatahq/phidata GitHub repository redirects to agno-agi/agno. It has three layers. The Agno SDK (`pip install agno`, Python 3.9+) gives you three primitives, agents, teams and workflows, plus attachable capabilities such as tools (100+ prebuilt toolkits and MCP), knowledge for agentic RAG, user memory, session state, skills, reasoning, structured input and output, human approval steps, evals and guardrails. Models are set with a `provider:model_id` string, and the docs cover native adapters for OpenAI, Anthropic, Google Gemini, Mistral, Cohere, DeepSeek, xAI and others, cloud platforms such as AWS Bedrock, Azure and Vertex AI, gateways such as OpenRouter and LiteLLM, and local runtimes such as Ollama, vLLM and LM Studio. AgentOS, the runtime, is part of the same open-source package. It turns your agents into a production API with SSE and WebSocket streaming, stores sessions, memory, knowledge and traces in your own database, adds JWT-based RBAC with optional per-user data isolation, OpenTelemetry tracing, cron scheduling and background runs, and exposes agents through an MCP server, A2A, AG-UI, Slack, Telegram, WhatsApp and Discord. It can also serve agents built with LangGraph, DSPy or the Claude Agent SDK through adapters. Starter templates deploy it as a container to Docker, Railway, AWS, GCP, Azure, Fly, Render, Modal or Kubernetes, and Agno's quick start has you paste a setup prompt into Claude Code, Cursor or Codex. The paid part is the hosted AgentOS Control Plane at os.agno.com, a web UI for chat, sessions, trace trees, a no-code Studio for versioning components, memory, knowledge, evaluations, approvals and schedules. The browser talks to your AgentOS directly, and Agno says it never holds a copy of your data. The Free plan connects the control plane only to AgentOS instances on your own machine; Pro ($150 per month) adds one live deployment connection, three team seats and roles; Enterprise adds end-user identity, audit logs, per-resource RBAC and an optional self-hosted control plane. The tradeoffs: you operate the runtime, database and network controls yourself, the SDK is Python-only, the project ships breaking changes quickly (v3.0 in August 2026 required a database migration), and per-run telemetry is on until you disable it.

Updates from Agno

New FeatureAgno v3.1 adds RBAC and user management to AgentOS

v3.1.0 added an authorization package with a role store, scope policy, audit log, user directory and admin router, a database-backed AgentOS filesystem with its own routes, and an AI/ML API toolkit. It is a breaking release for DbFileSystem users, who must run a migration script, and MCP configs now publish only the tools you list. v3.1.1 followed on October 2 with progress reporting for knowledge page sync.

LaunchAgno v3.0 moves runs to their own table and adds tool-result offloading

v3.0.0 was a breaking release that requires a database migration: each run now gets its own row, with a one-line, non-destructive migration. It also added offloading of large tool results and media to storage, CodeMode for calling tools from a persistent Python kernel, and per-user isolation that extends beyond sessions to metrics, schedules, evals and knowledge.

Are you the founder? Claim this listing →