The agent frameworkloved by coding agents
Build agents, multi-agent teams and multi-step workflows using coding agents
- 41K GitHub stars
- 2M+ / month
- Fortune 5 customers
- SOC 2 compliant
Start with a primitive
Choosing the right orchestrator is half the job. Start with an agent, turn it into a team when scope expands or a workflow when you need step-by-step control
from agno.agent import Agentfrom agno.tools.finance import FinanceToolsagent = Agent( name="Finance Agent", model="openai:gpt-5.6", tools=[FinanceTools()], instructions="Lead with the answer, then show the evidence.",)agent.print_response("Give me a market brief on NVIDIA", stream=True)$ uv run agent.pyAgent
Start with a model with tools and instructions. Add storage, memory, knowledge and more as needed
from agno.agent import Agentfrom agno.tools.finance import FinanceToolsagent = Agent( name="Finance Agent", model="openai:gpt-5.6", tools=[FinanceTools()], instructions="Lead with the answer, then show the evidence.",)agent.print_response("Give me a market brief on NVIDIA", stream=True)$ uv run agent.pyTeam
Orchestrate a team of agents in four modes: coordinate, route, broadcast and tasks
from agno.agent import Agentfrom agno.team import Teamfrom agno.team.mode import TeamModeenglish = Agent(name="English Agent", role="Responds in English")chinese = Agent(name="Chinese Agent", role="Responds in Chinese")german = Agent(name="German Agent", role="Responds in German")dutch = Agent(name="Dutch Agent", role="Responds in Dutch")germanic = Team(name="Germanic Team", members=[german, dutch])team = Team( name="Language Router Team", mode=TeamMode.route, members=[english, chinese, germanic], model="openai:gpt-5.6",)team.print_response("Wie funktionieren Agenten?", stream=True)$ uv run team.pyWorkflow
Run agents, teams or regular code in steps with branches, loops, conditions and parallel execution
from agno.agent import Agentfrom agno.team import Teamfrom agno.tools.finance import FinanceToolsfrom agno.workflow import Parallel, Workflowresearcher = Agent(name="Researcher Agent", tools=[FinanceTools()])bull = Agent(name="Bull", role="Make the case for investing")bear = Agent(name="Bear", role="Make the case against")debate = Team(name="Debate Team", members=[bull, bear])report = Agent(name="Report Agent", role="Writes the investment brief")workflow = Workflow( name="Investment Workflow", steps=[researcher, Parallel(bull, bear), debate, report],)workflow.print_response("Should we invest in NVIDIA?", stream=True)$ uv run workflow.pyAdd tools
Connect your agents to 100+ applications like GitHub, Slack, Postgres and more. Any integration you want is already there or one email to our team away
Add capabilities
Give your agents capabilities like session management, memory, knowledge, learning and more. Stack capabilities using a composable API
Session management
Store sessions, runs and messages in your agent's database. Resume where you left off.
agent = Agent( model="openai:gpt-5.6", db=SqliteDb(db_file="tmp/agent.db"), add_history_to_context=True, num_history_runs=3,)Memory
Extracts facts about each user and stores them, so new sessions start already knowing them.
agent = Agent( model="openai:gpt-5.6", db=SqliteDb(db_file="tmp/agent.db"), enable_agentic_memory=True, memory_manager=MemoryManager( additional_instructions="Capture goals and preferences.", ),)Knowledge
Turns files, URLs and text into a searchable vector store the agent queries when it needs to.
agent = Agent( model="openai:gpt-5.6", knowledge=Knowledge( vector_db=PgVector( table_name="docs", db_url="postgresql+psycopg://ai:ai@localhost:5532/ai", ), ), search_knowledge=True,)Learning
The agent learns as it runs, filling stores for profiles, context, entities and knowledge.
agent = Agent( model="openai:gpt-5.6", db=SqliteDb(db_file="tmp/agent.db"), learning=LearningMachine( user_profile=UserProfileConfig(mode=LearningMode.ALWAYS), user_memory=UserMemoryConfig(mode=LearningMode.AGENTIC), session_context=SessionContextConfig(enable_planning=True), entity_memory=EntityMemoryConfig(), ),)Context providers
Exposes apps, folders and databases as context via sub-agents. No juggling tools.
fs = FilesystemContextProvider(root="docs/", id="docs")agent = Agent( model="openai:gpt-5.6", tools=fs.get_tools(), instructions=fs.instructions(),)Wiki
A wiki your agent reads and writes, backed by markdown files, a git repo or Notion.
wiki = WikiContextProvider( backend=FileSystemBackend(path="wiki/"),)agent = Agent( model="openai:gpt-5.6", tools=wiki.get_tools(), instructions=wiki.instructions(),)FileSystem
A private filesystem in your database, whatever one run writes the next can read.
fs = FileSystem(SqliteDb(db_file="tmp/agno.db"))agent = Agent( model="openai:gpt-5.6", tools=[fs.tools()], instructions=[fs.instructions()],)Human in the loop
Flagged tools pause the run for approval, then continue where they stopped.
@tool(requires_confirmation=True)def issue_refund(order_id: str) -> str: ...agent = Agent( model="openai:gpt-5.6", tools=[issue_refund],)run = agent.run("Refund order #4521")run.active_requirements[0].confirm()agent.continue_run(run_id=run.run_id, requirements=run.requirements)Checkpointing
Run state persists after every tool batch, so a crash costs one batch, not the run.
agent = Agent( model="openai:gpt-5.6", db=SqliteDb(db_file="tmp/agents.db"), checkpoint="tool-batch",)agent.continue_run(run_id=run_id, session_id=session_id)Skills
Folders of instructions and scripts the agent pulls in only when a task calls for them.
agent = Agent( model="openai:gpt-5.6", skills=Skills(loaders=[LocalSkills("skills/")]),)Session state
A dict of durable state, templated into instructions and updated from tools.
agent = Agent( model="openai:gpt-5.6", db=SqliteDb(db_file="tmp/agents.db"), session_state={"shopping_list": []}, instructions="The shopping list is: {shopping_list}",)Structured output
Answers arrive as a validated Pydantic instance, not free text you have to parse.
agent = Agent( model="openai:gpt-5.6", output_schema=StockAnalysis,)analysis = agent.run("Analyze NVIDIA").contentanalysis.recommendationMultimodal
Pass images, audio or files straight into the run call, whatever the provider needs.
agent = Agent(model="openai:gpt-5.6")response = agent.run( "Describe what you see and hear", images=[Image(url="https://example.com/golden-gate.jpg")], audio=[Audio(content=audio_bytes)],)Guardrails
Pre and post hooks screen inputs and outputs, catching PII and prompt injection.
agent = Agent( model="openai:gpt-5.6", pre_hooks=[ PIIDetectionGuardrail(mask_pii=True), PromptInjectionGuardrail(), ], post_hooks=[validate_response_quality],)Compression
Older tool results get compressed once they crowd the context, keeping facts, not dumps.
agent = Agent( model="openai:gpt-5.6", compress_tool_results=True, compression_manager=CompressionManager(compress_token_limit=5000),)50+ model providers and infinite capabilities, behind one API.
Go live with AgentOS
Turn your agents into an API and MCP with AgentOS
Serve your agents using AgentOS
AgentOS is a high-performance runtime that provides an execution environment and context layer for your agents. It serves them as an API and MCP, providing durability, tracing, scheduling and observability out of the box.
Learn about AgentOSagent_os = AgentOS( db=db, agents=[product_copilot, sales_agent], teams=[customer_ops, research_team], workflows=[invoice_processor, weekly_digest], tracing=True, scheduler=True, mcp_server=True, authorization=True,)app = agent_os.get_app()if __name__ == "__main__": agent_os.serve(app="agentos:app")Secure, durable and observable
Secure: Every endpoint sits behind JWT-based authorization. Service accounts and RBAC provide agent and tool level access control.
Durable: Runs execute on durable queues and survive disconnects, restarts and crashes. Sessions and state persist in your database.
Observable: Tracing, session history, metrics and audit logs provide deep observability into your system. All data lives in your database.
Extreme performance by default
Agno agents start 342× faster than LangGraph and 5,736× faster than CrewAI, and use 27.8× less memory than LangGraph and 4.5× less than CrewAI.
Engineers and agents love Agno
Agno is the robust, well-documented, and scalable agent deployment framework I've been looking for.
It's so flexible. Any model, any tool sets, any MCP server — it just works.
Adam Shedivy
Staff Software Developer at IBM
The documentation was just so well done. It was some of the best documentation I've ever seen in a piece of tech.
Darren Haligas
VP of Engineering at Key Data
Agno has been a reliable core runtime for our conversational agents, RAG agents, and team-of-agents architectures used for multi-agent orchestration.
We stopped writing plumbing code and started writing business logic. That's the real win.
Igor Lessio
Chief Technology Officer at Datai Network
We can start an idea at the beginning of the week and have it into production by the end of the week with evals in place.
Bogdan Rau
Founder & CEO at Thinqpoint
Frequently asked questions
Agno is a Python SDK for building agent platforms. It gives you three primitives (agents, teams and workflows), 100+ toolkits, and a large set of capabilities you can attach to them.
Yes. The Agno SDK is licensed as Apache 2.0. Please read the license for more details.
Yes, the SDK is Python 3.9 and up. But this is just the backend language. The agents you build are served over standard APIs and MCP, so your clients built in any language can call them. Python is the perfect language for a backend that can serve any frontend.
Agno leans into the patterns that make coding agents successful. The API is small, consistent and composable. The docs are served over MCP so coding agents can query them. Every capability is a keyword argument and Agno handles the wiring underneath. All you need to do is describe the system you want and your coding agent can assemble it for you without much trouble.
Think of an agent as a domain-specific expert, built with a model, tools and instructions for that particular task. A team is a group of agents working together, letting you expand the scope in a deterministic manner (specialized agents in the team handle their domains). A workflow is a multi-step process running agents, teams and functions step by step. Start with an agent and reach for a team or workflow when the task calls for it.
Agno brings you four multi-agent orchestration patterns: coordinate, route, broadcast and tasks. In coordinate mode the team leader breaks work down and delegates it to the respective agents. In route mode the leader hands the task to the one specialist that owns it. In broadcast mode every member gets the same task and the leader synthesizes their answers. In tasks mode the leader splits the request into a task list and runs it through to completion.
A workflow is a multi-step process made of Steps that are orchestrated sequentially, in parallel, in a loop or branched and routed on conditions. Each step can be an agent, a team, a nested workflow or a regular Python function. The best part is that you can simply drop agents, teams, workflows or functions in as a step and Agno handles the rest.
Agno provides over 100 built-in toolkits, from web search to databases to finance. Any Python function works as a tool, and agents can call MCP servers directly. If you find a toolkit that’s not available, create a GitHub issue or email us at support@agno.com and we’ll get it built out quickly.
Agno gives you 47 providers behind one API, including Anthropic, OpenAI, Google, AWS, Azure, Groq, Mistral and local runtimes like Ollama. You can pass a model as a string or a model class for more control. Fallback models are also supported and building your own model class is straightforward.
They are complementary. A gateway gives you one choke point that all your traffic flows through, so think of it as traffic control. The unified model API lets you hit the provider endpoints directly and skip the network hop a gateway adds. Both have their own purpose and sit well together in production.
Agno supports over 20 vector databases, including pgvector, Qdrant, Milvus, Weaviate and LanceDB. The Agno Knowledge class turns files, URLs and text into a searchable knowledge base your agent can query as needed.
No. You can run the SDK as regular Python. AgentOS helps you serve your agent platform using a secure FastAPI runtime, but you are free to use the SDK as is.
Yes. The SDK and AgentOS are Apache 2.0 and free to use. You run AgentOS in your own cloud. Paid plans are only for live control plane features. Please see the pricing page for more details.
Yes. Agno has deep, built-in support for human in the loop and admin approvals. The key difference is that human in the loop gives control to the user, but admin approval workflows give control to the admins. You can flag a tool to require user confirmation before it executes, to pause for user input or to have execution handled outside Agno. You can also mark a tool as requiring an approval that leaves an audit record.
Get started by signing up on os.agno.com.