Agno — AI Native Crash Course

TL;DR — Agno (formerly Phidata) is a lightweight Python framework for building model-agnostic agents. Agents instantiate in microseconds with zero overhead. It supports all major providers, has built-in tools (web search, file I/O, SQL, APIs), vector-backed knowledge bases, persistent memory, and a team abstraction for multi-agent coordination. Designed to be fast, simple, and production-ready without a heavy framework tax.

What it is

Agno gives you one Agent class. Pass it a model, tools, knowledge, and instructions — it handles the tool-calling loop, memory, and structured output. Agents can work in teams with a leader that delegates tasks. No graph DSL, no chain abstractions — just Python classes with sensible defaults.

Why it exists

LangChain has too much surface. LangGraph requires graph thinking. Agno's bet: you should be able to build a production agent in 10 lines of Python with near-zero initialization overhead. It grew out of Phidata's infrastructure tooling and keeps that pragmatic, "just make it work" philosophy.

Install & setup

pip install agno
export OPENAI_API_KEY=sk-...

Basic agent

from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    instructions=["You are a helpful assistant."],
    markdown=True,
)

agent.print_response("What is vLLM?", stream=True)

Tools

from agno.agent import Agent
from agno.tools.duckduckgo import DuckDuckGoTools

agent = Agent(
    model=OpenAIChat(id="gpt-4o"),
    tools=[DuckDuckGoTools()],
    instructions=["Always include sources."],
    show_tool_calls=True,
)

agent.print_response("Search for recent vLLM updates")

Knowledge bases

from agno.agent import Agent
from agno.knowledge.pdf import PDFKnowledgeBase
from agno.vectordb.pgvector import PgVector

knowledge = PDFKnowledgeBase(
    path="docs/",
    vector_db=PgVector(table_name="docs", db_url="postgresql://..."),
)
knowledge.load()

agent = Agent(knowledge=knowledge, search_knowledge=True)

Structured output

from pydantic import BaseModel

class MovieReview(BaseModel):
    title: str
    rating: float
    summary: str

agent = Agent(model=OpenAIChat(id="gpt-4o"), response_model=MovieReview)
review = agent.run("Review the movie Inception")
print(review.content)  # MovieReview object

Teams

from agno.agent import Agent
from agno.team import Team

researcher = Agent(name="Researcher", role="Research topics", tools=[DuckDuckGoTools()])
writer = Agent(name="Writer", role="Write summaries")

team = Team(
    agents=[researcher, writer],
    instructions=["Research first, then write."],
    show_tool_calls=True,
)
team.print_response("Write a summary of PagedAttention")

When to use, when to skip

Use it when you want a lightweight, fast-to-start agent framework without heavy abstractions. Great for API backends, chatbots, and data processing pipelines where you want agents that initialize in microseconds.

Skip it when you need complex graph-based control flow (LangGraph), rich middleware (LangChain v1), or established multi-agent conversation patterns (AutoGen).

vs the alternatives

Tool	Best for	Trade-off
Agno	Fast, lightweight, pragmatic agents	Smaller community
LangChain	Rich ecosystem, middleware, integrations	Heavier
Pydantic AI	Type-safe, test-friendly agents	Less built-in tooling
Smolagents	Code-first, minimal	Less production features

Verified against Agno docs (docs.agno.com), May 2026.

Agno — lightweight, model-agnostic agents in pure Python.