Vendor: agno-agi
Agno (formerly Phidata) is a production-oriented, Apache-2.0 agent platform framework that separates SDK-based agent construction, the AgentOS runtime, and a governance UI—delivering Postgres-backed relational memory, native MCP server support, JWT RBAC, and Docker-first deployment for organizations seeking to own their agent infrastructure.
| Repository | agno-agi/agno |
|---|---|
| GitHub Stars | ★ 41.9k |
| Forks | 5.8k forks |
| Primary Language | Python |
| License | Apache-2.0 |
| Technical Domain | AGENTS |
$ git clone https://github.com/agno-agi/agno.git && cd agno
Agno (formerly Phidata) represents a significant maturation of the open-source agent framework space, transitioning from a lightweight toolkit into a full-stack agent platform runtime. The project's core architectural wager is the strict separation of concerns between three planes: the Agno SDK for declarative agent construction, the AgentOS runtime for serving agents as stateful services, and the AgentOS UI for operational governance. This trifold decomposition directly addresses the chronic fragility of agent deployments—where prompt logic, tool execution, memory persistence, and observability are typically entangled in ad-hoc scripts.
At the SDK level, Agno exposes typed Python primitives—Agent, Tool, KnowledgeBase, Session, Team—each with rigorous schema enforcement. Tools are defined with Pydantic-validated signatures, enabling reliable function-calling across heterogeneous LLM providers (OpenAI, Anthropic, Mistral, Ollama, Groq). The framework's native Model Context Protocol (MCP) server integration is particularly noteworthy: it transforms Agno from a consumer of tools into a publisher of tools, allowing enterprise environments to expose internal APIs, databases, and document stores as standardized MCP resources consumable by any compliant agent client.
AgentOS, the runtime layer, is built on FastAPI and Postgres, persisting sessions, traces, memories, and evaluation metrics in a relational schema that supports per-user and per-tenant isolation. JWT-based RBAC is enforced at the API gateway, and the runtime ships with structured trace emission compatible with OpenTelemetry. The deployment story is pragmatic—Docker Compose for local development, with curated templates for Railway, AWS, and bare Docker—lowering the operational barrier without locking users into proprietary infrastructure.
Memory handling is where Agno distinguishes itself from peers like LangChain or CrewAI. Rather than relying on ephemeral in-process state or opaque vector stores, Agno models memory as first-class relational entities: session state, user-level long-term memory, and knowledge-base citations are queryable, auditable, and versioned. This enables a genuine learning loop where usage traces can be replayed, evaluated, and used to refine prompts and tool definitions.
Caveats exist. The framework's breadth introduces cognitive overhead—teams must internalize SDK semantics, AgentOS deployment topology, and MCP conventions simultaneously. Token budget management relies on developer discipline rather than enforced ceilings, and the sandboxing story for arbitrary code execution remains Docker-dependent. Nonetheless, for organizations seeking to own their agent stack rather than rent it from a managed vendor, Agno offers one of the most coherent, extensible, and production-oriented open-source architectures currently available.
Agno's lineage traces back to Phidata, an early-2023 framework that initially focused on structured data extraction and lightweight agent orchestration. The rebrand to Agno—derived from the agno-agi repository namespace, signaling an explicit orientation toward general-intelligence infrastructure—marks a deliberate architectural pivot from library to platform. Where Phidata treated agents as composable Python objects within a developer's application process, Agno treats agents as deployable services managed by a dedicated runtime (AgentOS) and governed by a control plane. This evolution mirrors the broader industry trajectory from prompt-in-a-script prototypes toward durable, observable agent platforms that enterprises can operate with the same rigor applied to traditional microservices.
The core architectural breakthrough is the formal separation of build, run, and manage planes. The Agno SDK provides declarative primitives—Agent, Tool, KnowledgeBase, Session, Team—each with Pydantic-enforced schemas that compile into provider-agnostic function-calling contracts. AgentOS, built on FastAPI and Postgres, materializes these declarations as stateful services with persistent sessions, structured traces, and per-tenant isolation. The AgentOS UI closes the loop with operational governance: RBAC, usage analytics, simulation replay, and prompt iteration. This trifold decomposition directly addresses the chronic entanglement of prompt logic, tool execution, and memory state that plagues frameworks like LangChain, where operational concerns leak into application code and debugging becomes a forensic exercise across multiple abstraction layers.
Several specific design decisions warrant attention. First, Agno's Skill and Tool protocol enforces typed argument signatures and structured return schemas, eliminating the JSON-schema drift that frequently breaks function-calling in production when models emit subtly malformed tool invocations. Second, memory is modeled relationally rather than as opaque vector embeddings—session state, user-level long-term memory, and knowledge citations are first-class Postgres entities, queryable and auditable. Third, the framework's native MCP server support repositions Agno as both tool consumer and tool publisher, enabling enterprise tool registries that any compliant agent client can consume. Finally, execution sandboxing is Docker-native, with the runtime providing isolation boundaries for tool execution rather than relying on in-process trust—a meaningful security posture for organizations handling untrusted inputs or arbitrary code generation.
Enterprise MCP tool registries represent Agno's most strategically differentiated use case. By running AgentOS with its embedded MCP server, organizations can expose internal APIs, document stores, databases, and SaaS connectors as standardized MCP resources. Any compliant agent client—whether Agno-native, Claude Desktop, Cursor, or a third-party orchestrator—can discover and invoke these tools without bespoke integration glue. This transforms the agent platform from an application into infrastructure: a centralized, governed, RBAC-protected catalog of organizational capabilities that becomes the substrate for every downstream agent workflow. The relational Postgres backing store enables per-tool usage analytics, audit trails, and quota enforcement—capabilities typically absent from ad-hoc MCP deployments that rely on file-based or in-memory tool definitions.
Long-term agent memory and structured prompt pipelines form the second major use case cluster. Agno's relational memory model supports user-scoped persistent state, session-scoped working memory, and knowledge-base-grounded retrieval as distinct, queryable entities. This enables customer support agents that recall prior interactions across sessions, research agents that maintain evolving project context over weeks or months, and coding agents that accumulate repository-specific knowledge including file structure, conventions, and prior debugging decisions. Structured prompt pipelines—composed via the Team primitive—allow multi-agent orchestration where specialized agents hand off context with typed message contracts, avoiding the prompt-bloat and context-window exhaustion that degrades single-agent performance on complex, multi-step tasks.
Autonomous browser navigation and multi-modal agent workflows constitute the third use case tier. Agno's tool protocol accommodates browser-use-style automation, vision-language model integration, and document-grounded reasoning within a unified execution context. Teams can compose agents that perceive via multimodal LLM inputs, act via browser, shell, or API tools, and reflect via memory and knowledge retrieval in a closed loop. The Docker-based sandboxing boundary is critical here: arbitrary code execution, file system access, and network egress can be constrained per-agent, providing a defensible security posture for autonomous workflows that would be reckless in unsandboxed environments. The structured trace emission allows every perceptual input, tool invocation, and reasoning step to be replayed and audited post-execution.
Installation follows a conventional Python path: pip install agno establishes the SDK, while the AgentOS runtime is bootstrapped via curated starter templates—agentos-docker for local development, agentos-railway or agentos-aws for cloud deployment. The recommended onboarding flow leverages coding agents such as Claude Code, Cursor, or Codex by handing them a structured prompt that clones the appropriate template, reads the README, and follows the get-started guide. This meta-pattern—using an AI coding agent to scaffold an AI agent platform—is both pragmatic and emblematic of Agno's target audience: developers already embedded in agentic workflows who expect infrastructure to be provisioned through natural-language instruction rather than manual configuration.
A minimal agent definition illustrates the SDK's declarative style. Developers instantiate an Agent with a model reference (OpenAI's gpt-4o, Anthropic's claude-sonnet, or local Ollama models), a list of Tools each defined as a Pydantic-typed callable, an optional KnowledgeBase backed by pgvector or external vector stores, and session configuration controlling memory persistence. The Agent.run method returns a structured RunResponse containing the model output, executed tool calls, token usage metadata, and trace identifiers that correlate to AgentOS UI entries. Serving the agent as a service requires AgentOS: docker compose up launches the FastAPI server, Postgres database, MCP server, and the AgentOS UI on configurable ports. The UI provides immediate visibility into sessions, traces, tool invocations, and memory state—a significant debugging accelerant relative to CLI-only frameworks.
MCP server configuration warrants specific attention. AgentOS exposes an MCP endpoint that aggregates registered Tools as MCP resources, each with auto-generated JSON schemas derived from the Pydantic signatures. External MCP clients connect via the standard MCP transport (stdio or HTTP), authenticate via JWT, and discover available tools through the MCP list-tools protocol. This configuration enables a clean separation between tool definition in Agno SDK code and tool consumption by any compliant client, making Agno a viable backbone for heterogeneous multi-vendor agent ecosystems. Configuration files—typically agentos.yaml—specify model providers, database connection strings, RBAC policies, vector store backends, and deployment targets in a single declarative artifact that can be version-controlled and reviewed.
Production readiness is Agno's strongest practical dimension. The Postgres-backed persistence model provides ACID guarantees for session state and memory—critical for any agent workflow with regulatory, compliance, or audit requirements. JWT-based RBAC, enforced at the FastAPI gateway, supports multi-tenant deployments where different teams or customers share infrastructure with isolated data planes. OpenTelemetry-compatible trace emission integrates with existing observability stacks including Datadog, Honeycomb, and Grafana Tempo, avoiding the proprietary telemetry lock-in characteristic of managed agent platforms. The Docker-first deployment topology aligns with mainstream DevOps practice, and the curated AWS template provides a credible path to production scale without requiring Kubernetes expertise or a dedicated platform engineering team.
Latency and scalability considerations are more nuanced. AgentOS introduces a service layer between agent logic and LLM providers, adding modest overhead—typically 10 to 30 milliseconds per request for session hydration, RBAC checks, and trace persistence—that is negligible relative to LLM inference latency but accumulates in high-throughput scenarios. Postgres as the unified backing store simplifies operations but creates a potential bottleneck for high-volume trace writes; teams operating at scale should consider table partitioning strategies, connection pooling tuning, or offloading cold traces to object storage. Token budget management remains developer-disciplined—Agno exposes token usage metadata in RunResponse objects but does not enforce hard ceilings, requiring teams to implement budget guards and circuit breakers at the application or gateway layer.
Caveats include debugging overhead inherent to any multi-agent framework: traces span LLM calls, tool executions, memory reads, knowledge retrieval, and inter-agent message passing, requiring the AgentOS UI or equivalent observability tooling to reconstruct execution flows. Sandboxing security is Docker-dependent—adequate for most enterprise workloads but insufficient for hostile multi-tenant scenarios requiring gVisor, Firecracker, or Kata Containers-level isolation. The framework's breadth imposes a learning curve: developers must internalize SDK semantics, AgentOS topology, MCP conventions, and the relational memory model simultaneously before achieving productive velocity. Finally, the rapid iteration pace—evidenced by the Phidata-to-Agno transition and frequent SDK releases—means API stability should be evaluated carefully, with pinning and migration testing, before committing to large-scale production deployments.
Agno's adoption footprint—reflected in its 41,000-plus GitHub stars and active contributor base—spans startups, consultancies, and enterprise innovation teams. The framework's rebrand from Phidata preserved sufficient backward compatibility to retain the existing community while attracting new users oriented toward the AgentOS platform vision. Notable implementation patterns include customer support automation platforms using Agno's relational memory to maintain cross-session customer context with full audit trails, internal knowledge agents grounded in enterprise document stores via the KnowledgeBase primitive, and research orchestration systems leveraging the Team primitive for multi-perspective analysis workflows where specialized agents cover distinct domains and synthesize findings through structured handoffs.
Ecosystem integration is a defining strength. Agno supports the major LLM providers—OpenAI, Anthropic, Google, Mistral, Cohere, Ollama, vLLM—through a unified model interface, with streaming, function-calling, and multimodal inputs handled consistently across providers. Vector store integrations include pgvector as the default leveraging the existing Postgres deployment, plus Qdrant, Pinecone, and Weaviate for teams with existing vector infrastructure. The tool ecosystem spans HTTP APIs, SQL databases, file systems, shell execution, browser automation, and SaaS connectors. The MCP server capability positions Agno as a participant in the emerging MCP ecosystem alongside Anthropic's Claude Desktop, Cursor, Continue, and other MCP-compliant clients—a strategically significant interoperability stance as MCP consolidates as the de facto tool-protocol standard.
The deployment template ecosystem—agentos-docker, agentos-railway, agentos-aws—reflects pragmatic engagement with real deployment targets rather than abstract cloud-agnostic claims. The Railway template lowers the barrier for prototype-to-production progression, while the AWS template provides VPC-aware deployment patterns suitable for enterprise environments with compliance constraints around data residency and network egress. Community contributions extend the deployment surface to additional platforms. While Agno has not yet achieved the enterprise reference-customer visibility of managed platforms like LangSmith or Vertex AI Agent Builder, its open-source Apache-2.0 license, self-hostable architecture, coherent platform vision, and active development velocity position it as a credible foundation for organizations prioritizing data sovereignty, vendor independence, and architectural control over their agent infrastructure.
agno is an open-source AI project developed primarily in Python under the Apache-2.0 license. Agno (formerly Phidata) is a production-oriented, Apache-2.0 agent platform framework that separates SDK-based agent construction, the AgentOS runtime, and a governance UI—delivering Postgres-backed relational memory, native MCP server support, JWT RBAC, and Docker-first deployment for organizations seeking to own their agent infrastructure.. Agno's lineage traces back to Phidata, an early-2023 framework that initially focused on structured data extraction and lightweight agent orchestration. The rebrand to Agno—derived from the agno-agi repository namespace, signaling an explicit orientation toward general-intelligence infrastructure—marks a deliberate architectural pivot from library to platform. Where Phidata treated agents as composable Python objects within a developer's application process, Agno treats agents as deployable services managed by a dedicated runtime (AgentOS) and governed by a control plane. This evolution mirrors the broader industry trajectory from prompt-in-a-script prototypes toward durable, observable agent platforms that enterprises can operate with the same rigor applied to traditional microservices. The core architectural breakthrough is the formal separation of build, run, and manage planes. The Agno SDK provides declarative primitives—Agent, Tool, KnowledgeBase, Session, Team—each with Pydantic-enforced schemas that compile into provider-agnostic function-calling contracts. AgentOS, built on FastAPI and Postgres, materializes these declarations as stateful services with persistent sessions, structured traces, and per-tenant isolation. The AgentOS UI closes the loop with operational governance: RBAC, usage analytics, simulation replay, and prompt iteration. This trifold decomposition directly addresses the chronic entanglement of prompt logic, tool execution, and memory state that plagues frameworks like LangChain, where operational concerns leak into application code and debugging becomes a forensic exercise across multiple abstraction layers. Several specific design decisions warrant attention. First, Agno's Skill and Tool protocol enforces typed argument signatures and structured return schemas, eliminating the JSON-schema drift that frequently breaks function-calling in production when models emit subtly malformed tool invocations. Second, memory is modeled relationally rather than as opaque vector embeddings—session state, user-level long-term memory, and knowledge citations are first-class Postgres entities, queryable and auditable. Third, the framework's native MCP server support repositions Agno as both tool consumer and tool publisher, enabling enterprise tool registries that any compliant agent client can consume. Finally, execution sandboxing is Docker-native, with the runtime providing isolation boundaries for tool execution rather than relying on in-process trust—a meaningful security posture for organizations handling untrusted inputs or arbitrary code generation.
Installation follows a conventional Python path: pip install agno establishes the SDK, while the AgentOS runtime is bootstrapped via curated starter templates—agentos-docker for local development, agentos-railway or agentos-aws for cloud deployment. The recommended onboarding flow leverages coding agents such as Claude Code, Cursor, or Codex by handing them a structured prompt that clones the appropriate template, reads the README, and follows the get-started guide. This meta-pattern—using an AI coding agent to scaffold an AI agent platform—is both pragmatic and emblematic of Agno's target audience: developers already embedded in agentic workflows who expect infrastructure to be provisioned through natural-language instruction rather than manual configuration. A minimal agent definition illustrates the SDK's declarative style. Developers instantiate an Agent with a model reference (OpenAI's gpt-4o, Anthropic's claude-sonnet, or local Ollama models), a list of Tools each defined as a Pydantic-typed callable, an optional KnowledgeBase backed by pgvector or external vector stores, and session configuration controlling memory persistence. The Agent.run method returns a structured RunResponse containing the model output, executed tool calls, token usage metadata, and trace identifiers that correlate to AgentOS UI entries. Serving the agent as a service requires AgentOS: docker compose up launches the FastAPI server, Postgres database, MCP server, and the AgentOS UI on configurable ports. The UI provides immediate visibility into sessions, traces, tool invocations, and memory state—a significant debugging accelerant relative to CLI-only frameworks. MCP server configuration warrants specific attention. AgentOS exposes an MCP endpoint that aggregates registered Tools as MCP resources, each with auto-generated JSON schemas derived from the Pydantic signatures. External MCP clients connect via the standard MCP transport (stdio or HTTP), authenticate via JWT, and discover available tools through the MCP list-tools protocol. This configuration enables a clean separation between tool definition in Agno SDK code and tool consumption by any compliant client, making Agno a viable backbone for heterogeneous multi-vendor agent ecosystems. Configuration files—typically agentos.yaml—specify model providers, database connection strings, RBAC policies, vector store backends, and deployment targets in a single declarative artifact that can be version-controlled and reviewed.
agno is well-suited for Enterprise MCP tool registries exposing internal APIs, databases, and document stores as standardized, governed, RBAC-protected resources consumable by any compliant agent client, Long-term agent memory with user-scoped persistent state across sessions, enabling support, research, and coding agents that accumulate context over time, Multi-agent orchestration via the Team primitive with typed message contracts, supporting structured prompt pipelines and specialized agent handoffs, Autonomous multimodal workflows combining vision-language inputs, browser automation, and Docker-sandboxed tool execution within a unified, observable runtime. With an overall rating of 4.8/5, it offers strong community activity, reliable performance, and easy integration with existing AI pipelines.
Production readiness is Agno's strongest practical dimension. The Postgres-backed persistence model provides ACID guarantees for session state and memory—critical for any agent workflow with regulatory, compliance, or audit requirements. JWT-based RBAC, enforced at the FastAPI gateway, supports multi-tenant deployments where different teams or customers share infrastructure with isolated data planes. OpenTelemetry-compatible trace emission integrates with existing observability stacks including Datadog, Honeycomb, and Grafana Tempo, avoiding the proprietary telemetry lock-in characteristic of managed agent platforms. The Docker-first deployment topology aligns with mainstream DevOps practice, and the curated AWS template provides a credible path to production scale without requiring Kubernetes expertise or a dedicated platform engineering team. Latency and scalability considerations are more nuanced. AgentOS introduces a service layer between agent logic and LLM providers, adding modest overhead—typically 10 to 30 milliseconds per request for session hydration, RBAC checks, and trace persistence—that is negligible relative to LLM inference latency but accumulates in high-throughput scenarios. Postgres as the unified backing store simplifies operations but creates a potential bottleneck for high-volume trace writes; teams operating at scale should consider table partitioning strategies, connection pooling tuning, or offloading cold traces to object storage. Token budget management remains developer-disciplined—Agno exposes token usage metadata in RunResponse objects but does not enforce hard ceilings, requiring teams to implement budget guards and circuit breakers at the application or gateway layer. Caveats include debugging overhead inherent to any multi-agent framework: traces span LLM calls, tool executions, memory reads, knowledge retrieval, and inter-agent message passing, requiring the AgentOS UI or equivalent observability tooling to reconstruct execution flows. Sandboxing security is Docker-dependent—adequate for most enterprise workloads but insufficient for hostile multi-tenant scenarios requiring gVisor, Firecracker, or Kata Containers-level isolation. The framework's breadth imposes a learning curve: developers must internalize SDK semantics, AgentOS topology, MCP conventions, and the relational memory model simultaneously before achieving productive velocity. Finally, the rapid iteration pace—evidenced by the Phidata-to-Agno transition and frequent SDK releases—means API stability should be evaluated carefully, with pinning and migration testing, before committing to large-scale production deployments.
Minimal tool for running large language models locally