feat(blog): add Agno Agent Framework review post (#13)

* feat(blog): add Agno Agent Framework review post

* chore(blog): remove unused image

* chore: add English translations for PR #13

Author: ppippi-dev

public/img/agno/image-20260101180709381.png

@@ -0,0 +1,341 @@
+---
+description: 'Hands-on review of the Agno Agent Framework: performance, architecture,
+  and a minimal API for building AI agents with Memory, Knowledge (RAG), MCP, Teams,
+  and AgentOS.'
+pubDate: '2026-01-01'
+tags:
+- Agno
+- LLMOps
+- Agent
+title: 'Agno Agent Framework Review: Fast, Minimal AI Agents'
+---
+
+## Summary
+
+This post is a hands-on review of the Agno Agent Framework, based on my own usage, focusing on its architecture, performance, and design philosophy.
+
+- Agno’s emphasis on fast instantiation and memory optimization
+- A structure that lets you build Agents, Tools, Memory, and even a UI with minimal code
+- Multi-Agent (Teams), Knowledge, and Memory design patterns
+- The AgentOS-based runtime model and how it integrates with MCP
+
+If you’ve used agent frameworks like LangGraph or CrewAI, or you’re thinking through agent infrastructure for production, this should be useful context.
+
+## TL;DR
+
+Agno is an AI agent framework optimized for performance and simplicity.  
+With minimal code, you can wire up Agents, Memory, MCP, Multi-Agent, and even a UI, and it’s designed with instantiation speed and memory efficiency as first-class priorities.
+
+As of January 1, 2026, Agno is a popular agent framework with about 36.5k GitHub stars. Over the last few days, I built several agents using Agno and wanted to share what I learned and how the framework is structured. With so many agent tools out there, Agno stands out as a tool worth evaluating—especially for performance and simplicity.
+
+## Agno Agent Framework’s Performance Approach
+
+### Benchmark results
+
+According to the [performance benchmark](https://docs.agno.com/get-started/performance#results) Agno published in October 2025, results measured on an Apple M4 MacBook Pro show strong instantiation speed and memory usage compared to other agent frameworks. It includes a claim of being up to 529x faster than LangGraph-based agents, and says memory usage is also efficiently optimized.
+
+![image-20260101180709381](../../../public/img/agno/image-20260101180709381.png)
+
+### Questions about instantiation time
+
+The benchmark measures how long it takes to instantiate an agent. In environments where servers are always running, this may not matter much. But in serverless architectures—or when you need session-scoped instantiation for security reasons—it can be an important factor. Honestly, “it’s faster” sounds great when you’re building agent systems, but in my personal view the LLM itself is so slow that you don’t always feel this difference strongly.
+
+### Agno’s optimization strategy
+
+Agno says it optimizes across agent performance, system performance, and reliability/accuracy. In particular, it’s designed to improve speed by making instantiation, memory space management, tool calls, memory updates, and logging more efficient. It also runs memory asynchronously to prevent system memory leaks. Another key trait is a stateless architecture designed to scale horizontally.
+
+## Agno Agent Framework’s Simple Design
+
+The Agno docs say you can build a complete agent with memory and state in 25 lines of code. They also emphasize how easy it is to bring up a server as a FastAPI app.
+
+```python
+from agno.agent import Agent
+from agno.db.sqlite import SqliteDb
+from agno.models.anthropic import Claude
+from agno.os import AgentOS
+from agno.tools.mcp import MCPTools
+
+# Create the Agent
+agno_agent = Agent(
+    name="Agno Agent",
+    model=Claude(id="claude-sonnet-4-5"),
+    # Add a database to the Agent
+    db=SqliteDb(db_file="agno.db"),
+    # Add the Agno MCP server to the Agent
+    tools=[MCPTools(transport="streamable-http", url="https://docs.agno.com/mcp")],
+    # Add the previous session history to the context
+    add_history_to_context=True,
+    markdown=True,
+)
+
+# Create the AgentOS
+agent_os = AgentOS(agents=[agno_agent])
+# Get the FastAPI app for the AgentOS
+app = agent_os.get_app()
+```
+
+This code includes:
+
+- Agent definition
+- LLM model selection
+- DB-backed history management
+- MCP Tool integration
+- FastAPI server exposure
+
+Being able to build and run an agent server with so little code is one of Agno’s biggest advantages.
+
+Based on the code above, let’s look at the key building blocks of an Agno agent.
+
+### Choosing an LLM model
+
+Choosing an LLM defines how the agent calls the model to perform its core functions. Agno supports many models via its own model wrappers, and it calls models directly rather than going through LiteLLM. You can find the supported model list in the [official docs](https://docs.agno.com/integrations/models/model-index).
+
+### Defining an agent
+
+Agent definition is where you set the agent’s responsibilities and behavioral guidelines. You can specify a simple name and an `instructions` prompt to clarify the agent’s role, and you can also configure a `role` for multi-agent setups.
+
+```python
+agent = Agent(
+    name="test_agent",
+    model=OpenAIChat(id="gpt-5-nano"),
+    role="You are a test agent.",
+    instructions="You are a test agent. You are tasked with testing the agent's functionality. You will be given a task and you will need to complete it.",
+)
+```
+
+### DB: History management
+
+History management helps the agent remember and reuse prior conversations. Agno supports DB-backed history with very little configuration. From my experience implementing this manually in other frameworks, the fact that Agno makes history this straightforward feels like a major advantage.
+
+```python
+Agent(...,
+      db=SqliteDb(db_file="agno.db"),
+      add_history_to_context=True,
+)
+```
+
+### Tool integration
+
+You can easily connect tools like MCP so the agent can interact with external systems.
+
+```python
+Agent(...,
+      tools=[MCPTools(transport="streamable-http", url="https://docs.agno.com/mcp")],
+)
+```
+
+Memory and Knowledge can be added in a similarly simple way. I’ll cover those in more detail shortly.
+
+## Built-in UI
+
+When you run an agent, Agno provides a UI you can use immediately. After launching the server as a FastAPI app, you can connect your local port to Agno’s hosted UI at https://os.agno.com/chat.
+
+```python
+import os
+
+from settings import settings
+
+os.environ["OPENAI_API_KEY"] = settings.OPENAI_API_KEY
+
+from agno.models.openai import OpenAIChat
+from agno.tools.hackernews import HackerNewsTools
+from agno.os import AgentOS
+from agno.agent import Agent
+
+agent = Agent(
+    model=OpenAIChat(id="gpt-5-nano"),
+    tools=[HackerNewsTools()],
+    instructions="Write a report on the topic. Output only the report.",
+    markdown=True,
+)
+
+# Create the AgentOS
+agent_os = AgentOS(agents=[agent])
+# Get the FastAPI app for the AgentOS
+app = agent_os.get_app()
+```
+
+If you run this with a FastAPI dev server, you can test the agent easily through the UI. This is especially useful for quickly validating an agent before production, or when you need to share results with non-developers.
+
+![image-20260101225757855](../../../public/img/agno/image-20260101225757855.png)
+
+## Multi-Agent Framework – Agno Teams
+
+In Agno, multi-agent composition is provided as a unit called `Teams`. A Team groups multiple agents and orchestrates them based on roles. In other words, agents inside a Team can split work and collaborate based on their assigned responsibilities.
+
+```python
+import os
+
+from settings import settings
+
+os.environ["OPENAI_API_KEY"] = settings.OPENAI_API_KEY
+
+from agno.agent import Agent, RunOutput
+from agno.models.openai import OpenAIChat
+from agno.team import Team
+from agno.utils.pprint import pprint_run_response
+
+# Research Agent: Gathers and analyzes information on given topics
+research_agent = Agent(
+    name="Research Agent",
+    role="Research Specialist",
+    instructions="You are a research specialist. Gather comprehensive information, analyze data, and provide well-structured research findings on the given topic.",
+    markdown=True,
+)
+
+# Writer Agent: Creates content based on research findings
+writer_agent = Agent(
+    name="Writer Agent",
+    role="Content Writer",
+    instructions="You are a professional content writer. Create engaging, well-structured content based on the research provided. Focus on clarity and readability.",
+    markdown=True,
+)
+
+# Create the team
+team = Team(
+    name="Content Creation Team",
+    members=[research_agent, writer_agent],
+    model=OpenAIChat(id="gpt-5-nano"),
+    instructions="You coordinate the research and writing process. First, delegate research tasks to the Research Agent, then pass findings to the Writer Agent for content creation.",
+    markdown=True,
+)
+
+# Run agent and return the response as a variable
+response: RunOutput = team.run("Write a 3-paragraph blog post about the benefits of multi-agent AI systems")
+
+# Print the response in markdown format
+pprint_run_response(response, markdown=True)
+```
+
+With a small amount of code, you can build a multi-agent setup that supports role-based delegation and collaboration.
+
+![image-20260101230908515](../../../public/img/agno/image-20260101230908515.png)
+
+## Knowledge & Memory – Designing Agno Agents
+
+Let’s look at Memory and Knowledge, which are core components that significantly affect agent performance.
+
+### Memory
+
+Memory acts as context storage, allowing the agent to retain and reuse information learned during conversations or tasks. Agno provides two main memory approaches.
+
+| Category | Automatic Memory | Agentic Memory |
+|---|---|---|
+| Enable option | `enable_user_memories=True` | `enable_agentic_memory=True` |
+| Behavior | Automatically creates, stores, and updates memories during conversation | The agent decides what to store and selectively saves only relevant information |
+
+Example – Automatic Memory:
+
+```python
+from agno.agent import Agent
+from agno.db.sqlite import SqliteDb
+
+db = SqliteDb(db_file="agno.db")
+
+agent = Agent(
+    db=db,
+    enable_user_memories=True,
+)
+
+agent.print_response("My name is Sarah and I prefer email over phone calls.")
+agent.print_response("What's the best way to reach me?")
+```
+
+Example – Agentic Memory:
+
+```python
+from agno.agent import Agent
+from agno.db.sqlite import SqliteDb
+
+db = SqliteDb(db_file="agno.db")
+
+agent = Agent(
+    db=db,
+    enable_agentic_memory=True,
+)
+```
+
+Agno supports not only SQLite but also various databases such as PostgreSQL, and of course you can manually retrieve memories.
+
+```python
+from agno.agent import Agent
+from agno.db.postgres import PostgresDb
+
+db = PostgresDb(
+    db_url="postgresql://user:password@localhost:5432/my_database",
+    memory_table="my_memory_table",
+)
+
+agent = Agent(db=db)
+
+agent.print_response("I love sushi!", user_id="123")
+
+memories = agent.get_user_memories(user_id="123")
+print(memories)
+```
+
+### Knowledge
+
+Knowledge serves as a knowledge base built from external information or documents, and it’s primarily used to build RAG systems.
+
+```python
+import asyncio
+
+from agno.agent import Agent
+from agno.db.postgres.postgres import PostgresDb
+from agno.knowledge.embedder.openai import OpenAIEmbedder
+from agno.knowledge.knowledge import Knowledge
+from agno.vectordb.pgvector import PgVector
+
+db = PostgresDb(
+    db_url="postgresql+psycopg://ai:ai@localhost:5532/ai",
+    knowledge_table="knowledge_contents",
+)
+
+knowledge = Knowledge(
+    name="Basic SDK Knowledge Base",
+    description="Agno 2.0 Knowledge Implementation",
+    contents_db=db,
+    vector_db=PgVector(
+        table_name="vectors",
+        db_url="postgresql+psycopg://ai:ai@localhost:5532/ai",
+        embedder=OpenAIEmbedder(),
+    ),
+)
+
+asyncio.run(
+    knowledge.add_content_async(
+        name="Recipes",
+        url="https://agno-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf",
+        metadata={"user_tag": "Recipes from website"},
+    )
+)
+
+agent = Agent(
+    name="My Agent",
+    description="Agno 2.0 Agent Implementation",
+    knowledge=knowledge,
+    search_knowledge=True,
+)
+
+agent.print_response(
+    "How do I make chicken and galangal in coconut milk soup?",
+    markdown=True,
+)
+```
+
+The code above is an example from the Agno docs. The Knowledge feature can look a bit complex, but it’s impressive that you can build a RAG system with code like this.
+
+## Closing thoughts
+
+Agno is an agent framework with broad capabilities: fast instantiation, memory efficiency, a simple API, and multi-agent support.  
+It’s especially well-suited for teams that want to stand up production-grade agent infrastructure quickly with minimal code.
+
+Beyond the features mentioned here, the Agno Agent Framework supports a wide range of components most agent systems need.  
+It’s unlikely you’ll get blocked due to missing features, and the framework’s strength is that it stays simple while still leaving enough room for customization.
+
+It also feels natural that Agno expands this system under the concept of AgentOS.  
+The direction is clear: it’s aiming to cover not just an SDK, but the runtime environment as well. In that same context, it also makes sense that it offers a (paid) cloud option.
+
+With so many agent SDKs and frameworks emerging, it’s hard to say exactly where Agno will land long-term.  
+Still, if you look at structure, performance, and simplicity, it’s clearly an agent framework worth paying attention to right now.