◆ AI Agent Frameworks

Agno

v3.0.4 open-source

Build, run, and manage agent platforms.

source ↗ website ↗ rss ↗ last repo push Aug 22, 2026

from agno.tools.knowledge import KnowledgeManagementTools

km_tools = KnowledgeManagementTools(
    knowledge_base=my_kb,
    ingest_url=True,
    ingest_text=True,
    ingest_path=True,   # opt-in: exposes any path the server process can read
    remove_content=False,
)
from agno.agent import Agent
from agno.tools.knowledge import KnowledgeManagementTools

agent = Agent(
    tools=[KnowledgeManagementTools(scope="shared")],
)
agent.print_response("Ingest https://docs.agno.com and list all loaded pages.", stream=True)
curl -X POST https://<agentos-host>/knowledge/content/<id>/refresh
curl 'https://<agentos-host>/knowledge/content?parent_id=<parent_id>'
from agno.agent import Agent
from agno.tools.wavespeed import WaveSpeedTools

agent = Agent(
    tools=[WaveSpeedTools(poll_interval=2, timeout=60)],
    markdown=True,
)
agent.print_response("Generate an image of a futuristic city at night", stream=True)
from agno.agent import Agent
from agno.tools.atomicmail import AtomicMailTools

agent = Agent(
    tools=[AtomicMailTools(pow_timeout=300)],
    markdown=True,
)
agent.print_response("Register me an inbox, then check for any new messages.", stream=True)
from agno.tools.pubmed import PubmedTools
from agno.agent import Agent

agent = Agent(
    tools=[PubmedTools(timeout=10)],
)
agent.print_response("Latest research on CRISPR gene editing", stream=True)
from agno.tools.studio_runner import StudioRunnerTools

router = Agent(
    name="Router",
    tools=[StudioRunnerTools()],
    ...
)
from agno.tools.studio_runner import StudioRunnerTools
from agno.agent import Agent

router = Agent(
    name="router",
    tools=[StudioRunnerTools()],
    instructions="Dispatch user requests to the appropriate Studio component.",
)
from agno.tools.smallest import SmallestTools
from agno.agent import Agent

agent = Agent(tools=[SmallestTools(voice_id='<voice_id>', model='lightning_v3.1', output_file='output.wav')])
agent.run('Convert this text to speech: Hello from Agno!')
curl -X POST 'http://localhost:8000/metrics/refresh?background=true'
# Then poll until completed:
curl 'http://localhost:8000/metrics/refresh/status'
from agno.vectordb.opensearch import OpenSearch

vectordb = OpenSearch(
    host='localhost',
    port=9200,
    index='my-index',
    search_type='hybrid'
)
import time
from agentos_client import AgentOSClient

client = AgentOSClient()
client.post("/metrics/refresh?background=true")

while True:
    status = client.get_metrics_refresh_status()
    if status["state"] in ("completed", "failed"):
        print(status)
        break
    time.sleep(2)
from agno.models.moonshot import Moonshot

model = Moonshot(use_thinking=True)
agent = Agent(model=model)
agent.print_response('Analyze the security implications of this architecture')
from agno.agent import Agent
from agno.tools.agentos import AgentOSTools

ops_agent = Agent(
    tools=[AgentOSTools()],
    instructions="You are a platform operations assistant. Use AgentOSTools to answer questions about agent health, schedules, and pending approvals.",
)

if __name__ == "__main__":
    ops_agent.print_response("Show me any pending approvals and recent failures.", stream=True)
from agno.agent import Agent
from agno.models.moonshot import Moonshot

agent = Agent(
    model=Moonshot(id="kimi-k3", use_thinking=True),
    instructions="Reason step by step before answering.",
)

if __name__ == "__main__":
    agent.print_response("Explain the trade-offs between RAG and fine-tuning.", stream=True)
slack_agent = Agent(
    tools=[SlackTools(respond_to_other_agents=True)],
    ...
)
learning_store = LearningStore(
    extraction_tool_call_limit=5,
    ...
)
from agno.agent import Agent
from agno.tools.slack import SlackTools

agent = Agent(
    tools=[SlackTools(respond_to_other_agents=True)],
)
agent.print_response('Check if any peer agents have posted updates in #alerts', stream=True)
from agno.learning import LearningStore

store = LearningStore(
    extraction_tool_call_limit=10,
)
results.to_sft_jsonl("passing_attempts.jsonl")
from agno.agent import Agent
from agno.tools.superserve import SuperserveTools

agent = Agent(tools=[SuperserveTools()])
agent.print_response('Write and execute a Python script that processes this dataset')
from agno.agent import Agent
from agno.tools.plivo import PlivoTools

agent = Agent(tools=[PlivoTools()])
agent.print_response('Send an SMS to +15551234567 saying the nightly scan is complete')
from agno.agent_os import AgentOS

agent_os = AgentOS(mcp_auth=...)
uvx agno connect --name ci-bot
agno tokens revoke agno_pat_abc123xyz
from agno.tools.twelvelabs import TwelveLabsTools

tools = TwelveLabsTools()
agent = Agent(tools=[tools])
from agno.tools.local_file_system import LocalFileSystemTools

tools = LocalFileSystemTools(
    target_directory="/data/agent-workspace",
    enable_read_file=True,
    restrict_to_base_dir=True,
)
from agno.models.litellm import LiteLLM

model = LiteLLM(
    model="openai/gpt-4o",
    supports_native_structured_outputs=True,
)
from agno.models.openai import OpenAIChat
from agno.agent import Agent

agent = Agent(model=OpenAIChat(id="gpt-4o"))
response = agent.run("What happened in AI news today?")
print(response.citations)
from agno.guardrails import PIIDetectionGuardrail

guardrail = PIIDetectionGuardrail(
    custom_patterns=[r'\b\d{3}-\d{2}-\d{4}\b', r'\bACCT-\d{8}\b']
)
from agno.agent import Agent
from agno.tools.you import YouTools

agent = Agent(tools=[YouTools()], show_tool_calls=True)
agent.print_response('What are the latest AI model releases this week?')
def my_post_hook(run_response):
    approval = run_response.metadata.get("approval")
    if approval:
        print(approval["resolved_by"], approval["resolved_at"])
from agno.utils.path_safety import safe_join, PathSecurityError

try:
    safe_path = safe_join("/var/app/uploads", user_input_filename)
except PathSecurityError as e:
    print(f"Blocked unsafe path: {e}")
from agno.models.gemini import GeminiInteractions

model = GeminiInteractions()
from agno.knowledge.url import URLKnowledgeBase

kb = URLKnowledgeBase(
    urls=["https://docs.example.com/sitemap.xml"],
    allowed_hosts=["docs.example.com"],
)
from agno.tools.llms_txt import LLMsTxtTools

tools = LLMsTxtTools(allowed_hosts=["docs.example.com", "api.example.com"])
from agno.context.slack import SlackContextProvider

provider = SlackContextProvider(enable_media_tools=True)
from agno.context.slack import SlackContextProvider

provider = SlackContextProvider(enable_workspace_search=True)
context = provider.get_context()
from agno.models.anthropic import Claude

model = Claude(id="claude-opus-4-5", cache_tools=True)
import os
from agno.agent import Agent
from agno.tools.web_context import WebContextProvider
from agno.tools.mcp.parallel import ParallelMCPBackend

os.environ["PARALLEL_API_KEY"] = "<your-key>"

agent = Agent(
    tools=[WebContextProvider(backend=ParallelMCPBackend())]
)
curl -X GET 'https://<agentOS-host>/sessions?type=workflow' \
  -H 'Authorization: Bearer <token>'
AGNO_LOG_TRACEBACKS=true python my_agent.py
from agno.memory import SessionSummaryManager

summary_manager = SessionSummaryManager(
    last_n_runs=10,
    conversation_limit=4000
)
agent = Agent(
    model=OpenAIChat(id="gpt-4o", base_url="http://localhost:1/v1", retries=0),
    fallback_models=[Claude(id="claude-sonnet-4-20250514")],
)
from agno.interface.slack import SlackInterface

slack = SlackInterface(
    agent=my_agent,
    show_member_tool_calls=True,
)
workflow.run(
    metadata={"run_label": "nightly"},
    dependencies={"db": my_db_client},
    add_dependencies_to_context=True,
    add_session_state_to_context=True
)
from agno.models.gemini import Gemini

model = Gemini(id="gemini-2.0-flash", timeout=30)
agent = Agent(
    model=...,
    datetime_format="%Y-%m-%dT%H:%M:%S"
)
def my_pre_hook(run_context, tool_call):
    history = run_context.messages
    for msg in history:
        print(msg)

agent = Agent(
    model=...,
    tool_hooks=[my_pre_hook]
)
from agno.tools.gitlab import GitlabTools

agent = Agent(
    tools=[GitlabTools()],
    ...
)
from agno.embedder.openai_like import OpenAILikeEmbedder

embedder = OpenAILikeEmbedder(
    base_url="http://localhost:4000",
    api_key="sk-...",
    model="text-embedding-3-small",
)
from agno.tools.google import GmailTools

tools = GmailTools()
vector_db = PgVector(
    table_name="embeddings",
    db_url="postgresql://user:pass@localhost/db",
    similarity_threshold=0.75,
)
tools = DuckDuckGoTools(
    timelimit="w",
    region="us-en",
    backend="html",
)
from agno.document.reader.pdf import PDFReader

reader = PDFReader(sanitize_content=False)
docs = reader.read("report_with_tables.pdf")
from agno.team import Team, TeamMode

team = Team(
    mode=TeamMode.broadcast,
    members=[analyst, researcher, summarizer],
)
team.run('Summarize the latest threat intelligence report')
from agno.knowledge import Knowledge

vuln_kb = Knowledge(
    name='vulnerabilities',
    isolate_vector_search=True,
)
patch_kb = Knowledge(
    name='patches',
    isolate_vector_search=True,
)
# Both can point at the same DB/table; searches will only return their own documents.
from agno.agent import Agent
from agno.models.neosantara import Neosantara

agent = Agent(model=Neosantara(id="<model-id>"))
agent.print_response("Halo, apa kabar?")
Condition(
    condition=my_condition,
    steps=[primary_step],
    else_steps=[fallback_step]
)
from agno.agent import Agent

agent = Agent(
    knowledge=my_knowledge_base,
    add_search_knowledge_instructions=False,
)
agent.run('What are our internal policies on data retention?')
from agno.agent import Agent
from agno.tools.seltz import SeltzTools

agent = Agent(
    tools=[SeltzTools()],
)
agent.run('Find recent research on LLM reasoning benchmarks.')
from agno.tools.unsplash import UnsplashTools

agent = Agent(tools=[UnsplashTools()], ...)
from agno.document.reader.excel import ExcelReader

reader = ExcelReader()
documents = reader.read("data/threat_intel.xlsx")
from agno.tools.tavily import TavilyTools

tools = TavilyTools(api_base_url="https://tavily.internal.example.com")
from agno.agent import Agent

agent = Agent(
    instructions=["Always respond in bullet points."],
    add_instruction_tags=True
)
from agno.tools.python import PythonTools

# Production: default sandboxed behaviour (restrict_to_base_dir=True)
tools = PythonTools(base_dir="/app/workspace")

# Local dev: opt out of sandboxing
tools_open = PythonTools(base_dir="/app/workspace", restrict_to_base_dir=False)
from agno.tools.crawl4ai import Crawl4aiTools

tools = Crawl4aiTools(
    proxy_config={
        "server": "http://proxy.corp.example.com:8080",
        "username": "user",
        "password": "pass"
    }
)
from agno.document.chunking.markdown import MarkdownChunker

chunker = MarkdownChunker(split_on_headings=True)
from agno.tools.mcp import MCPTools

def my_header_provider():
    token = fetch_current_auth_token()  # your token-refresh logic
    return {"Authorization": f"Bearer {token}"}

tools = MCPTools(url="https://my-mcp-server.example.com", header_provider=my_header_provider)
from agno.middleware.jwt import JWTMiddleware

middleware = JWTMiddleware(
    secret="<your-secret>",
    audience="https://api.myapp.example.com"
)
agent.set_cancellation_manager(my_custom_cancellation_manager)
serve(reload_includes=['*.yaml', '*.yml'], reload_excludes=['tests/*', 'docs/*'])
agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    output_schema={
        'type': 'json_schema',
        'json_schema': {
            'name': 'result',
            'strict': True,
            'schema': {
                'type': 'object',
                'properties': {'answer': {'type': 'string'}},
                'required': ['answer'],
                'additionalProperties': False
            }
        }
    }
)
from agno.tools.shopify import ShopifyTools

agent = Agent(tools=[ShopifyTools()], markdown=True)
agent.print_response('What were my top-selling products last month?')
result = agent.run(
    "Enumerate open ports on 10.0.0.1",
    run_id="pentest-2025-07-01-recon"
)
import asyncio
from agno.memory import MemoryManager

memory_manager = MemoryManager(user_id="user_123")

# Sync
memory_manager.optimize_memories()

# Async
asyncio.run(memory_manager.aoptimize_memories())
from agno.agent import Agent
from pydantic import BaseModel

class SummaryOutput(BaseModel):
    summary: str
    key_points: list[str]

agent = Agent(model=...)
result = agent.run("Summarise this document", output_schema=SummaryOutput)
from agno.models.google import Gemini
from agno.agent import Agent

agent = Agent(model=Gemini(thinking_level="high"))
agent.run("Explain the proof of Fermat's Last Theorem")
from agno.tools.nano_banana import NanoBananaTools

agent = Agent(tools=[NanoBananaTools()], ...)
team.print_response("Summarise the threat landscape", show_member_responses=True)
slack_interface = SlackInterface(agent=my_agent, reply_to_mentions_only=False)
from agno.tools.parallel_tools import ParallelTools

agent = Agent(
    tools=[ParallelTools()],
    ...
)
agent.run('Find and summarize the latest research on LLM context management')
from agno.workflow import Workflow, RunContext

def my_step(run_context: RunContext) -> str:
    run_context.state['processed'] = True
    return 'done'

wf = Workflow(steps=[my_step])
wf.run()
for event in agent.run('Summarise this report', yield_run_output=True, stream=True):
    print(event)
from agno.agent import RunContext

def my_tool(query: str, run_context: RunContext) -> str:
    previous = run_context.state.get("last_query", "none")
    run_context.state["last_query"] = query
    return f"Previous query was: {previous}"
from agno.agent import Agent

agent = Agent(model="openai:gpt-5")
agent = Agent(
    ...
    num_history_messages=5,
)
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o', cache_response=True),
    description='A cost-efficient research assistant',
)
agent.print_response('Summarize the history of the Roman Empire')
from agno.agent import Agent
from agno.storage.sqlite import AsyncSqliteDb

storage = AsyncSqliteDb(db_path='tmp/agent_sessions.db')
agent = Agent(storage=storage)

import asyncio
asyncio.run(agent.aprint_response('Hello!'))
agent = Agent(
    tools=[...],
    max_tool_calls_from_history=5
)
async for event in agent.arun('Summarize the latest reports', stream=True, stream_events=True):
    print(event)
await agent.aupdate_session_state({'last_topic': 'network anomalies', 'alert_level': 'high'})
curl -X GET 'https://<agentOS-host>/sessions/<session-id>/runs/<run-id>' \
  -H 'Authorization: Bearer <token>'
from agno.workflow import Condition

def my_evaluator(step_output, session_state):
    return session_state.get('user_tier') == 'premium'

condition = Condition(evaluator=my_evaluator, ...)
agent = Agent(
    ...,
    store_history_messages=False,
    store_tool_messages=False,
)
workflow.run(
    ...,
    stream_intermediate_events=True,
    stream_executor_events=False,
)
serve(access_log=True)
agent_os = AgentOS(app=my_fastapi_app, enable_mcp_server=True)
agent = Agent(..., overwrite_db_session_state=True)
from agno.tools.mcp import MultiMCPTools

tools = MultiMCPTools(
    servers=["npx -y @modelcontextprotocol/server-github", "npx -y @modelcontextprotocol/server-slack"],
    allow_partial_failure=True
)
from agno.agent import Agent
from agno.tools.file_generation import FileGenerationTools

agent = Agent(
    tools=[FileGenerationTools()],
    description="An agent that can generate and save file artifacts.",
)
agent.print_response("Summarise this dataset and save it as a CSV report.")
def custom_function_step(step_input: StepInput, session_state):
    session_state["last_processed"] = step_input.message
    return step_input
from typing import TypedDict
from agno.agent import Agent

class ScanInput(TypedDict):
    target: str
    depth: int

agent = Agent(input_schema=ScanInput)
from agno.client.discord import DiscordClient
from pydantic import BaseModel

class AnalysisResult(BaseModel):
    summary: str
    risk_level: str

client = DiscordClient(agent=my_agent, response_model=AnalysisResult)
from agno.agent import Agent
from agno.tools.neo4j import Neo4jTools

agent = Agent(
    tools=[Neo4jTools(uri='bolt://localhost:7687', user='neo4j', password='<password>')],
    show_tool_calls=True,
)
agent.print_response('Find all nodes connected to the user with id 42')
from agno.agent import Agent
from agno.models.openai import OpenAIResponses

agent = Agent(
    model=OpenAIResponses(id='o3', summary='auto'),
    markdown=True,
)
agent.print_response('Explain the steps to assess a phishing email')
from agno.tools.memori import MemoriTools

agent = Agent(tools=[MemoriTools()], ...)
from agno.models.openai import OpenAIChat

model = OpenAIChat(id="gpt-4o", verbosity=2)
from agno.storage.memory import InMemoryStorage
from agno.agent import Agent

agent = Agent(
    storage=InMemoryStorage(),
)
agent.run('Summarize the latest threat intel report.')
from agno.agent import Agent
from agno.tools.trafilatura import TrafilaturaTools

agent = Agent(
    tools=[TrafilaturaTools()],
)
agent.run('Extract the main article text from https://example.com/blog/post')
from agno.models.dashscope import DashScope
from agno.agent import Agent

agent = Agent(
    model=DashScope(id='qwen-max'),
)
agent.run('List the top five open-source SIEM platforms.')
from agno.team import Team

research_team = Team(
    name='Research Team',
    role='Gather and synthesize information from web sources to answer factual questions',
    members=[...]
)
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='o3'),
    output_model=OpenAIChat(id='gpt-4o-mini'),
)
agent.print_response('Summarise the quarterly results.')
from agno.models.openai import OpenAIChat

model = OpenAIChat(id='gpt-4o', service_tier='flex')
pip install agno[arxiv]
from agno.document.chunking.row import RowChunking
from agno.document.reader.csv_reader import CSVReader

reader = CSVReader(chunking_strategy=RowChunking())
documents = reader.read('alerts.csv')
from agno.tools.bitbucket import BitbucketTools
from agno.agent import Agent

agent = Agent(
    tools=[BitbucketTools(username="<username>", password="<app-password>", workspace="<workspace>")],
    markdown=True,
)
agent.print_response("List all open pull requests in the agno repo")
from pydantic import BaseModel
from agno.agent import Agent

class ScanRequest(BaseModel):
    target: str
    depth: int

agent = Agent(model=...)
agent.run(ScanRequest(target="example.com", depth=3))
agent.run('Continue the investigation', session_state={'case_id': 'INC-4821', 'severity': 'high'})
from agno.eval.performance import PerformanceEval
from agno.agent import Agent

eval = PerformanceEval(agent=Agent(), memory_growth_tracking=True)
eval.run()
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(model=OpenAIChat(id="o3-deep-research"))
agent.print_response("Research the latest advances in quantum error correction.")
from agno.agent import Agent

agent = Agent(
    model=my_model,
    debug_level=2,
)
from agno.models.gemini import Gemini

model = Gemini(
    id="gemini-2.0-flash-thinking-exp",
    thinking_budget=1024,
    include_thoughts=True,
)
from agno.agent import Agent
from agno.tools.valyu import ValyuTools

agent = Agent(tools=[ValyuTools()])
agent.print_response("Find recent papers on retrieval-augmented generation")
agent = Agent(tools=[existing_tool])
agent.add_tool(new_tool)
team = Team(
    members=[...],
    stream_member_events=False
)
response = agent.run('Analyze the logs')
if response.status == 'CANCELLED':
    print('Run was cancelled before completion')
elif response.status == 'PAUSED':
    print('Run is awaiting input')
from agno.knowledge.pdf_bytes import PDFBytesKnowledgeBase
import httpx

pdf_bytes = httpx.get('https://example.com/report.pdf').content
kb = PDFBytesKnowledgeBase(pdf_bytes=pdf_bytes)
kb.load()
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    add_location_to_instructions=True,
)
agent.print_response('What businesses near me are open right now?')
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.serper import SerperTools

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    tools=[SerperTools()],
)
agent.print_response('What are the latest CVEs disclosed this week?')
from agno.agent import Agent
from agno.tools.visualization import VisualizationTools

agent = Agent(
    name="ChartAgent",
    tools=[VisualizationTools()],
)
agent.print_response("Plot a bar chart of monthly sales: Jan=120, Feb=95, Mar=140")
from agno.agent import Agent
from agno.tools.brave_search import BraveSearch

agent = Agent(
    name="WebSearchAgent",
    tools=[BraveSearch()],
)
agent.print_response("What are the latest CVEs disclosed this week?")
from agno.agent import Agent
from my_tools import search_tool

agent = Agent(
    tools=[search_tool],
    tool_call_limit=10,
)
agent.run('Research the latest CVEs in OpenSSL')
agent = Agent(
    ...
    search_previous_sessions_history=True,
)
storage = RedisStorage(
    ...
    expire=3600,
)
from agno.agent import Agent
from agno.tools.user_control_flow import UserControlFlowTools

agent = Agent(
    tools=[UserControlFlowTools(), ...],
    ...
)
from agno.vectordb.mongodb import MongoDBVectorDb

vector_db = MongoDBVectorDb(
    connection_string="<your-cosmos-vcore-connection-string>",
    database_name="agno_kb",
    collection_name="embeddings",
    cosmos_compatibility=True,
)
from agno.tools import Toolkit

class MyTools(Toolkit):
    def __init__(self):
        super().__init__(
            stop_after_tool_call_tools=["run_query"],
            show_result_tools=["run_query", "fetch_report"],
        )
from agno.storage.redis import RedisStorage

storage = RedisStorage(
    host="my-redis-host",
    port=6380,
    ssl=True
)
from agno.vectordb.milvus import Milvus

vdb = Milvus(
    collection="my_collection",
    hybrid_search=True,
)
agent = Agent(
    knowledge=knowledge_base,
    enable_agentic_knowledge_filters=True
)
agent.run("Tell me about John Doe's performance review")
knowledge_base = PDFKnowledgeBase(path=[
    {"path": "alice_records.pdf", "metadata": {"user_id": "alice"}},
    {"path": "bob_records.pdf",   "metadata": {"user_id": "bob"}}
])
async def my_retriever(query: str, **kwargs):
    results = await async_search(query)
    return results

agent = Agent(retriever=my_retriever, ...)
await agent.arun('What does the policy say about data retention?')
from agno.models.openai import OpenAIChat
from agno.agent import Agent
from agno.media import File

agent = Agent(model=OpenAIChat(id='gpt-4o'))
agent.run('Summarize this report.', files=[File(filepath='report.pdf')])
from agno.models.google import Gemini
from agno.agent import Agent
from agno.media import Video

agent = Agent(model=Gemini(id='gemini-2.0-flash'))
agent.run('Describe what happens in this video.', videos=[Video(url='https://example.com/incident.mp4')])
from agno.tools.some_toolkit import SomeToolkit

agent = Agent(
    tools=[SomeToolkit(include_tools=["search", "fetch"])],
)
from agno.embedder.azure_openai import AzureOpenAIEmbedder

embedder = AzureOpenAIEmbedder(
    client_params={
        'api_version': '2024-02-01',
        'azure_deployment': 'my-embedding-deployment'
    }
)
summary = agent.get_session_summary()
user_memories = agent.get_user_memories()
print(summary)
print(user_memories)
agent.run("What did I order last time?", user_id="user-42", session_id="session-abc123")
team = Team(
    members=[agent1, agent2],
    knowledge=knowledge_base,
    retriever=my_custom_retriever,
    search_knowledge=True,
)
agent.print_response(stream_intermediate_resp=True)
from agno.agent import Agent

agent = Agent(
    timezone_identifier="America/New_York",
    # ... other params
)
from agno.agent import Agent
from agno.tools.reasoning import ReasoningTools

agent = Agent(
    tools=[ReasoningTools()],
    # ... other params
)
from agno.tools.knowledge import KnowledgeTools

agent = Agent(
    knowledge=knowledge_base,
    tools=[KnowledgeTools(knowledge=knowledge_base)],
)
from agno.tools.mcp import MultiMCPTools

tools = MultiMCPTools(
    commands=[
        "npx -y @modelcontextprotocol/server-filesystem /tmp",
        "npx -y @modelcontextprotocol/server-brave-search"
    ]
)

agent = Agent(tools=[tools], ...)
from agno.tools import Toolkit

class MySearchToolkit(Toolkit):
    def __init__(self):
        super().__init__(
            name="my_search",
            instructions="Always prefer recent results. Limit queries to 10 words.",
            add_instructions=True,
        )

    def search(self, query: str) -> str:
        ...
import asyncio
from agno.knowledge.pdf import PDFKnowledgeBase

kb = PDFKnowledgeBase(path='reports/')
asyncio.run(kb.aload())
MCPTools(include_tools=['read_file', 'list_dir'])
Team(members=[...], tools=[my_tool], tool_call_limit=5)
@tool(post_hook=async_post_hook)
async def fetch_data(url: str) -> str:
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()
from agno.team import Team
from agno.agent import Agent

research_agent = Agent(name='Researcher', ...)
writer_agent = Agent(name='Writer', ...)

team = Team(
    mode='route',
    members=[research_agent, writer_agent],
    response_model=MyOutputModel,
    debug_mode=True,
)
team.print_response('Summarise the latest AI papers')
from agno.agent import Agent
from pydantic import BaseModel

class Report(BaseModel):
    title: str
    summary: str

agent = Agent(
    response_model=Report,
    use_json_mode=True,
)
agent.print_response('Generate a threat report')
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.utils.audio import write_audio_to_file

agent = Agent(
    model=OpenAIChat(
        id="gpt-4o-audio-preview",
        modalities=["text", "audio"],
        audio={"voice": "alloy", "format": "wav"},
    ),
)
agent.print_response("Tell me a 5 second story")
if agent.run_response.response_audio is not None:
    write_audio_to_file(
        audio=agent.run_response.response_audio.base64_audio,
        filename="response.wav"
    )
from agno.tools.gmail import GmailTools

tools = GmailTools()
thread = tools.get_emails_by_thread(thread_id="<thread_id>")
tools.send_email_reply(thread_id="<thread_id>", message="Thanks, I'll follow up shortly.")
embeddings = GeminiEmbedder("text-embedding-004").get_embedding(
    "The quick brown fox jumps over the lazy dog."
)
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    exponential_backoff=True,
)
agent.print_response('Summarize the latest AI research trends.')
from agno.models.perplexity import Perplexity
from agno.agent import Agent

agent = Agent(model=Perplexity())
agent.print_response('What are the latest developments in AI safety?')
from agno.tools.todoist import TodoistTools
from agno.agent import Agent

agent = Agent(tools=[TodoistTools()])
agent.print_response('Add a task to review the quarterly report by Friday.')
from agno.tools.exa import ExaTools

exa = ExaTools()
results = exa.find_similar('https://example.com/threat-report')
from agno.knowledge.pdf_url import PDFUrlKnowledgeBase
from agno.vectordb.pgvector import PgVector
from agno.embedder.ollama import OllamaEmbedder

knowledge_base = PDFUrlKnowledgeBase(
    urls=['https://phi-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf'],
    vector_db=PgVector(
        table_name='recipes',
        db_url='postgresql+psycopg://ai:ai@localhost:5532/ai',
        embedder=OllamaEmbedder(id='llama3.2', dimensions=3072),
    ),
)
knowledge_base.load(recreate=True)

Summary

Agno is an open-source framework and runtime for agent platforms that allows building, running, and managing agent stacks, with data and memory remaining under the user's control via JWT-based RBAC. It is accessible via an SDK for building agents, an AgentOS runtime, and a web UI for management. This tool targets platform engineers, and its documentation describes it as enabling users to own their agent stack, contrasting it with tools that require outsourcing control. The project maintains active setup instructions demonstrating local deployment via Docker containers.

Build, run, and manage agent platforms.

What Agno answers

How do I set up the platform environment?

A coding agent can set up the platform locally using Docker by following a prompt that directs it to a starter template repository.

What data and state is persisted?

The system uses a Postgres database for storing data and traces.

What components are included in a local setup?

A local setup includes a REST API for serving agents, an MCP server, and a control plane.

What are the options for deploying beyond local Docker?

You can adapt the setup by pointing the deployment prompt to different repository templates like those for AWS, GCP, or Azure.

How do I manage the agents after setting up the platform?

Management is handled through a dedicated web UI component.

What mechanisms enforce who can access what?

Access control is managed using JWT-based Role-Based Access Control (RBAC).

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

v3.0.4 Aug 30, 2026 · issue 012

KnowledgeManagementTools gets granular opt-in flags and per-tool names; AtomicMail warm calls drop from ~35 s to under 3 s
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.4
```
└──▷ USE IT
Enable only safe ingestion tools and explicitly opt in to path ingestion for an agent that needs to load local files into a shared knowledge base.
python
```
from agno.tools.knowledge import KnowledgeManagementTools

km_tools = KnowledgeManagementTools(
    knowledge_base=my_kb,
    ingest_url=True,
    ingest_text=True,
    ingest_path=True,   # opt-in: exposes any path the server process can read
    remove_content=False,
)
```
- ›Renames KnowledgeManagementTools constructor flags to match the tools they register — ingest_url, ingest_path, ingest_text, remove_content — giving per-tool opt-in control; ingest_path now defaults to off because under scope='shared' it exposes loaded content to every agent on the knowledge base.
- ›Moves KnowledgeManagementTools to agno.tools.knowledge; KnowledgeTools (read-only) and KnowledgeManagementTools (write) now share that package, mirroring the agno.tools.mcp and agno.tools.finance layout.
- ›Makes agno.tools.file and agno.tools.knowledge lazy-loading packages so importing FileTools no longer pulls in reportlab and python-docx — saves 44.8 ms on every FilesystemContextProvider import.
- ›Adds pow_workers argument to AtomicMail (default min(4, cpu_count())) to parallelise scrypt nonce search across a bounded thread pool, cutting mean solve time from 25.9 s to 10.4 s at difficulty 10.
- ›Caches AtomicMail auth context (capability JWT, API URL, account and inbox IDs) on the instance until token expiry, reducing warm tool call latency from ~35 s to 0.4–3 s in both sync and async paths.
└──▷ BREAKING ON UPGRADE
- !The enable_ingest and enable_remove flags on KnowledgeManagementTools are removed and silently ignored if passed; replace them with the new per-tool flags ingest_url, ingest_path, ingest_text, and remove_content.
- !KnowledgeManagementTools moved from agno.tools.knowledge_management to agno.tools.knowledge; any from agno.tools.knowledge_management import KnowledgeManagementTools import will break.
- !ingest_path on KnowledgeManagementTools now defaults to off; existing code that relied on it being enabled by default must now pass ingest_path=True explicitly.
v3.0.3 Aug 30, 2026 · issue 012

Agno v3.0.3 adds per-page website/folder ingestion, SitemapReader, KnowledgeManagementTools, and new AgentOS knowledge API routes.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.3
```
└──▷ USE IT
Attach knowledge management tools to an agent so it can ingest, list, and remove knowledge base content at runtime.
python
```
from agno.agent import Agent
from agno.tools.knowledge import KnowledgeManagementTools

agent = Agent(
    tools=[KnowledgeManagementTools(scope="shared")],
)
agent.print_response("Ingest https://docs.agno.com and list all loaded pages.", stream=True)
```
Trigger a background re-ingest of a specific knowledge content row via the AgentOS API.
```
$ curl -X POST https://<agentos-host>/knowledge/content/<id>/refresh
```
List all child rows belonging to a previously ingested site or folder to inspect per-page status.
```
$ curl 'https://<agentos-host>/knowledge/content?parent_id=<parent_id>'
```
- ›Adds KnowledgeManagementTools with operations ingest_url, ingest_text, ingest_path, list_content, ingest_status, and remove_content (confirmation required by default), supporting scope="shared"|"user", JSON envelopes, and sync/async variants.
- ›Adds AgentOS API route GET /knowledge/content?parent_id= to list a site's or folder's content rows with correct totals.
- ›Adds AgentOS API route POST /knowledge/content/{id}/refresh to re-run ingest for a URL or path-sourced row in the background.
- ›Adds SitemapReader that discovers pages via the sitemap protocol (robots.txt Sitemap: lines, /sitemap.xml, /sitemap_index.xml, gzip and nested indexes) with canonical dedup and a max_pages cap; auto-selected for bare sitemap*.xml(.gz) URLs and available in the UI reader dropdown.
- ›Adds HttpxPageFetcher and ParallelPageFetcher as fetch seams below URL readers; ParallelPageFetcher resolves Parallel's keyed SDK, then its keyless MCP endpoint, then plain httpx, honoring retry-after with exponential backoff and recording per-page extractor and attempts provenance.
+4 moreshow less
- ›Per-page website ingestion stores one content row per page with content_id matching its vectors, supporting individual list, refresh, and delete; digest-driven re-ingest skips unchanged pages, replaces only changed pages' vectors, retries failed pages, and prunes removed sitemap entries.
- ›Folder ingestion stores a folder row with one child row per file (nested folders flattened), with byte-digest refresh (unchanged files skip read and embed), failure isolation per file, pruning of deleted files, and cascade delete.
- ›HttpxPageFetcher routes application/pdf responses and %PDF- bytes served under a wrong content type through PDFReader; a missing pypdf surfaces as a per-page error naming agno[pdf].
- ›Adds cookbook examples cookbook/07_knowledge/01_getting_started/05_website_per_page.py (per-page website ingestion) and cookbook/91_tools/knowledge_management_tools.py (management toolkit including folder ingestion).
v3.0.2 Aug 30, 2026 · issue 011

Agno v3.0.2 adds Synthorai, WaveSpeed, Serply, and AtomicMail integrations plus MCP toolkit publishing and per-provider reasoning detection.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.2
```
└──▷ USE IT
Add WaveSpeed image generation to an agent for text-to-image workflows in a script or notebook.
python
```
from agno.agent import Agent
from agno.tools.wavespeed import WaveSpeedTools

agent = Agent(
    tools=[WaveSpeedTools(poll_interval=2, timeout=60)],
    markdown=True,
)
agent.print_response("Generate an image of a futuristic city at night", stream=True)
```
Give an agent its own disposable inbox for automated email tasks — inbox is provisioned once and reused from ~/.atomicmail/credentials.json.
python
```
from agno.agent import Agent
from agno.tools.atomicmail import AtomicMailTools

agent = Agent(
    tools=[AtomicMailTools(pow_timeout=300)],
    markdown=True,
)
agent.print_response("Register me an inbox, then check for any new messages.", stream=True)
```
- ›Adds Synthorai model provider (agno.models.synthorai) reading SYNTHORAI_API_KEY, defaulting to https://synthorai.io/v1; resolves model='synthorai:<model-id>' strings via the provider lookup table.
- ›Adds WaveSpeedTools (pip install agno[wavespeed], key from WAVESPEED_API_KEY) with generate_image and generate_video methods that accept a text prompt, poll within poll_interval and timeout, and return ToolResult carrying Image/Video artifacts.
- ›Adds SerplyTools for Google web, News, and Scholar search via the Serply API, reading SERPLY_API_KEY; web search is on by default, with search_news, search_scholar, and all=True enabling additional surfaces.
- ›Adds AtomicMailTools with register_inbox, send_email, and list_inbox over JMAP; register_inbox provisions a new inbox via proof-of-work signup, credentials cached to ~/.atomicmail/credentials.json, with pow_timeout (default 300s) capping the solve.
- ›Adds MCPConfig.tools support for Agent, Team, Workflow instances, remote proxies, and component factories, publishing each as its own named MCP tool; component.as_tool(name=..., description=...) lets you control the published name.
+7 moreshow less
- ›Adds MCPConfig.tools support for Toolkit instances, publishing one MCP tool per registered method filtered by enable_*/include_tools/exclude_tools; ToolResult is rendered as MCP content blocks including text, image, audio, embedded resource, and resource_link.
- ›Adds title and annotations parameters to as_tool() and @tool/Function, published over MCP for exposed components and built-in tools; unknown annotation keys raise at construction.
- ›Adds query_timeout parameter to every context provider, applying a wall-clock deadline to each query_<id> tool call (requires Python 3.11+), and adds write_tools to the five write-capable providers to replace the default write sub-agent toolset.
- ›Adds headless Google OAuth support: Google toolkits accept AuthConfig(interactive=False) or env var GOOGLE_OAUTH_NONINTERACTIVE=1 to raise instead of blocking on a browser flow.
- ›Adds ScheduleManager.list_all() and alist_all() to page the full schedule catalog, backed by a new raise_on_error argument on get_schedules; listings now break created_at ties by id.
- ›Adds sync, async, and streaming reasoning handlers to MoonShot (Kimi) reading reasoning_content; routes OpenRouter through the OpenAI reasoning path.
- ›Native reasoning detection now queries the provider first before falling back to model-id matching; result is cached on the reasoning manager with a 10-second timeout on the Ollama, OpenRouter, and Moonshot paths.
└──▷ BREAKING ON UPGRADE
- !MCPConfig/MCPServerConfig now raise on unrecognised keyword arguments at construction instead of silently ignoring them (e.g. a typo like tool= will fail at boot).
- !BaseRemote.acancel_run gained a required auth_token keyword parameter; third-party BaseRemote subclasses must accept it.
- !metadata precedence on Agent, Team, and Workflow changed: a metadata= passed to run() now wins over the component-level metadata; code that read agent.metadata after a run to observe session values now sees only the constructor value.
- !Reasoning detection now queries the provider via a blocking HTTP call before model-id matching; a Gemini or Claude model configured for thinking may now be classified as non-reasoning when the provider reports thinking unsupported. Id-based fallbacks also changed: gpt-5 variants match on OpenAI and Azure OpenAI, Groq and Ollama match gpt-oss and qwen3, and qwen2.5-coder on Ollama is no longer treated as a reasoning model.
v3.0.1 Aug 26, 2026 · issue 009

Agno v3.0.1 adds a timeout parameter to PubmedTools, exports QueueConfig from agno.os, and caches tool schemas across runs for faster large-toolkit agents.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.1
```
└──▷ USE IT
Prevent a slow PubMed API response from stalling an agent tool call by setting an explicit request timeout.
python
```
from agno.tools.pubmed import PubmedTools
from agno.agent import Agent

agent = Agent(
    tools=[PubmedTools(timeout=10)],
)
agent.print_response("Latest research on CRISPR gene editing", stream=True)
```
- ›Adds timeout parameter to PubmedTools, passed to both NCBI E-utilities requests so a stalled PubMed response cannot block a tool call indefinitely.
- ›Exports QueueConfig from agno.os, making it importable directly from that module.
- ›Tool schemas are now derived once and cached across runs, cutting per-run overhead for agents that carry large toolkits.
- ›Session history is now loaded incrementally per turn, keeping response time flat as a conversation grows rather than scaling with its length.
docs update Aug 24, 2026 · issue 006

Agno agents gain media_storage and delete_media options to offload and manage session media externally.
- ›Adds media_storage parameter (type Optional[Union[MediaStorage, AsyncMediaStorage]]) to Agent, enabling offloading of media to external storage while keeping only a reference in the database.
- ›Adds delete_media parameter (bool, default False) to Agent, which when True also deletes a session's offloaded media from media_storage on session deletion.
docs update Aug 24, 2026 · issue 006

Agno adds media storage backends for sessions: local filesystem, Amazon S3, and Google Cloud Storage.
- ›New Media Storage subsystem for persisting session media, with backends for local filesystem, Amazon S3 (S3 Media Storage), and Google Cloud Storage (GCS Media Storage).
v3.0.0a5 Aug 24, 2026 · issue 006

Adds opt-in self_dispatch knob to the Studio dispatch guard in Agno v3.0.0a5.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.0a5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.0a5
```
- ›Adds self_dispatch opt-in knob to the Studio dispatch guard, allowing agents to be explicitly configured to dispatch to themselves.
v3.0.0a4 Aug 23, 2026 · issue 006

Agno v3.0.0a4 adds MiniMax video generation tools and switches all telemetry calls to fire-and-forget.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.0a4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.0a4
```
- ›Adds MiniMax video generation tools, extending the 100+ integrations toolkit with AI video synthesis.
- ›Makes all telemetry calls fire-and-forget, eliminating blocking waits on telemetry I/O during agent runs.
v3.0.0a3 Aug 21, 2026 · issue 004

Agno v3.0.0a3 adds CodeMode, media offloading, SuperGrok OAuth, workflow registry, and MigrationRequiredError for stale schemas.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.0a3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.0a3
```
- ›Adds MigrationRequiredError to surface stale database schema errors with an actionable migration path instead of a silent table failure.
- ›Adds CodeMode for agents and teams, enabling result offloading and a result_store handle with kernel fixes and execution bounds (3.0 S1).
- ›Adds media offloading from the database to local, S3, or GCS storage backends.
- ›Adds SuperGrok OAuth device-code authentication for the xAI model.
- ›Adds workflow registry and zero-config Studio integration for workflows.
+1 moreshow less
- ›Makes LearningMachine the sole Studio memory surface, consolidating memory management.
v3.0.0a2 Aug 20, 2026 · issue 003

Agno v3.0.0a2 adds FinanceTools, RampRouter, user-isolated evals/schedules/knowledge, reliable background execution, and Studio 3.0.
└──▷ GET THIS VERSION
```
$ git clone --branch v3.0.0a2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v3.0.0a2
```
- ›Adds FinanceTools — a unified finance toolkit with swappable data providers, replacing scattered individual finance tool integrations.
- ›Adds RampRouter model class for the Ramp Router (router.com) provider.
- ›Adds id field to Toolkit, allowing toolkits to be referenced and tracked by identifier.
- ›Requires human_review=HumanReview(...) for human-in-the-loop configuration — replaces flat HITL kwargs.
- ›Adds user-isolation to evals, so evaluation runs are scoped per user.
+7 moreshow less
- ›Adds user-isolation to schedules, metrics, knowledge, and vector DB resources.
- ›Introduces reliable background execution for AgentOS — bounded, observable, and durable agent job processing.
- ›Introduces Studio 3.0, a governed control plane for agents that build agents.
- ›Consolidates AgentOS metadata routes into a unified surface.
- ›Denormalizes the sessions table in the database for improved query performance.
- ›Makes Team and Workflow constructors keyword-only, enforcing explicit argument passing.
- ›Improves agno create onboarding flow for new platform setup.
└──▷ BREAKING ON UPGRADE
- !The enable_user_memories, search_session_history, num_history_sessions, and num_past_session_runs parameters are removed; any code passing these will break on upgrade.
- !Flat HITL kwargs are removed; callers must now pass human_review=HumanReview(...) instead.
- !The reasoning=True shortcut is removed; callers must now pass an explicit reasoning_model argument.
- !The culture feature (experimental) is removed with no replacement.
- !The MistralAI v1 compatibility layer is removed; code relying on it will break.
- !Team and Workflow constructors are now keyword-only; positional arguments will raise errors on upgrade.
- !Deprecated v3.0 API surface and unannounced compat surface are removed.
v2.9.0 Aug 13, 2026 · issue -006

Agno v2.9.0 adds StudioRunnerTools for identity-aware dispatch and hardens MCP tool security and cache isolation
└──▷ GET THIS VERSION
```
$ git clone --branch v2.9.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.9.0
```
└──▷ USE IT
Mount StudioRunnerTools on a router agent so it can discover and invoke Studio-built agents and teams on behalf of the authenticated user, without exposing create/edit/delete operations.
python
```
from agno.tools.studio_runner import StudioRunnerTools

router = Agent(
    name="Router",
    tools=[StudioRunnerTools()],
    ...
)
```
- ›Adds agno.tools.studio_runner.StudioRunnerTools, an identity-aware dispatch toolkit that lets any component (team lead, router) discover and run Studio-built agents, teams, and workflows — without exposing Studio's create/edit/delete surface — threading the caller's user_id into sub-runs for correct per-user state.
- ›Adds a name filter parameter to list_components for narrowing component discovery by name.
- ›MCP tool entrypoints no longer accept a call-time tool_name override; the executed tool name is now closed over from tool.name, closing a bypass of allow-lists, requires_confirmation, HITL approval, and logging gates.
- ›Rehydration of persisted components with unresolvable references now raises ComponentRehydrationError (an AgnoError, status_code=422) on strict paths — AgentOS lookups and all dispatch paths (POST /runs, continue, MCP run tools, StudioRunner) default to strict=True and return a 422 naming the unresolvable piece instead of silently running a degraded component; public from_dict/load default to strict=False.
└──▷ BREAKING ON UPGRADE
- !MCP tool call-time tool_name overrides are now ignored and forwarded as ordinary arguments instead of selecting the tool to execute; any integration that relied on passing tool_name at call time to route to a different tool will no longer work as before.
- !Tool result cache keys now include user_id and session_id, so all prior cache entries composed without those fields will not produce hits after upgrading.
- !AgentOS lookups and all dispatch paths (POST /runs, continue, MCP run tools, StudioRunner) now default strict=True for rehydration and return a 422 ComponentRehydrationError for unresolvable references instead of silently degrading and running the component.
v2.9.0 Aug 13, 2026 · issue 002

Agno v2.9.0 adds StudioRunnerTools for identity-aware agent dispatch and hardens MCP tool security and cache isolation.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.9.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.9.0
```
└──▷ USE IT
Mount StudioRunnerTools on a router agent so it can discover and run any Studio-built agent or team on behalf of the calling user without gaining create/edit/delete access.
python
```
from agno.tools.studio_runner import StudioRunnerTools
from agno.agent import Agent

router = Agent(
    name="router",
    tools=[StudioRunnerTools()],
    instructions="Dispatch user requests to the appropriate Studio component.",
)
```
- ›Adds agno.tools.studio_runner.StudioRunnerTools, a new identity-aware dispatch toolkit that lets any component (team lead, router) discover and run Studio-built agents, teams, and workflows without exposing the Studio's create/edit/delete surface; threads the caller's user_id into sub-runs for correct per-user state.
- ›Adds a name filter parameter to list_components for targeted component lookup.
- ›Rehydration now raises ComponentRehydrationError (AgnoError, status_code=422) on unresolvable references instead of silently degrading; from_dict/load default strict=False, while AgentOS lookups and all dispatch paths (POST /runs, continue, MCP run tools, StudioRunner) default strict=True and return a 422 naming the unresolvable piece.
└──▷ BREAKING ON UPGRADE
- !MCP tool entrypoints no longer accept a call-time tool_name override; model-supplied tool_name arguments are forwarded as ordinary arguments rather than used to select the tool to execute.
- !Tool result cache keys now include user_id and session_id, so existing cache entries will not match under the new key composition — prior cache hits will not line up.
- !AgentOS lookups and all dispatch paths (POST /runs, continue, MCP run tools, StudioRunner) now default strict=True for rehydration and return a 422 ComponentRehydrationError instead of running a degraded component when references are unresolvable.
v2.8.7 Aug 5, 2026 · issue -014

Agno v2.8.7 adds AdvisorTools, OpenRouteService toolkit, and overridable FileSystemTools names
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.7
```
- ›Adds AdvisorTools class for querying advisor models for feedback on agent outputs.
- ›Adds OpenRouteService toolkit for accurate geospatial routing.
- ›Allows overriding the FileSystemTools toolkit name via the toolkit's name parameter.
- ›Adds component-aware schedule tools and history parameters to StudioTools.
v2.8.7 Aug 5, 2026 · issue 002

Agno v2.8.7 adds AdvisorTools, OpenRouteService toolkit, and component-aware StudioTools with history parameters.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.7
```
- ›Adds OpenRouteService toolkit for accurate geographic routing.
- ›Adds component-aware schedule tools and history parameters to StudioTools.
- ›Allows overriding the FileSystemTools toolkit name at instantiation time.
v2.8.6 Jul 30, 2026 · issue -020

Agno v2.8.6 adds Smallest AI TTS tools, OpenSearch vector DB, and a new AgentOS metrics-refresh status endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.6
```
└──▷ USE IT
Add Smallest AI text-to-speech capability to an agent and save audio output to disk.
python
```
from agno.tools.smallest import SmallestTools
from agno.agent import Agent

agent = Agent(tools=[SmallestTools(voice_id='<voice_id>', model='lightning_v3.1', output_file='output.wav')])
agent.run('Convert this text to speech: Hello from Agno!')
```
Poll AgentOS for completion of a background metrics refresh instead of waiting for a blocking response.
```
$ curl -X POST 'http://localhost:8000/metrics/refresh?background=true'
# Then poll until completed:
curl 'http://localhost:8000/metrics/refresh/status'
```
Use OpenSearch as a vector database backend for hybrid search in a retrieval workflow.
python
```
from agno.vectordb.opensearch import OpenSearch

vectordb = OpenSearch(
    host='localhost',
    port=9200,
    index='my-index',
    search_type='hybrid'
)
```
- ›Adds SmallestTools toolkit in agno for Smallest AI text-to-speech, exposing text_to_speech (returns audio as a ToolResult artifact, optionally saved to disk) and get_voices; supports lightning_v3.1 and lightning_v3.1_pro models.
- ›Adds OpenSearch vector database support at agno.vectordb.opensearch, installable via the agno[opensearch] extra, with vector, keyword, and hybrid search in both sync and async variants; includes a run_opensearch.sh script for local setup.
- ›Adds GET /metrics/refresh/status endpoint to AgentOS to poll the state of a background metrics refresh, returning idle, running, completed, or failed with started_at, finished_at, and error fields.
- ›Exposes AgentOSClient.get_metrics_refresh_status() as the client-side counterpart to GET /metrics/refresh/status.
- ›Adds ?background=true query parameter to POST /metrics/refresh, returning HTTP 202 immediately and running the refresh as a single-flight background task per database.
+1 moreshow less
- ›Caches the Pydantic version lookup during tool wrapping, cutting repeated-wrap overhead from 65.9 ms to 11.0 ms per 100 wraps.
v2.8.6 Jul 30, 2026 · issue 002

Agno v2.8.6 adds SmallestAI TTS tools, OpenSearch vector DB support, and a new AgentOS metrics-refresh status endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.6
```
└──▷ USE IT
Poll AgentOS for background metrics-refresh completion instead of timing out silently.
python
```
import time
from agentos_client import AgentOSClient

client = AgentOSClient()
client.post("/metrics/refresh?background=true")

while True:
    status = client.get_metrics_refresh_status()
    if status["state"] in ("completed", "failed"):
        print(status)
        break
    time.sleep(2)
```
- ›Adds OpenSearch vector database backend at agno.vectordb.opensearch with vector, keyword, and hybrid search in sync and async variants; installable via the agno[opensearch] extra.
- ›Adds GET /metrics/refresh/status AgentOS endpoint reporting idle, running, completed, or failed states with started_at, finished_at, and error fields so clients can poll for completion.
- ›Exposes the new metrics-refresh status endpoint on the Python client as AgentOSClient.get_metrics_refresh_status().
- ›Adds ?background=true query parameter to POST /metrics/refresh to return HTTP 202 immediately and run the refresh as a single-flight background task per database.
v2.8.5 Jul 27, 2026 · issue -023

Agno v2.8.5 adds AgentOSTools for platform observability and Moonshot thinking-mode toggle with file/video input support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.5
```
└──▷ USE IT
Enable Moonshot extended reasoning for a complex analysis task.
python
```
from agno.models.moonshot import Moonshot

model = Moonshot(use_thinking=True)
agent = Agent(model=model)
agent.print_response('Analyze the security implications of this architecture')
```
- ›Adds AgentOSTools class, a read-only platform operations toolkit that reports on AgentOS usage, latency, failures, schedules, evals, components, and pending approvals.
- ›Adds use_thinking parameter to the Moonshot integration to toggle thinking mode.
- ›Adds file and video input support to the Moonshot integration.
- ›Adds latency and error stats grouped by agent, team, workflow, or endpoint — plus tool and model call stats — to Traces, implemented for PostgresDb and SqliteDb.
└──▷ BREAKING ON UPGRADE
- !The Moonshot integration default model is changed to kimi-k3; any setup relying on the previous default model will now use kimi-k3 without an explicit override.
v2.8.5 Jul 27, 2026 · issue 002

Agno v2.8.5 adds AgentOSTools for platform observability, Moonshot thinking mode, and file/video input support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.5
```
└──▷ USE IT
Embed AgentOSTools in an agent to query live platform status — pending approvals, failures, and schedules — from within a conversation.
python
```
from agno.agent import Agent
from agno.tools.agentos import AgentOSTools

ops_agent = Agent(
    tools=[AgentOSTools()],
    instructions="You are a platform operations assistant. Use AgentOSTools to answer questions about agent health, schedules, and pending approvals.",
)

if __name__ == "__main__":
    ops_agent.print_response("Show me any pending approvals and recent failures.", stream=True)
```
Enable extended reasoning on a Moonshot-backed agent to get chain-of-thought responses for complex tasks.
python
```
from agno.agent import Agent
from agno.models.moonshot import Moonshot

agent = Agent(
    model=Moonshot(id="kimi-k3", use_thinking=True),
    instructions="Reason step by step before answering.",
)

if __name__ == "__main__":
    agent.print_response("Explain the trade-offs between RAG and fine-tuning.", stream=True)
```
- ›Adds AgentOSTools class providing a read-only platform operations toolkit to report on AgentOS usage, latency, failures, schedules, evals, components, and pending approvals.
- ›Adds use_thinking parameter to the Moonshot integration to toggle thinking mode.
- ›Adds file and video input support to the Moonshot integration.
- ›Adds latency and error stats grouped by agent, team, workflow, or endpoint — plus tool and model call stats — to Traces, implemented for PostgresDb and SqliteDb.
- ›Changes the Moonshot default model to kimi-k3.
└──▷ BREAKING ON UPGRADE
- !The Moonshot integration now defaults to kimi-k3 instead of the previous default model; any setup relying on the former default will silently switch models on upgrade.
v2.8.4 Jul 26, 2026 · issue -024

Agno v2.8.4 adds TrustedRouter as an OpenAILike model class and revamps entity memory for the second brain.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.4
```
- ›Adds TrustedRouter as an OpenAILike model class, enabling use of TrustedRouter as a model backend.
- ›Revamps entity memory for the second brain, enhancing how agent memory stores and retrieves entities.
v2.8.4 Jul 26, 2026 · issue 002

Agno v2.8.4 adds TrustedRouter as an OpenAILike model class and revamps entity memory for the second brain.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.4
```
- ›Adds TrustedRouter as an OpenAILike model class, enabling use of TrustedRouter as a model provider within the Agno SDK.
- ›Revamps entity memory for the second brain, improving how agents store and recall structured entity information across conversations.
v2.8.2 Jul 24, 2026 · issue -026

Agno v2.8.2 adds FileSystem, a durable per-agent persistent filesystem with pluggable DB/local backends.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.2
```
- ›Adds FileSystem, a new durable agent filesystem primitive giving agents a private, persistent filesystem with pluggable DB or local backends and fail-closed per-user namespace isolation.
v2.8.2 Jul 24, 2026 · issue 002

Agno v2.8.2 adds FileSystem, a durable per-agent private filesystem with pluggable DB/local backends and per-user namespace isolation.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.2
```
- ›Adds FileSystem, a new durable state primitive that gives agents a private, persistent filesystem with pluggable database or local backends and fail-closed per-user namespace isolation.
v2.8.1 Jul 23, 2026 · issue -027

Agno v2.8.1 adds Marengo video embeddings, Slack peer-agent comms flag, and a loop-guard for Learning Stores.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.1
```
└──▷ USE IT
Enable a Slack-connected agent to respond to messages from other agents in the same workspace.
python
```
slack_agent = Agent(
    tools=[SlackTools(respond_to_other_agents=True)],
    ...
)
```
Cap extraction tool calls in a Learning Store to avoid infinite loops during knowledge ingestion.
python
```
learning_store = LearningStore(
    extraction_tool_call_limit=5,
    ...
)
```
- ›Adds respond_to_other_agents flag to the Slack integration to enable peer-agent communication between Slack-connected agents.
- ›Adds extraction_tool_call_limit to Learning Stores to cap runaway tool calls and prevent infinite loops.
- ›Adds stream_sub_agent_events support across all Context Providers.
- ›Adds Marengo video embeddings support to TwelveLabsTools.
└──▷ BREAKING ON UPGRADE
- !The google_search method in ScavioTools now targets the Scavio Google v2 API, changing parameter mapping to gl, hl, and start for localization and paging — existing integrations relying on the v1 API will break.
v2.8.1 Jul 23, 2026 · issue 002

Agno v2.8.1 adds Marengo video embeddings, a Slack peer-agent flag, and loop-prevention limits for learning stores.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.1
```
└──▷ USE IT
Enable a Slack-connected agent to respond to messages from other agents in the same workspace.
python
```
from agno.agent import Agent
from agno.tools.slack import SlackTools

agent = Agent(
    tools=[SlackTools(respond_to_other_agents=True)],
)
agent.print_response('Check if any peer agents have posted updates in #alerts', stream=True)
```
Cap tool calls during knowledge extraction to prevent runaway loops in a learning store.
python
```
from agno.learning import LearningStore

store = LearningStore(
    extraction_tool_call_limit=10,
)
```
- ›Adds respond_to_other_agents flag to the Slack integration to enable peer-agent communication between Slack-connected agents.
- ›Adds extraction_tool_call_limit to Learning Stores to cap tool calls and prevent infinite extraction loops.
- ›Adds stream_sub_agent_events support across all Context Providers.
- ›Adds Marengo video embedding support to TwelveLabsTools.
└──▷ BREAKING ON UPGRADE
- !The google_search tool in ScavioTools now targets the Scavio Google v2 API, changing localization and paging behavior for any existing integrations.
v2.8.0 Jul 20, 2026 · issue -030

Agno v2.8.0 adds a scorer framework, rollout environments for pass@k evaluation, and new Gmail/Adanos/file-generation tools.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.8.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.8.0
```
└──▷ USE IT
Export passing rollout attempts as conversational-SFT JSONL for fine-tuning, with a provenance sidecar automatically included.
python
```
results.to_sft_jsonl("passing_attempts.jsonl")
```
- ›Adds agno.scorer module with CodeScorer (wraps any callable returning bool | float | Score), JudgeScorer (LLM judge with numeric verdicts normalized via (score - 1) / 9), and ToolCallScorer (deterministic check of tool executions, rejecting refused, errored, or HITL-rejected calls) — all three ship sync and async variants.
- ›Adds agno.environments with Environment, Task, and run_rollouts(env, k=8) to run each task K times in full isolation (fresh db/session/user, no memory/knowledge/learning writes, cache off), enabling pass@k evaluation with a live per-attempt grid and real pass-rate tracking.
- ›Adds to_sft_jsonl(...) on the rollout environment to export passing attempts as conversational-SFT JSONL with a provenance sidecar.
- ›Adds save, load, diff, and learning_zone() methods to the rollout environment for managing and comparing evaluation runs.
- ›Adds Case.scorer field to plug any scorer into an eval Case alongside Case.expected; SuiteResult.to_dict() gains additive score_value, score_passed, and score_reason keys.
+3 moreshow less
- ›Adds max_results_per_request parameter and pagination support to Gmail Tools.
- ›Adds optional Adanos market sentiment tools.
- ›Adds code file generation capability to FileGenerationTools.
└──▷ BREAKING ON UPGRADE
- !ReliabilityEval now satisfies tool expectations only on a clean execution via RunOutput.tools (with tool_call_error not set), not on message-side requests — verdicts that previously passed may flip red after upgrading, with missing entries annotated '... (requested but refused/errored — execution matching, new in 2.8.0)'. Argument checks move to ToolExecution.tool_args.
- !Every AgentAsJudgeEval now fences judged output behind a per-call random nonce; a literal </output> no longer escapes the block. Judge verdicts and token counts may shift after upgrading.
v2.7.4 Jul 17, 2026 · issue -033

Agno v2.7.4 adds SuperserveTools, PlivoTools, The Context Company observability, and expanded Telegram/Tavily/Google toolkit methods.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.7.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.7.4
```
└──▷ USE IT
Run agent-generated code in an isolated Firecracker sandbox for a long-running agent task.
python
```
from agno.agent import Agent
from agno.tools.superserve import SuperserveTools

agent = Agent(tools=[SuperserveTools()])
agent.print_response('Write and execute a Python script that processes this dataset')
```
Send an SMS or make a voice call from an agent using Plivo credentials.
python
```
from agno.agent import Agent
from agno.tools.plivo import PlivoTools

agent = Agent(tools=[PlivoTools()])
agent.print_response('Send an SMS to +15551234567 saying the nightly scan is complete')
```
- ›Adds SuperserveTools class to run agent-generated code and manage files inside Superserve, a Firecracker-based sandbox platform designed for long-running agents.
- ›Adds PlivoTools class to send SMS, make voice calls, and look up phone numbers via Plivo.
- ›Adds pin_message, get_chat, get_file, and react_with_emoji methods to TelegramTools, plus save_downloads and output_directory options to save downloaded files to disk.
- ›Adds domain, date range, topic, and country filter parameters to TavilyTools searches.
- ›Adds observability integration to trace agent runs with The Context Company.
+3 moreshow less
- ›Enhances agno create with interactive starter template and project name prompts, four new starters (Azure, Helm, Modal, Render), and automatic .env seeding.
- ›Enables OxylabsTools to return full page content as Markdown.
- ›Workflows now accept run_context in Router selectors and Condition evaluators (deprecating session_state).
v2.7.3 Jul 14, 2026 · issue -036

Agno v2.7.3 adds ValkeyDb storage and vector store, RedmineTools, TokenLab provider, and AG-UI human-in-the-loop support
└──▷ GET THIS VERSION
```
$ git clone --branch v2.7.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.7.3
```
- ›Adds ValkeyDb as a fast in-memory database backend for agents, teams, and workflows.
- ›Adds ValkeyDB vector store with both vector and keyword search capabilities.
- ›Adds RedmineTools to manage issues, comments, and time logs against a Redmine project management instance.
- ›Adds TokenLab as a new OpenAI-compatible model provider.
- ›Extends AG-UI with human-in-the-loop confirmation, input, and feedback flows.
v2.7.2 Jul 9, 2026 · issue -041

Agno v2.7.2 adds OAuth on the AgentOS MCP endpoint, AG-UI client tools, and multi-target agno connect enhancements.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.7.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.7.2
```
└──▷ USE IT
Enable OAuth-protected MCP access on an AgentOS instance so only authenticated clients can connect.
python
```
from agno.agent_os import AgentOS

agent_os = AgentOS(mcp_auth=...)
```
- ›Adds mcp_auth parameter to AgentOS(...) to configure OAuth support on the AgentOS MCP endpoint.
- ›Renames AgentOS parameter enable_mcp_server to mcp_server and folds in mcp_config.
- ›Adds client_tools support for AG-UI frontend tools.
- ›Enhances agno connect with multi-target select, disconnect, restart hints, and identity-named entries.
└──▷ BREAKING ON UPGRADE
- !The enable_mcp_server parameter on AgentOS is renamed to mcp_server; existing code using enable_mcp_server will break.
v2.7.0 Jul 7, 2026 · issue -043

Agno v2.7.0 adds service account PATs, a full CLI (agnoctl), MCP Interface v2, an eval suite runner, and a discovery endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.7.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.7.0
```
└──▷ TRY IT
Wire up all supported coding-agent MCP clients (Claude Code, Cursor, Codex, etc.) to a running AgentOS in one step, minting a named shared PAT.
```
$ uvx agno connect --name ci-bot
```
Rotate a compromised PAT without touching your AgentOS deployment.
```
$ agno tokens revoke agno_pat_abc123xyz
```
- ›Adds agno connect command (via uvx agno connect) that discovers an AgentOS, mints per-client PATs (--name for a shared token), writes MCP config for Claude Code, Claude Desktop, Cursor, Codex, and ChatGPT, and verifies each connection — no manual JSON editing.
- ›Adds agno tokens create/list/revoke commands to mint, inventory, and rotate Personal Access Tokens (agno_pat_... machine identities) with SHA-256-hashed storage, per-user scoping, and revocation support.
- ›Adds agno create command to scaffold a new AgentOS project from a template (agentos-<provider>).
- ›Adds agno up, agno down, agno restart, and agno status commands for lifecycle management of local AgentOS deployments.
- ›New agnoctl CLI distributed on PyPI and invoked as agno — the unified command surface for all of the above.
+6 moreshow less
- ›New agno.eval package introducing Case and run_cases with a CLI runner supporting team subjects and numeric judge scoring.
- ›New GET /info discovery endpoint reporting agno_version, mcp.enabled, mcp.path, and auth_mode so external tooling can inspect an AgentOS before connecting.
- ›New MCP Interface v2 exposes an 8-tool operator surface at /mcp: get_agentos_config, run_agent, run_team, run_workflow, continue_run, cancel_run, get_sessions, and get_session_runs; includes MCP progress notifications for long-running tools and a HITL continue/cancel lifecycle.
- ›Adds result_mode="full" escape hatch in MCPServerConfig to opt out of the new trimmed run-result shape.
- ›Single AuthMiddleware on the parent app now covers REST, /mcp, and WebSocket transports; JWTMiddleware is preserved as an alias for backward compatibility.
- ›A2A/AGUI routes now enforce authorization (scope-mappings merged per-interface at the mount prefix, gating custom prefixes too).
└──▷ BREAKING ON UPGRADE
- !MCP surface shrunk from 19 to 8 tools — session-write and memory-CRUD tools are no longer exposed via MCP; MCPServerConfig(include_tags={"memory"}) now fails Pydantic validation and callers must use REST endpoints instead.
- !MCP run results are trimmed by default — clients consuming the raw RunOutput shape must handle the new trimmed shape or set result_mode="full" in MCPServerConfig.
- !AgentOS(authorization=True) without JWT keys now raises ValueError at construction instead of silently serving an open instance; set JWT_VERIFICATION_KEY or JWT_JWKS_FILE env vars, or pass verification_keys/jwks_file via authorization_config.
- !The AGNO_OS_URL environment variable is renamed to AGENTOS_URL; any environment or CI config referencing the old name must be updated.
v2.6.22 Jul 3, 2026 · issue -047

Agno v2.6.22 adds TwelveLabsTools, SofyaTools, and SearchApiTools plus a base Toolkit timeout parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.22 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.22
```
└──▷ USE IT
Integrate TwelveLabs video analysis into an Agno agent to analyze uploaded video content.
python
```
from agno.tools.twelvelabs import TwelveLabsTools

tools = TwelveLabsTools()
agent = Agent(tools=[tools])
```
- ›Adds TwelveLabsTools class for video analysis and multimodal text embedding generation via the TwelveLabs API.
- ›Adds SofyaTools class exposing search, extract, and research capabilities.
- ›Adds SearchApiTools class with Google, News, Images, and YouTube search methods.
- ›Adds timeout parameter to the base Toolkit class, wiring HTTP timeouts across tools and extending timeout support to additional toolkits.
v2.6.21 Jul 2, 2026 · issue -048

LocalFileSystemTools gains file-read support and directory confinement controls via new flags.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.21 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.21
```
└──▷ USE IT
Allow an agent to read files while keeping all operations inside a sandboxed directory.
python
```
from agno.tools.local_file_system import LocalFileSystemTools

tools = LocalFileSystemTools(
    target_directory="/data/agent-workspace",
    enable_read_file=True,
    restrict_to_base_dir=True,
)
```
- ›Adds enable_read_file flag to LocalFileSystemTools to expose a read-file tool to agents.
- ›Adds restrict_to_base_dir flag to LocalFileSystemTools to confine all file operations within target_directory by default; set restrict_to_base_dir=False to opt out.
v2.6.20 Jun 26, 2026 · issue -054

Agno v2.6.20 adds ClickHouse trace storage, Scavio search, LiteLLM structured outputs, and OpenAI web-search citations.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.20 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.20
```
└──▷ USE IT
Enable native structured outputs for a LiteLLM provider that supports the feature natively.
python
```
from agno.models.litellm import LiteLLM

model = LiteLLM(
    model="openai/gpt-4o",
    supports_native_structured_outputs=True,
)
```
Read citations returned from an OpenAI web-search response to attribute sources in your application.
python
```
from agno.models.openai import OpenAIChat
from agno.agent import Agent

agent = Agent(model=OpenAIChat(id="gpt-4o"))
response = agent.run("What happened in AI news today?")
print(response.citations)
```
- ›Enables supports_native_structured_outputs and supports_json_schema_outputs per-provider flags on LiteLLM to activate native structured outputs and JSON schema outputs.
- ›Surfaces web-search citations on response.citations for OpenAIChat and OpenAILike providers.
- ›Adds ClickHouseDB as a backend for high-volume trace ingest and OLAP scans.
- ›Adds a new Scavio search toolkit integration.
- ›Removes the hard cap on quick_prompts (previously limited to 3) per agent, team, or workflow in AgentOS.
+1 moreshow less
- ›Supports FastAPI >= 0.137 so get_routes() lists every registered route.
v2.6.19 Jun 23, 2026 · issue -057

Agno v2.6.19 adds tool-batch checkpointing with a unified /continue endpoint and a new StudioTool for dynamic agent/team/workflow composition.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.19 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.19
```
└──▷ USE IT
Use raw regex strings in PII guardrail patterns without pre-compiling them.
python
```
from agno.guardrails import PIIDetectionGuardrail

guardrail = PIIDetectionGuardrail(
    custom_patterns=[r'\b\d{3}-\d{2}-\d{4}\b', r'\bACCT-\d{8}\b']
)
```
- ›Adds StudioTool toolkit for dynamic composition of agents, teams, and workflows at runtime.
- ›Adds tool-batch-level checkpointing and a unified /continue endpoint supporting both regenerate and fork-a-run workflows, plus session forking support.
- ›Extends custom_patterns on PIIDetectionGuardrail to accept raw regex strings in addition to compiled patterns.
- ›ClickHouse and Pinecone vector DBs now expose their supported search types via get_supported_search_types().
v2.6.15 Jun 15, 2026 · issue -065

Agno v2.6.15 adds identity-aware, scoped MCP tool registration via a single MCPServerConfig object
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.15 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.15
```
- ›Adds MCPServerConfig to configure the AgentOS MCP server (/mcp): register custom tools (plain callables or Agno @tool/Functions), scope built-ins with enable_builtin_tools=False, filter with include_tags/exclude_tags, inject the authenticated caller's JWT subject via a declared user_id parameter (hidden from the client schema), gate calls with an authorize function, and enable DNS-rebinding protection via allowed_hosts/allowed_origins — all in data, no custom middleware classes required.
v2.6.14 Jun 12, 2026 · issue -068

Agno v2.6.14 adds CRUD endpoints for learnings on AgentOS.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.14 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.14
```
- ›Adds create, read, update, and delete endpoints for learnings on AgentOS.
v2.6.13 Jun 10, 2026 · issue -070

Agno v2.6.13 adds sub-agent event streaming, AgentOS registry auto-population, socket-based HITL workflows, and a Slack app manifest.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.13 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.13
```
- ›Sub-agent events from the context provider update tool now stream through to the parent run, enabling real-time observability of nested agent activity.
- ›The AgentOS registry now auto-populates from agents, teams, and workflows, eliminating manual registration.
- ›Adds socket support for human-in-the-loop (HITL) workflows, enabling interactive pause-and-resume over persistent socket connections.
- ›Adds a Slack app manifest for the AgentOS interface, simplifying Slack app setup and deployment.
v2.6.12 Jun 5, 2026 · issue -075

Agno v2.6.12 adds HTML file generation, AG-UI state events, and Tuning Engines as a new model provider
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.12
```
- ›Adds Tuning Engines as a new model provider, expanding the range of backends agents can target.
- ›Adds AG-UI state events support, enabling state change signaling within the AG-UI protocol.
- ›Adds HTML file generation support with an example app, allowing agents to produce HTML file outputs.
- ›Adds Latitude via OpenInference as an observability integration example.
- ›Adds WorkOS example for role-based access control (RBAC).
+1 moreshow less
- ›Upgrades MiniMax default model to M3.
v2.6.11 Jun 2, 2026 · issue -078

Agno v2.6.11 adds Task API and Monitor API tools for parallel web plus a new Manifest for AgentOS UI metadata.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.11
```
- ›Adds Manifest for per-entity AgentOS UI metadata configuration.
- ›Adds Task API and Monitor API integration tools for parallel web workflows.
v2.6.10 Jun 2, 2026 · issue -078

Agno v2.6.10 adds four new model providers, YouTools, DOCX generation, context-provider streaming, and a files field on RunCompleted.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.10
```
└──▷ USE IT
Use You.com search inside an agent to ground responses in live web results.
python
```
from agno.agent import Agent
from agno.tools.you import YouTools

agent = Agent(tools=[YouTools()], show_tool_calls=True)
agent.print_response('What are the latest AI model releases this week?')
```
- ›Adds files field on the RunCompleted event, exposing generated files at run completion.
- ›Adds YouTools class for You.com Search API integration.
- ›Adds DOCX file generation support.
- ›Adds google-interactions provider to the model string parser.
- ›Adds knowledge and managers support in the agent registry.
+6 moreshow less
- ›Streams sub-agent events from context providers.
- ›Persists cancelled runs properly for agents, teams, and workflows.
- ›Adds Inception Labs model provider integration.
- ›Adds Xiaomi MiMo model provider.
- ›Adds MiniMax model provider (M2.7).
- ›Adds Cloudflare AI Gateway model provider.
v2.6.9 May 21, 2026 · issue -090

Agno v2.6.9 exposes full resolved approval records to post-hooks via run_response.metadata["approval"]
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.9
```
└──▷ USE IT
Inspect who approved (or rejected) a run inside a post-hook — useful for audit logging or conditional downstream actions.
python
```
def my_post_hook(run_response):
    approval = run_response.metadata.get("approval")
    if approval:
        print(approval["resolved_by"], approval["resolved_at"])
```
- ›Adds cookbook/07_knowledge/04_advanced/06_prefix_search.py demonstrating the help-center typeahead use case for PgVector(prefix_match=True).
v2.6.8 May 19, 2026 · issue -092

Agno v2.6.8 adds Antigravity API support, Gemini managed agents (Deep Research + Antigravity), and centralized path-safety utilities.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.8
```
└──▷ USE IT
Use safe_join to safely resolve user-supplied paths and avoid path-traversal vulnerabilities in custom tools.
python
```
from agno.utils.path_safety import safe_join, PathSecurityError

try:
    safe_path = safe_join("/var/app/uploads", user_input_filename)
except PathSecurityError as e:
    print(f"Blocked unsafe path: {e}")
```
- ›Adds AntigravityAgent (a BaseExternalAgent served through AgentOS with native sessions, streaming, and UI) for first-party Google Antigravity API integration.
- ›Adds AntigravityTools (a Toolkit) so any Agno agent can delegate sub-tasks to a managed Antigravity sandbox.
- ›Adds GeminiInteractions support for Google's managed Deep Research agent — autonomous research with citations, background streaming with reconnect, and last_event_id resume.
- ›Adds GeminiInteractions support for Google's managed Antigravity agent — general-purpose agent running in a managed Linux sandbox.
- ›Adds agent, agent_config, and environment fields to GeminiInteractions for selecting and configuring managed agents, with per-agent forcing of background and store.
+5 moreshow less
- ›Adds mcp_servers and file_search_store_names support on the GeminiInteractions agent path.
- ›Introduces agno.utils.path_safety module with safe_join and safe_join_subpath, hardening FileGenerationTools, SlackTools, Toolkit._check_path, agno.skills.utils.is_safe_path, and FileTools.check_escape against path traversal, symlink escape, control-char injection, Windows MagicDot, and Unicode normalization attacks.
- ›Introduces PathSecurityError (raised on path-safety violations); FileGenerationSecurityError is kept as a deprecation alias.
- ›Adds 18 self-contained data-labeling workflows to cookbook/data_labeling/, covering text, image, audio, video, document, and composed (LLM-as-judge, quality review) labeling primitives.
- ›Adds a deterministic Slack HITL incident-commander demo to cookbook/, demonstrating structured pauses via tool_choice='required', user-input echo, and clean termination via stop_after_tool_call=True.
└──▷ BREAKING ON UPGRADE
- !The available_models field is removed from EvalsDomainConfig; the only supported source for the Evals UI dropdown is now AgentOSConfig.available_models.
v2.6.7 May 15, 2026 · issue -096

Agno v2.6.7 adds GeminiInteractions model, per-user AgentOS data isolation, and an allowed_hosts guard on URL-fetching knowledge readers.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.7
```
└──▷ USE IT
Instantiate the new stateful Gemini interactions model when you need multi-turn conversation state managed server-side by Google.
python
```
from agno.models.gemini import GeminiInteractions

model = GeminiInteractions()
```
Restrict a URL-fetching knowledge reader to only allowed domains, preventing unintended outbound SSRF-style fetches.
python
```
from agno.knowledge.url import URLKnowledgeBase

kb = URLKnowledgeBase(
    urls=["https://docs.example.com/sitemap.xml"],
    allowed_hosts=["docs.example.com"],
)
```
- ›Adds GeminiInteractions model class to leverage Google's stateful interactions API.
- ›Adds allowed_hosts parameter to URL-fetching knowledge readers to restrict which hosts agents may fetch from.
- ›Adds opt-in per-user data isolation layer for AgentOS authenticated endpoints.
v2.6.6 May 14, 2026 · issue -097

Agno v2.6.6 adds Slack HITL multi-row approvals and a NotionDatabaseBackend for wiki context.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.6
```
- ›Adds NotionDatabaseBackend to the WikiContextProvider, enabling Notion databases as a knowledge source for agents.
- ›Adds HITL multi-row approvals with all pause types to the Slack interface.
- ›Warns on duplicate tool names when registering tools on an agent or team.
v2.6.5 May 6, 2026 · issue -105

Agno v2.6.5 adds Gemini multimodal file search, Gmail/Calendar context providers, Mongo scheduler support, and new workflow error handling.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.5
```
└──▷ USE IT
Restrict an agent's LLMsTxt fetching to only trusted domains to prevent SSRF-style abuse in agentic pipelines.
python
```
from agno.tools.llms_txt import LLMsTxtTools

tools = LLMsTxtTools(allowed_hosts=["docs.example.com", "api.example.com"])
```
Enable file download and upload capabilities in a Slack-connected agent for workflows that need to handle attachments.
python
```
from agno.context.slack import SlackContextProvider

provider = SlackContextProvider(enable_media_tools=True)
```
- ›Adds allowed_hosts parameter to LLMsTxtTools so agents only fetch from explicitly trusted hosts.
- ›Adds enable_media_tools flag (default: False) to SlackContextProvider to control file download/upload; when enabled, exposes download_file in read tools and upload_file in write tools.
- ›Adds on_error handling to the Condition workflow step, giving control over error propagation when sub-steps fail.
- ›Adds GmailContextProvider and CalendarContextProvider, following the same pattern as existing GDriveContextProvider, SlackContextProvider, and DatabaseContextProvider.
- ›Extends GDriveContextProvider to support OAuth authentication in addition to service account auth.
+2 moreshow less
- ›Adds scheduler support for MongoDb and AsyncMongoDb backends, enabling agents, teams, and workflows to run on a cron schedule in AgentOS.
- ›Adds multimodal support in the Gemini File Search API (requires google-genai>=1.75.0), enabling image and other media types alongside text in file search workflows.
v2.6.4 Apr 28, 2026 · issue -113

Agno v2.6.4 adds WikiContextProvider with filesystem, git, and web backends plus read/write control.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.4
```
- ›Adds WikiContextProvider class with filesystem and git backends, web ingestion support, and read/write flags for controlling access.
v2.6.3 Apr 28, 2026 · issue -113

Agno v2.6.3 adds WorkspaceContextProvider for project-aware repo context and expands SlackContextProvider with opt-in workspace search.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.3
```
└──▷ USE IT
Enable Slack workspace search in SlackContextProvider for broader channel discovery without using the removed factory methods.
python
```
from agno.context.slack import SlackContextProvider

provider = SlackContextProvider(enable_workspace_search=True)
context = provider.get_context()
```
- ›Adds WorkspaceContextProvider, a project-aware context provider for repository roots backed by the read-only Workspace toolkit instead of generic FileTools; centralizes local filesystem exclude patterns so both FileTools and Workspace skip .context, .venvs, and other agent/dependency/build noise by default.
- ›Adds exclude_patterns parameter to FilesystemContextProvider for explicit opt-out or customization of filesystem exclusions.
- ›Adds opt-in enable_workspace_search parameter to SlackContextProvider; tools are now self-documenting via SlackTools, removing runtime agent switching.
- ›Removes for_bot_read(), for_assistant_search(), and for_write() factory methods from SlackContextProvider in favor of explicit flags for direct construction.
└──▷ BREAKING ON UPGRADE
- !The for_bot_read(), for_assistant_search(), and for_write() factory methods have been removed from SlackContextProvider; callers must switch to explicit flags on construction.
v2.6.2 Apr 27, 2026 · issue -114

Agno v2.6.2 adds a Workspace toolkit giving agents read/write/shell access to a local directory tree with HITL confirmation gates.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.2
```
- ›Adds WorkspaceTools toolkit exposing read, list, search, write, edit, move, delete, and shell operations scoped to a root directory tree, with destructive operations gated by Agno's built-in human-in-the-loop confirmation by default.
v2.6.1 Apr 24, 2026 · issue -117

Agno v2.6.1 adds multi-block Claude prompt caching, a ParallelMCPBackend for web search, and deterministic tool ordering across all model providers.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.1
```
└──▷ USE IT
Enable tool-prefix caching on Claude so repeated calls with the same tool set skip re-encoding the tool definitions.
python
```
from agno.models.anthropic import Claude

model = Claude(id="claude-opus-4-5", cache_tools=True)
```
Use ParallelMCPBackend for web search and fetch inside an agent, with a higher-rate-limit API key.
python
```
import os
from agno.agent import Agent
from agno.tools.web_context import WebContextProvider
from agno.tools.mcp.parallel import ParallelMCPBackend

os.environ["PARALLEL_API_KEY"] = "<your-key>"

agent = Agent(
    tools=[WebContextProvider(backend=ParallelMCPBackend())]
)
```
- ›Adds system_prompt_blocks: List[SystemPromptBlock] field on Claude — each block carries text, cache, and an optional per-block ttl ("5m" or "1h") that overrides the model-level extended_cache_time flag.
- ›Adds cache_tools: bool field on Claude (Anthropic, AWS Bedrock, and VertexAI) to attach cache_control to the last tool so the tool prefix is cached.
- ›Adds ParallelMCPBackend as a new web backend for WebContextProvider, connecting to search.parallel.ai/mcp and exposing web_search and web_fetch (compressed markdown output); keyless by default, Bearer-auth via PARALLEL_API_KEY for higher rate limits, and optional OAuth via use_oauth=True; defaults to a 30s timeout.
- ›Deterministic tool ordering in Model._format_tools (sort by name) keeps request prefixes stable across runs so prompt caches actually hit; applies across Anthropic, OpenAI, Gemini, and Bedrock.
- ›Maps the "openai:" model string prefix to OpenAIResponses (e.g. Agent(model="openai:gpt-5.4") resolves to OpenAIResponses(id="gpt-5.4")); adds "openai-chat:" prefix as a fallback for users who still need OpenAIChat.
v2.6.0 Apr 23, 2026 · issue -118

Agno v2.6.0 adds HITL for Teams and Workflows, runtime Factories, multi-framework AgentOS support, and a new Context Provider API.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.6.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.6.0
```
└──▷ TRY IT
Filter the /sessions endpoint by type to retrieve only workflow sessions after the default-all-types change.
```
$ curl -X GET 'https://<agentOS-host>/sessions?type=workflow' \
  -H 'Authorization: Bearer <token>'
```
- ›Adds AgentFactory, TeamFactory, and WorkflowFactory for dynamically creating Agents, Teams, and Workflows at runtime, enabling multi-tenant use cases.
- ›Adds agno.context — a first-party API for plugging external sources (filesystem, web, SQL database, Slack, Google Drive, MCP server) into an agent as a natural-language tool.
- ›Adds an API layer for Team human-in-the-loop (HITL) with support in the AgentOS chat page, including Team Approvals.
- ›Adds executor-level HITL support for Workflow steps (WorkflowExecutor) when a pause-tool flow is configured on an agent or team within a workflow step.
- ›Adds reconnection and resume capability for Agent/Team runs using SSE in AgentOS, allowing interrupted sessions to continue from where they left off.
+1 moreshow less
- ›Adds multi-framework support (Beta) in AgentOS for ClaudeAgentSDK, Langgraph, and DSPy via a unified AgentProtocol backbone.
└──▷ BREAKING ON UPGRADE
- !The /sessions endpoint now returns all session types (agent, team, and workflow) by default instead of a filtered subset; existing callers that relied on a single type must add ?type=agent, ?type=team, or ?type=workflow to their requests to restore the previous behaviour.
v2.5.17 Apr 15, 2026 · issue -126

Agno v2.5.17 adds per-request GitHub repo targeting and a toggle to disable Claude file citations.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.17 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.17
```
- ›Adds option to disable Claude file citations (PR #7511).
- ›Allows GitHubConfig repo to be specified per request rather than only at configuration time (PR #7496).
v2.5.16 Apr 10, 2026 · issue -131

Agno v2.5.16 adds LLMsTxtTools, SalesforceTools, Azure AI Foundry Claude, and OpenAI Responses background mode
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.16 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.16
```
- ›Adds LLMsTxtTools and LLMsTxtReader classes for consuming the llms.txt standard, enabling agents to index LLM-friendly documentation from sites that expose a /llms.txt endpoint (e.g. https://docs.agno.com/llms.txt).
- ›Adds SalesforceTools for integrating Salesforce CRM data and actions into agents.
- ›Adds Azure AI Foundry Claude as a new model provider.
- ›Adds background mode support for the OpenAI Responses API.
v2.5.15 Apr 9, 2026 · issue -132

Agno v2.5.15 adds Team skills, nested workflows, post-execution HITL output review, and new SessionSummaryManager controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.15 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.15
```
└──▷ TRY IT
Enable full tracebacks in error logs during development to diagnose agent failures without changing code.
```
$ AGNO_LOG_TRACEBACKS=true python my_agent.py
```
Limit how much history is fed into session summaries to keep token costs predictable for long-running sessions.
python
```
from agno.memory import SessionSummaryManager

summary_manager = SessionSummaryManager(
    last_n_runs=10,
    conversation_limit=4000
)
```
- ›Adds requires_output_review on Step, Router, and Loop to pause a workflow after a step runs and allow human review, approval, rejection with feedback, retry, or output editing before execution continues.
- ›Consolidates HITL parameters into a HumanReview config class — pass human_review=HumanReview(...) on Step, Loop, and Router instead of flat params; fully backward compatible.
- ›Adds last_n_runs and conversation_limit parameters to SessionSummaryManager to control how much conversation history is included when generating session summaries.
- ›Adds AGNO_LOG_TRACEBACKS environment variable (opt-in, off by default) to enable full tracebacks in log_error and log_warning.
- ›Adds skills support to Team, enabling teams to use shared skill sets.
+1 moreshow less
- ›Supports nested workflows — a Workflow can now be used as a step inside another Workflow.
v2.5.14 Apr 2, 2026 · issue -139

Agno v2.5.14 adds fallback model chains for Agents and Teams, SAS token auth for Azure Blob, and a Slack workspace search tool.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.14 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.14
```
└──▷ USE IT
Route traffic to Claude automatically when a primary OpenAI-compatible endpoint is unavailable — useful for self-hosted or rate-limited model endpoints in production.
python
```
agent = Agent(
    model=OpenAIChat(id="gpt-4o", base_url="http://localhost:1/v1", retries=0),
    fallback_models=[Claude(id="claude-sonnet-4-20250514")],
)
```
- ›Adds fallback_models parameter to Agent and Team constructors, letting you specify an ordered list of backup models (e.g. Claude) that are tried automatically when the primary model fails.
- ›Adds SAS token authentication support to AzureBlobConfig for Azure Blob Storage connections.
- ›Adds a workspace search tool to SlackTools.
v2.5.13 Apr 1, 2026 · issue -140

Agno v2.5.13 adds a /info metadata endpoint, richer /sessions list fields, Slack show_member_tool_calls param, and ReliabilityEval subset matching.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.13 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.13
```
└──▷ USE IT
Show member tool calls inline when streaming agent responses to a Slack channel.
python
```
from agno.interface.slack import SlackInterface

slack = SlackInterface(
    agent=my_agent,
    show_member_tool_calls=True,
)
```
- ›Adds show_member_tool_calls param to the Slack Interface, plus automatic card overflow rotation that starts a new message when text exceeds the threshold.
- ›Enhances the AgentOS /sessions list API to return additional fields: user_id, agent_id, team_id, workflow_id, session_summary, metrics, total_tokens, and metadata.
- ›Adds the AgentOS /info API endpoint — a lightweight, unauthenticated call that returns agent, team, and workflow counts as instance metadata.
- ›Adds subset matching, argument validation, and missing tool call tracking to ReliabilityEval, with multi-round tool call collection support.
- ›Implements dynamic batch splitting for large upsert/query operations in ChromaDB.
+2 moreshow less
- ›Propagates chunk_size to default chunking strategies in reader classes.
- ›Enables channel summarization in the Slack interface.
v2.5.12 Mar 30, 2026 · issue -142

Agno v2.5.12 adds Docling tool integration and a new SchedulerTools toolkit for agent-driven schedule management.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.12
```
- ›Adds SchedulerTools toolkit, enabling agents to programmatically manage schedules.
- ›Adds DoclingTool integration with tests and cookbook example for document parsing and conversion within agents.
v2.5.11 Mar 26, 2026 · issue -146

Agno v2.5.11 adds Google Slides toolkit, GoogleAuth, PerplexitySearch, cross-model tool call compatibility, and custom prompts for AgenticChunking.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.11
```
- ›Adds GoogleAuth toolkit and shared auth decorator to unify authentication across Google toolkits.
- ›Adds GoogleSlidesTools toolkit for creating, editing, and managing Google Slides presentations.
- ›Adds PerplexitySearch toolkit for integrating Perplexity-powered web search into agents.
- ›Adds custom prompt support to AgenticChunking, allowing callers to control how chunks are split.
- ›Adds cross-model tool call compatibility to support interchanging models within the same agent pattern.
+1 moreshow less
- ›Rewrites GoogleDriveTools with smart export and async support.
v2.5.10 Mar 17, 2026 · issue -155

Agno v2.5.10 adds Telegram interfaces, Docling document reader, MLflow tracing, WhatsApp V2 media/interactive support, and Vertex AI parallel search.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.10
```
└──▷ USE IT
Pass run-level dependency and session-state context when triggering a workflow programmatically.
python
```
workflow.run(
    metadata={"run_label": "nightly"},
    dependencies={"db": my_db_client},
    add_dependencies_to_context=True,
    add_session_state_to_context=True
)
```
Set a request timeout on a Gemini model to avoid hanging agent runs in production.
python
```
from agno.models.gemini import Gemini

model = Gemini(id="gemini-2.0-flash", timeout=30)
```
- ›Adds enable_encryption parameter to the WhatsApp Interface V2 for encrypting phone numbers.
- ›Adds version query parameter to GET /workflows/{id} to fetch specific workflow versions.
- ›Adds run-level parameters metadata, dependencies, add_dependencies_to_context, and add_session_state_to_context to Workflow.run() and arun().
- ›Adds timeout parameter to the Gemini model class.
- ›New Telegram interfaces for AgentOS supporting agents, teams, and workflows, with multi-modal support and /new command to start fresh conversations.
+6 moreshow less
- ›New Telegram Tools enabling agents to send photos, documents, videos, audio, animations, and stickers.
- ›WhatsApp Interface V2 adds media support (images, video, audio, documents), interactive messages (reply buttons, list menus, locations, reactions), Team/Workflow support, and /new command for fresh conversations.
- ›Integrates the Docling library as a new reader for advanced document processing across multiple file formats.
- ›Extends observability support with MLflow for full trace visibility into agent runs.
- ›Adds Parallel AI Search support for Vertex AI via native ToolParallelAiSearch integration.
- ›Adds mistralai v2 support while maintaining backward compatibility with v1.
v2.5.9 Mar 10, 2026 · issue -161

Agno v2.5.9 adds built-in followup suggestions, datetime_format, message history in tool hooks, and extended GoogleCalendarTools.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.9
```
└──▷ USE IT
Use ISO-8601 datetime formatting in an agent so its system prompt always receives a consistently formatted timestamp.
python
```
agent = Agent(
    model=...,
    datetime_format="%Y-%m-%dT%H:%M:%S"
)
```
Inspect or log the full message history inside a tool hook to audit what the agent has seen before a tool call fires.
python
```
def my_pre_hook(run_context, tool_call):
    history = run_context.messages
    for msg in history:
        print(msg)

agent = Agent(
    model=...,
    tool_hooks=[my_pre_hook]
)
```
- ›Adds datetime_format parameter to Agent and Team for custom strftime formatting of datetime context (e.g., ISO-8601, date-only, localized).
- ›Exposes the current run's message history to tool pre/post hooks and agent-level tool_hooks via run_context.messages, with mutation safety.
- ›Adds built-in followup suggestion support to Agent and Team.
- ›Extends GoogleCalendarTools with new tools and service account authentication support.
v2.5.8 Mar 6, 2026 · issue -165

Agno v2.5.8 adds GitlabTools, human-readable agent IDs, GmailTools service-account auth, and AgentOS env-var overrides.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.8
```
└──▷ USE IT
Use GitlabTools to give an agent read access to a GitLab instance for repository inspection or CI pipeline queries.
python
```
from agno.tools.gitlab import GitlabTools

agent = Agent(
    tools=[GitlabTools()],
    ...
)
```
- ›Adds AGENT_OS_HOST and AGENT_OS_PORT environment variables as fallbacks to serve(), simplifying container and orchestrated deployments.
- ›Adds GitlabTools with read-focused GitLab integrations, async support, and cleaner tool configuration.
- ›Extends GmailTools with new tools and service account authentication.
- ›Agents and teams now generate Docker-style human-readable IDs (e.g., brave-falcon-7x3k) instead of UUIDs, making debugging and monitoring more intuitive.
v2.5.7 Mar 4, 2026 · issue -167

Agno v2.5.7 adds OpenAILikeEmbedder and a two-step session search pattern with configurable depth limits.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.7
```
└──▷ USE IT
Use OpenAILikeEmbedder to connect to a LiteLLM proxy or any OpenAI-compatible embedding endpoint.
python
```
from agno.embedder.openai_like import OpenAILikeEmbedder

embedder = OpenAILikeEmbedder(
    base_url="http://localhost:4000",
    api_key="sk-...",
    model="text-embedding-3-small",
)
```
- ›Adds OpenAILikeEmbedder class for providers with OpenAI-compatible embedding endpoints (e.g. LiteLLM proxy).
- ›Adds a search_past_sessions + read_past_session two-step pattern so agents and teams can browse previous sessions, with num_past_sessions_to_search and num_past_session_runs_in_search to control search scope and preview depth.
- ›Adds num_runs parameter to read_past_session so the model can fetch a subset of turns from long sessions instead of pulling full conversation history.
- ›Session previews in search_past_sessions now show per-run user/assistant pairs instead of a single message.
v2.5.6 Mar 2, 2026 · issue -169

Agno v2.5.6 adds GitHub App auth for knowledge sources, HEIC/HEIF uploads, approval endpoints, and advanced trace filtering DSL.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.6
```
└──▷ USE IT
Import Gmail tools from the new sub-package structure after the Google tools restructure.
python
```
from agno.tools.google import GmailTools

tools = GmailTools()
```
- ›Adds GitHub App authentication to GitHubConfig via app_id, installation_id, and private_key parameters, with thread-safe token caching and both sync/async variants, in addition to existing personal access token support.
- ›Adds image/heic and image/heif MIME type support to file upload endpoints.
- ›Adds an approval status endpoint and admin-gated continue-run enforcement for agent workflows.
- ›Adds advanced filtering DSL support for Traces in Agent OS.
- ›Restructures Google tools into the agno.tools.google sub-package, enabling imports such as from agno.tools.google import GmailTools; old import paths remain functional via backwards compatibility.
+1 moreshow less
- ›Adds tasks: List[TaskData] field (containing id, title, description, status, assignee, dependencies, result) and completion_summary to TaskStateUpdatedEvent for structured task data in TeamMode.tasks streaming.
v2.5.5 Feb 25, 2026 · issue -173

Agno v2.5.5 adds real-time Slack streaming, per-bot credentials, and image generation to ModelsLabTools.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.5
```
- ›Adds token and signing_secret per Slack instance, enabling multiple independent bots to run on the same server.
- ›Extends ModelsLabTools to support image generation (PNG/JPG) via ModelsLab's text-to-image API, completing the full ModelsLab media suite.
- ›Slack interface now streams responses in real-time with live progress cards for tool calls, reasoning, and workflow steps.
v2.5.4 Feb 24, 2026 · issue -174

Agno v2.5.4 adds workflow step-level HITL, PgVector similarity filtering, team task streaming, and richer per-component metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.4
```
└──▷ USE IT
Filter PgVector knowledge-base searches to only return results above a meaningful similarity threshold, reducing noise in RAG pipelines.
python
```
vector_db = PgVector(
    table_name="embeddings",
    db_url="postgresql://user:pass@localhost/db",
    similarity_threshold=0.75,
)
```
Restrict DuckDuckGo web searches to recent results in a specific region via the newly exposed parameters.
python
```
tools = DuckDuckGoTools(
    timelimit="w",
    region="us-en",
    backend="html",
)
```
- ›Adds similarity_threshold parameter to PgVector to filter search results by a minimum similarity score.
- ›Exposes timelimit, region, and backend parameters in DuckDuckGoTools for more controlled web searches.
- ›Adds Human-in-the-Loop (HITL) support at the Step level in Workflows, enabling pauses for confirmation and user input during execution.
- ›Adds streaming event support for TeamMode.tasks, enabling real-time event emission during autonomous task execution.
- ›Redesigns the metrics system to provide per-model, per-component granular tracking across the full agent/team/workflow lifecycle.
v2.5.3 Feb 19, 2026 · issue -179

Agno v2.5.3 adds remote S3 knowledge endpoints, PDF content sanitization, and OpenTelemetry extras.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.3
```
└──▷ USE IT
Disable PDF sanitization when extracting structured content like code blocks or tables where whitespace is semantically significant.
python
```
from agno.document.reader.pdf import PDFReader

reader = PDFReader(sanitize_content=False)
docs = reader.read("report_with_tables.pdf")
```
- ›Adds sanitize_content parameter to BasePDFReader (enabled by default) to normalize fragmented PDF text extraction — collapses word-per-line artifacts while preserving paragraph breaks; set sanitize_content=False to preserve structured content like code or tables.
- ›Adds API endpoints for listing remote knowledge contents and enables uploading content in S3 buckets via AgentOS.
- ›Adds is_component, current_version, and stage fields to list endpoints.
- ›Adds OpenTelemetry and Agno instrumentation dependencies to the os extras.
v2.5.1 Feb 15, 2026 · issue -183

Agno v2.5.1 adds CodingTools and UserFeedbackTools toolkits for agents.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.1
```
- ›Adds CodingTools toolkit for code-related operations in agents.
- ›Adds UserFeedbackTools toolkit for collecting user feedback from within agents.
v2.5.0 Feb 12, 2026 · issue -186

Agno v2.5.0 adds TeamMode execution strategies, an @approval decorator for HITL workflows, cron scheduling, and vector-search isolation for shared Knowledge stores.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.5.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.5.0
```
└──▷ USE IT
Run a team in broadcast mode to fan a single task out to all members simultaneously and collect their responses.
python
```
from agno.team import Team, TeamMode

team = Team(
    mode=TeamMode.broadcast,
    members=[analyst, researcher, summarizer],
)
team.run('Summarize the latest threat intelligence report')
```
Share one vector database across multiple Knowledge instances while keeping their search results isolated from each other.
python
```
from agno.knowledge import Knowledge

vuln_kb = Knowledge(
    name='vulnerabilities',
    isolate_vector_search=True,
)
patch_kb = Knowledge(
    name='patches',
    isolate_vector_search=True,
)
# Both can point at the same DB/table; searches will only return their own documents.
```
- ›Adds TeamMode enum with four execution modes: coordinate (default supervisor pattern), route (routes to a specialist and returns response directly), broadcast (delegates the same task to all members simultaneously), and tasks (autonomous task decomposition into a shared task list).
- ›Adds isolate_vector_search flag to the Knowledge class — when enabled, documents are tagged with linked_to metadata at insert time and searches filter by that tag, letting multiple Knowledge instances share one vector database with isolated results; defaults to False for backward compatibility.
- ›Adds store_history_messages config key to Agent/Team — set store_history_messages=True to restore the previous behavior of persisting conversation history (now defaults to False).
- ›New @approval decorator enables human-in-the-loop approval workflows: @approval(type='required') pauses a run until resolved via the Approvals API; @approval(type='audit') records a non-blocking audit trail for compliance and logging, with persistent status tracking (pending, approved, rejected, expired, cancelled).
- ›New Approvals API for listing, inspecting, and resolving approval records created by the @approval decorator.
+3 moreshow less
- ›Adds cron-based scheduling for agents, teams, and workflows with retry, timeout, and timezone support.
- ›Adds LearningMachine support for Teams, enabling persistent learning across team runs.
- ›Adds AWS EFS volume and mount point support for AWS app infrastructure.
└──▷ BREAKING ON UPGRADE
- !store_history_messages now defaults to False — existing setups that rely on persisted conversation history must explicitly set store_history_messages=True or history will no longer be stored.
- !Knowledge instances now require a unique combination of database, table, and knowledge name — multiple Knowledge instances cannot share the same table without distinct names, breaking any setup that reused a table across instances without differentiating names.
v2.4.8 Feb 3, 2026 · issue -195

Agno v2.4.8 adds CEL expression support for serializable workflow steps, a Neosantara LLM provider, and a visual Studio editor for AgentOS.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.8
```
└──▷ USE IT
Target the Neosantara Indonesian LLM gateway in an Agno agent without changing the rest of your OpenAI-compatible workflow.
python
```
from agno.agent import Agent
from agno.models.neosantara import Neosantara

agent = Agent(model=Neosantara(id="<model-id>"))
agent.print_response("Halo, apa kabar?")
```
- ›Adds CEL (Common Expression Language) expression support as evaluators in Condition, Loop, and Router workflow steps, making steps fully serializable as strings.
- ›Adds step_choices support in the Router step's selector function, enabling the router to return a group of steps as a single choice.
- ›Adds Neosantara as a new model provider — an Indonesian LLM gateway with an OpenAI-compatible API.
- ›Adds shebang parsing and Windows command building to Skills for cross-platform script execution.
- ›Introduces Studio: a visual drag-and-drop editor in AgentOS for building Agents, Teams, and Workflows, with a Registry for managing tools, models, databases, and schemas.
+1 moreshow less
- ›WebsiteReader now defaults to FixedSizeChunking instead of Semantic chunking, removing the implicit dependency on an OpenAI API key.
v2.4.7 Jan 28, 2026 · issue -201

Agno v2.4.7 adds else_steps for workflow conditions, a new AwsBedrockReranker, and HITL confirmation support for MCPTools.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.7
```
└──▷ USE IT
Define a fallback path in a workflow condition step when the primary condition is not met.
python
```
Condition(
    condition=my_condition,
    steps=[primary_step],
    else_steps=[fallback_step]
)
```
- ›Adds else_steps to workflow condition logic, enabling an alternative execution path instead of skipping when a condition is not met.
- ›New AwsBedrockReranker class supporting Cohere Rerank 3.5 and Amazon Rerank 1.0.
- ›Enables MCPTools to work with requires_confirmation_tools, adding human-in-the-loop confirmation support for MCP tool calls.
- ›Extends AwsBedrockEmbedder to support Cohere v4 Embed.
v2.4.5 Jan 26, 2026 · issue -203

Agno v2.4.5 adds Seltz Search toolkit and a new parameter to suppress knowledge search instructions in system prompts.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.5
```
└──▷ USE IT
Suppress auto-injected knowledge search instructions in the system prompt when you want full control over prompt content.
python
```
from agno.agent import Agent

agent = Agent(
    knowledge=my_knowledge_base,
    add_search_knowledge_instructions=False,
)
agent.run('What are our internal policies on data retention?')
```
Equip an agent with Seltz Search to let it query the Seltz search engine during reasoning.
python
```
from agno.agent import Agent
from agno.tools.seltz import SeltzTools

agent = Agent(
    tools=[SeltzTools()],
)
agent.run('Find recent research on LLM reasoning benchmarks.')
```
- ›Adds add_search_knowledge_instructions parameter to Agent and Team classes to control whether knowledge search instructions are injected into the system prompt.
- ›New SeltzTools toolkit integrating Seltz Search as a tool source for agents.
v2.4.4 Jan 26, 2026 · issue -203

Agno v2.4.4 adds UnsplashTools image search, Moonshot model provider, and a new external_execution_silent tool decorator param.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.4
```
└──▷ USE IT
Give an agent access to high-quality royalty-free images from Unsplash for content generation or research workflows.
python
```
from agno.tools.unsplash import UnsplashTools

agent = Agent(tools=[UnsplashTools()], ...)
```
- ›Adds external_execution_silent parameter to the tool decorator to suppress placeholder strings from run response content during external tool execution.
- ›Adds UnsplashTools toolkit for searching and retrieving royalty-free images via the Unsplash API.
- ›Adds Moonshot (moonshot.ai) as a new model provider.
v2.4.3 Jan 23, 2026 · issue -206

Agno v2.4.3 adds ExcelReader for .xls and .xlsx knowledge ingestion
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.3
```
└──▷ USE IT
Ingest an Excel spreadsheet as a knowledge source for an agent
python
```
from agno.document.reader.excel import ExcelReader

reader = ExcelReader()
documents = reader.read("data/threat_intel.xlsx")
```
- ›Adds ExcelReader class for ingesting .xls and .xlsx files as knowledge sources
v2.4.2 Jan 22, 2026 · issue -207

Agno v2.4.2 adds Azure Blob Storage knowledge support and OpenAI Responses API compatibility for Ollama and OpenRouter.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.2
```
- ›Adds Azure Blob Storage as a private file-loading source for Knowledge, alongside the existing SharePoint and GitHub integrations.
- ›Adds support for the OpenAI Responses API specification for providers that implement it, including Ollama v0.13.3+ and OpenRouter (beta).
v2.4.1 Jan 21, 2026 · issue -208

Agno v2.4.1 adds N1N model provider, Excel knowledge ingestion, and private GitHub/SharePoint file support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.1
```
- ›Adds collect_metrics_on_completion flag to streaming runs, collecting metrics only from the final chunk rather than every streamed chunk.
- ›Adds tool_call_id to CustomEvent objects yielded from tools, enabling trace events to be linked back to their originating tool calls.
- ›Adds n1n.ai as a new OpenAI-compatible model provider.
- ›Adds first-class Excel ingestion (.xlsx/.xls) to Knowledge, parsing workbooks per sheet into separate documents with sheet metadata by routing through the existing CSV reader.
- ›Adds support for files in private GitHub and SharePoint repositories to be added to Knowledge, available in both the SDK and API.
v2.4.0 Jan 19, 2026 · issue -210

Agno v2.4.0 adds KnowledgeProtocol, Agent Builder persistence, new lifecycle events, and GCS file inputs for Gemini
└──▷ GET THIS VERSION
```
$ git clone --branch v2.4.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.4.0
```
└──▷ USE IT
Point TavilyTools at a self-hosted Tavily endpoint instead of the public API.
python
```
from agno.tools.tavily import TavilyTools

tools = TavilyTools(api_base_url="https://tavily.internal.example.com")
```
Restore XML-tagged instructions for an agent that relies on structured <instructions> blocks in its system prompt.
python
```
from agno.agent import Agent

agent = Agent(
    instructions=["Always respond in bullet points."],
    add_instruction_tags=True
)
```
- ›Adds api_base_url parameter to TavilyTools to point at custom-hosted Tavily instances.
- ›Adds add_instruction_tags=True option on Agent and Team to restore wrapping instructions in <instructions> XML tags (now omitted by default).
- ›Introduces KnowledgeProtocol interface so any custom knowledge implementation can be used with Agent and Team (only the main Agno implementation supports AgentOS Knowledge management).
- ›Introduces Agent Builder: Agent, Team, and Workflow configurations can now be persisted and managed in a database via new AgentOS endpoints for programmatic creation, retrieval, and updates.
- ›Adds new lifecycle events: ModelRequestStarted, ModelRequestCompleted, CompressionStarted, and CompressionCompleted; updates MemoryUpdateCompleted to include memory content.
+5 moreshow less
- ›Adds direct GCS URI and external URL support for Gemini file inputs.
- ›Adds db parameter to the AgentOS class that propagates to all agents, teams, and workflows without a database set, and also serves as the tracing database.
- ›Introduces update_memory_on_run as the replacement for the deprecated enable_user_memories.
- ›Replaces DDG web search tool with a generic WebSearchTools as the new default for web search in cookbooks and docs.
- ›Renames Knowledge.add_content() and its variants to insert() and insert_many() (old names still work but will be phased out of docs).
└──▷ BREAKING ON UPGRADE
- !Removed deprecated fields session_state, dependencies, and user_id from tool functions and hooks where RunContext has replaced them.
- !stream_intermediate_steps has been removed; use stream_events instead.
- !yield_run_response has been removed; use yield_run_output instead.
- !delegate_task_to_all_members has been removed from the Team class.
- !tracing_db on AgentOS is deprecated in favor of the new db parameter.
- !Instructions are no longer wrapped in <instructions> XML tags by default for Agent and Team; set add_instruction_tags=True to restore the previous behavior.
- !DDG web search tool is replaced by WebSearchTools as the default web search tool.
v2.3.26 Jan 13, 2026 · issue -216

Agno v2.3.26 adds per-request isolation for agents, teams, and workflows in shared FastAPI processes.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.26 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.26
```
- ›Improves request-level isolation for agents, teams, and workflows running in shared FastAPI processes, preventing state bleed between concurrent requests.
v2.3.25 Jan 12, 2026 · issue -217

Agno v2.3.25 adds LearningMachine for per-interaction agent learning and an AST-based CodeChunking strategy.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.25 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.25
```
- ›Adds LearningMachine, a unified learning system that coordinates multiple learning types — each with its own storage backend and retrieval pattern — so agents can learn from every interaction.
- ›Adds CodeChunking strategy that uses ASTs to split code into contextually relevant segments, complementing existing text-based chunkers.
v2.3.24 Jan 8, 2026 · issue -221

Agno v2.3.24 adds proxy support for Crawl4aiTools, base-directory sandboxing for PythonTools and MLXTranscribeTools, and heading-level chunking for MarkdownChunker.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.24 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.24
```
└──▷ USE IT
Lock a PythonTools instance to its base directory in production, or explicitly allow wider access during local development.
python
```
from agno.tools.python import PythonTools

# Production: default sandboxed behaviour (restrict_to_base_dir=True)
tools = PythonTools(base_dir="/app/workspace")

# Local dev: opt out of sandboxing
tools_open = PythonTools(base_dir="/app/workspace", restrict_to_base_dir=False)
```
Route web crawls through a corporate proxy when using Crawl4aiTools inside a restricted network.
python
```
from agno.tools.crawl4ai import Crawl4aiTools

tools = Crawl4aiTools(
    proxy_config={
        "server": "http://proxy.corp.example.com:8080",
        "username": "user",
        "password": "pass"
    }
)
```
Split a Markdown knowledge base on headings so each chunk stays within a single section.
python
```
from agno.document.chunking.markdown import MarkdownChunker

chunker = MarkdownChunker(split_on_headings=True)
```
- ›Adds proxy_config parameter to Crawl4aiTools for configuring proxy settings on the toolkit.
- ›Adds restrict_to_base_dir parameter to PythonTools and MLXTranscribeTools; by default both tools now block operations outside their contextual base directory — pass restrict_to_base_dir=False to opt out.
- ›Adds split_on_headings parameter to MarkdownChunker for fine-grained control over how chunks are separated.
- ›MongoDB connection handshake now includes Agno version metadata, improving connection identification when multiple applications share a cluster.
└──▷ BREAKING ON UPGRADE
- !PythonTools and MLXTranscribeTools now disallow operating outside the base directory by default; existing code that relies on out-of-directory access will break unless restrict_to_base_dir=False is explicitly set.
v2.3.23 Jan 7, 2026 · issue -222

Agno v2.3.23 adds async tool function support to Toolkit, automatically selected in async agent contexts.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.23 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.23
```
- ›Toolkit now supports async tool functions, automatically selected when the agent runs in an async context.
v2.3.22 Jan 6, 2026 · issue -223

Agno v2.3.22 adds the Skills class, dynamic MCP headers, A2A remote agent support, and JWT audience validation.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.22 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.22
```
└──▷ USE IT
Inject a per-request authorization token into every MCP tool call without hardcoding credentials.
python
```
from agno.tools.mcp import MCPTools

def my_header_provider():
    token = fetch_current_auth_token()  # your token-refresh logic
    return {"Authorization": f"Bearer {token}"}

tools = MCPTools(url="https://my-mcp-server.example.com", header_provider=my_header_provider)
```
Validate JWT tokens against a specific audience claim in an AgentOS deployment.
python
```
from agno.middleware.jwt import JWTMiddleware

middleware = JWTMiddleware(
    secret="<your-secret>",
    audience="https://api.myapp.example.com"
)
```
- ›Introduces the Skills class, enabling agents to be extended with capabilities defined by Anthropic's Agent Skill specification.
- ›Adds header_provider function parameter to MCPTools instances, allowing dynamic header generation (e.g. rotating auth tokens or per-user IDs) on each MCP tool call.
- ›Adds audience parameter to the JWTMiddleware constructor to set the expected audience when validating JWT tokens.
- ›MCPTools now defaults to StreamableHttp as the transport when a URL is present for connecting to external MCP servers.
- ›Adds A2AClient and support for the a2a protocol when using remote agents, enabling Google ADK agents to run as remote agents via AgentOS (beta).
+1 moreshow less
- ›Extends native reasoning support to OpenAI GPT-5.1 and 5.2, new Gemini 3, 3.5, and deepthink models, and new DeepSeek r1 and reasoner models.
v2.3.21 Dec 23, 2025 · issue -237

Agno v2.3.21 brings AgentAsJudge evals to AgentOS with full run configuration and listing support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.21 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.21
```
- ›AgentAsJudge evaluations are now fully supported on AgentOS: configure and trigger new runs, and view existing runs alongside other evals on the Evals page.
v2.3.20 Dec 22, 2025 · issue -238

Agno v2.3.20 adds async run cancellation via set_cancellation_manager() and reasoning_content extraction for LiteLLM models.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.20 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.20
```
└──▷ USE IT
Register a custom async cancellation manager so long-running agent runs can be cancelled cleanly in async contexts.
python
```
agent.set_cancellation_manager(my_custom_cancellation_manager)
```
- ›Adds set_cancellation_manager() to allow custom cancellation managers, with async method support for run cancellation workflows.
- ›Extracts reasoning_content from models that support it via the LiteLLM model wrapper.
v2.3.18 Dec 19, 2025 · issue -241

Agno v2.3.18 adds Google OAuth2 credentials file support for direct VertexAI authentication.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.18 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.18
```
- ›Supports a Google OAuth2 credentials file for direct VertexAI authentication in the Google VertexAI integration.
v2.3.17 Dec 19, 2025 · issue -241

Agno v2.3.17 adds RemoteAgent/Team/Workflow classes, AgentOSClient, and ChromaDB hybrid search with RRF fusion
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.17 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.17
```
- ›Adds RemoteAgent, RemoteTeam, and RemoteWorkflow classes for proxying Agents, Teams, and Workflows running on a remote AgentOS instance.
- ›Adds AgentOSClient class for connecting to and operating a remotely hosted AgentOS.
- ›Adds hybrid search for local ChromaDB combining dense vector similarity (semantic) with full-text search (keyword/lexical) via RRF fusion.
- ›Extends SemanticChunking to accept any Agno embedder (e.g. AzureOpenAI, Mistral), a model string, or a custom chonkie BaseEmbeddings implementation.
- ›Extends the AgentOS client WebSocket implementation to automatically reconnect interrupted Workflow sessions via socket.
v2.3.15 Dec 18, 2025 · issue -242

Agno v2.3.15 adds OpenRouter cost tracking in run metrics and a migrate-all-DBs endpoint via AgentOS.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.15 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.15
```
- ›Adds a cost field to run Metrics for OpenRouter-backed runs, enabling usage accounting across OpenRouter provider calls.
- ›Adds an endpoint to migrate all databases at once via AgentOS.
v2.3.14 Dec 17, 2025 · issue -243

Agno v2.3.14 adds reasoning streaming, new A2A endpoints, JSON schema structured outputs, and AgentOS reload controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.14 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.14
```
└──▷ USE IT
Control which files cause AgentOS to hot-reload — useful when you want changes to your YAML config to trigger a reload but ignore unrelated directories.
python
```
serve(reload_includes=['*.yaml', '*.yml'], reload_excludes=['tests/*', 'docs/*'])
```
Pass a provider-specific JSON schema directly to the model API for precise structured output control without Agno transforming it.
python
```
agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    output_schema={
        'type': 'json_schema',
        'json_schema': {
            'name': 'result',
            'strict': True,
            'schema': {
                'type': 'object',
                'properties': {'answer': {'type': 'string'}},
                'required': ['answer'],
                'additionalProperties': False
            }
        }
    }
)
```
- ›Adds reload_includes and reload_excludes parameters to the serve function of AgentOS, letting you specify which files trigger an app reload.
- ›Adds search_parameters to the search and async_search methods of the Milvus vector database class.
- ›output_schema now accepts JSON schemas in provider-specific formats, passed directly to the model API without transformation, giving full control over structured output for OpenAI, Claude, and OpenAI-like providers.
- ›Adds reasoning chunk streaming support when reasoning_model is provided.
- ›Adds new A2A interface endpoints to retrieve the Agent Card for any Agent, Team, or Workflow, and updates run endpoints for Agents, Teams, and Workflows to match the updated A2A protocol.
+2 moreshow less
- ›Updates the default model ID for the Gemini Embedder class to gemini-embedding-001.
- ›Error events are now always emitted during streaming runs, and runs containing errors are always persisted when relevant.
v2.3.13 Dec 15, 2025 · issue -245

Agno v2.3.13 adds JWT-based Role-Based Access Control to AgentOS with per-endpoint and per-agent scope enforcement.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.13 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.13
```
- ›Adds JWTMiddleware class to AgentOS for JWT-based authorization, requiring signed JWT tokens with user permission scopes on all traffic — verification_keys=[...] is the new recommended way to supply keys over the deprecated secret_key parameter.
- ›Supports per-endpoint authorization via configurable required scopes on each AgentOS endpoint.
- ›Supports per-agent (and per-Team, per-Workflow) resource control via scopes like agents:my-agent:read, restricting which users can invoke POST /agents/{id}/runs or read from GET /agents and GET /agents/{id}.
└──▷ BREAKING ON UPGRADE
- !The algorithm default on JWTMiddleware changed from HS256 to RS256; existing setups using the default with symmetric (HMAC) keys will fail to verify tokens on upgrade.
v2.3.12 Dec 12, 2025 · issue -248

Agno v2.3.12 adds token-count-based context compression support across providers.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.12
```
- ›Adds token count based compression via the Compression Manager, enabling context window management across providers based on token limits.
- ›Content hashing for knowledge ingestion now incorporates name and description fields for URLs, paths, and file_data, allowing multiple distinct content items from the same source to produce unique hashes.
└──▷ BREAKING ON UPGRADE
- !Existing knowledge content previously added with name or description fields will have different content hashes under v2.3.12, which may alter skip_if_exists and upsert behavior for that content.
v2.3.11 Dec 11, 2025 · issue -249

Agno v2.3.11 adds OpenAI-specific fields to RunOutput and RunCompletedEvent for streaming and non-streaming access.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.11
```
- ›Adds new OpenAI-specific fields to RunOutput and RunCompletedEvent classes via response_provider_data, exposing provider data in both streaming and non-streaming cases.
v2.3.10 Dec 10, 2025 · issue -250

Agno v2.3.10 adds ShopifyTools for store analytics and URL Context support for Gemini streaming.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.10
```
└──▷ USE IT
Analyze Shopify sales and customer data from an agent using the new ShopifyTools toolkit.
python
```
from agno.tools.shopify import ShopifyTools

agent = Agent(tools=[ShopifyTools()], markdown=True)
agent.print_response('What were my top-selling products last month?')
```
- ›Adds ShopifyTools toolkit to query Shopify store backends for sales analytics, customer insights, and related data.
- ›Adds URL Context support for Gemini streaming requests.
v2.3.9 Dec 9, 2025 · issue -251

Agno v2.3.9 adds AsyncMySQLDb, LLM-as-judge evals, run_id control, and OpenRouter reasoning support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.9
```
└──▷ USE IT
Replay or correlate a specific agent run by pinning its ID, useful for audit trails and deterministic testing.
python
```
result = agent.run(
    "Enumerate open ports on 10.0.0.1",
    run_id="pentest-2025-07-01-recon"
)
```
- ›Adds AsyncMySQLDb class with support for the asyncmy driver, enabling fully async MySQL storage.
- ›Adds AgentAsJudgeEval — an LLM-as-judge evaluation system that scores agent outputs against custom criteria using binary (pass/fail) or numeric (1–10) scoring, with support for standalone runs, post-hooks, background execution, and custom evaluator agents.
- ›Adds run_id parameter to the run and arun methods on Agent, Team, and Workflow classes, allowing callers to supply a deterministic run ID instead of auto-generating one.
- ›Adds create_schema=False parameter to database initializers (e.g. PostgresDb) to skip automatic schema creation for externally managed schemas.
- ›Adds introduction parameter to Agent and Team to set the first assistant message in a conversation.
+4 moreshow less
- ›Adds reasoning_content field to DeepSeek messages, enabling thinking mode when tools are active.
- ›Extends get_step_output() with recursive search so it finds steps nested inside Parallel, Condition, Router, Loop, and Steps groups.
- ›Adds native sync support for all add_content_ functions in Knowledge, replacing the previous asyncio-wrapping workaround.
- ›Adds support for reasoning messages from OpenRouter.
v2.3.8 Dec 5, 2025 · issue -255

Agno v2.3.8 adds model-level retry control via retries=n on the model object for provider rate-limit resilience.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.8
```
- ›Adds retries=n parameter at the model execution layer so rate-limit errors from model providers trigger retries directly on the model, independently of agent-level retries which continue to handle broader agent execution loop exceptions.
└──▷ BREAKING ON UPGRADE
- !MemoriTools has been removed; integrations using it must migrate to the updated Memori framework approach.
v2.3.7 Dec 4, 2025 · issue -256

Agno v2.3.7 adds Amazon Redshift toolkit and revamps Human-in-the-Loop with a new RunRequirement class
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.7
```
- ›Introduces the RunRequirement class to represent and resolve Human-in-the-Loop requirements; these objects appear in the Agent response or in the RunPaused event during streaming HITL flows.
- ›Adds yield_run_response parameter to continue_run streaming methods, yielding a RunOutput object at the end of a continued run.
- ›Adds Amazon Redshift toolkit for exploring Redshift databases and running queries.
- ›Passes run_context into get_relevant_documents_from_knowledge so custom knowledge retrievers now have access to dependencies.
- ›Enables Agno evals via AgentOS with Agents and Teams that use an asynchronous database class.
v2.3.6 Dec 3, 2025 · issue -257

Agno v2.3.6 adds a Spotify toolkit for managing libraries from agent workflows.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.6
```
- ›Adds a Spotify toolkit enabling agents to manage a Spotify library programmatically.
v2.3.5 Dec 3, 2025 · issue -257

Agno v2.3.5 adds OpenTelemetry-based native tracing and non-blocking background task hooks for agents and teams.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.5
```
- ›Introduces OpenTelemetry-based native tracing that automatically captures and stores agent runs, model calls, tool executions, and team operations in your Agno database.
- ›Agent and Team pre- and post-hooks can now run as background tasks on AgentOS for fully non-blocking, concurrent execution — useful for notifications, logging, or evaluations not on the critical path.
- ›Adds a debug-level environment variable for controlling Agno debug output.
- ›Extends debug-level support to workflows.
- ›Unifies model authentication errors across providers into a consistent error surface.
v2.3.3 Nov 27, 2025 · issue -263

Agno v2.3.3 adds context compression, memory optimization, Gemini File Search, and runtime output schema overrides.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.3
```
└──▷ USE IT
Summarize and deduplicate a user's stored memories outside of an agent run to keep the memory store compact.
python
```
import asyncio
from agno.memory import MemoryManager

memory_manager = MemoryManager(user_id="user_123")

# Sync
memory_manager.optimize_memories()

# Async
asyncio.run(memory_manager.aoptimize_memories())
```
Override the output schema on a per-call basis so one agent instance can return different structured shapes for different tasks.
python
```
from agno.agent import Agent
from pydantic import BaseModel

class SummaryOutput(BaseModel):
    summary: str
    key_points: list[str]

agent = Agent(model=...)
result = agent.run("Summarise this document", output_schema=SummaryOutput)
```
Control Gemini reasoning depth by passing thinking_level when running a Gemini-backed agent.
python
```
from agno.models.google import Gemini
from agno.agent import Agent

agent = Agent(model=Gemini(thinking_level="high"))
agent.run("Explain the proof of Fermat's Last Theorem")
```
- ›Adds optimize_memories and aoptimize_memories methods to MemoryManager for summarizing a user's memories outside of agent runs (beta).
- ›Adds output_schema override support to run() and arun() on both Agent and Team, as well as AgentOS API endpoints, enabling per-call schema control at runtime.
- ›Adds api_key support for AWS Bedrock authentication.
- ›Adds thinking_level parameter support to Gemini.
- ›Introduces Context Compression (beta): compresses tool call results in a running agent context to stay within context windows and avoid rate limits.
+3 moreshow less
- ›Adds Gemini File Search support, including document store create/list/get/delete, direct file upload with custom chunking configuration and metadata, document management with metadata filtering, citation extraction helpers, and full async/await support. See cookbooks: cookbook/models/google/gemini/file_search_basic.py, cookbook/models/google/gemini/file_search_advanced.py, cookbook/models/google/gemini/file_search_rag_pipeline.py.
- ›Extends AWS Bedrock Claude compatibility with native Claude, adding support for thinking models and caching.
- ›Extends VertexAI Claude compatibility with native Claude, adding support for thinking models and caching.
v2.3.1 Nov 21, 2025 · issue -269

Agno v2.3.1 adds NanoBananaTools image generation, Claude structured output support, and MCPTools subclass registration in AgentOS.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.1
```
└──▷ USE IT
Generate images with Google's Nano Banana model using the new toolkit.
python
```
from agno.tools.nano_banana import NanoBananaTools

agent = Agent(tools=[NanoBananaTools()], ...)
```
- ›Adds NanoBananaTools toolkit for generating images with Google's Nano Banana model.
- ›Adds support for Anthropic's structured output functionality in Claude models, ensuring responses always conform to a given schema.
- ›Enables custom toolkits that extend MCPTools or MultiMCPTools to be registered and used inside AgentOS.
v2.3.0 Nov 21, 2025 · issue -269

Agno v2.3.0 adds MigrationManager, sound-effect generation, RedisCluster support, and overhauled session message/history APIs.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.3.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.3.0
```
└──▷ USE IT
Print a multi-agent Team response while showing each member's individual output, for debugging delegation chains.
python
```
team.print_response("Summarise the threat landscape", show_member_responses=True)
```
- ›Introduces MigrationManager class to apply schema migrations for sessions and memories tables across PostgreSQL, SQLite, MySQL, and SingleStore backends.
- ›Adds get_messages and get_chat_history methods to AgentSession, TeamSession, and WorkflowSession session classes, with full filtering capabilities.
- ›Adds get_session_messages and get_chat_history methods to Agent, Team, and Workflow classes; adds get_chat_history to the WorkflowStep class.
- ›Adds show_member_responses parameter to Team.print_response and Team.aprint_response to surface member-level outputs during streaming.
- ›Adds RedisCluster support when configuring a RedisDb instance for agent database storage.
+3 moreshow less
- ›Adds sound-effect generation support to ModelLabsTools via ModelsLab SFX.
- ›All model instances now share a global httpx client singleton with http2 multiplexing enabled, improving resource use and instantiation speed.
- ›Stateless knowledge-base filters now work correctly with AgentOS; using knowledge(...) filters requires setting contents_db.
└──▷ BREAKING ON UPGRADE
- !delegate_task_to_all_members parameter on Team is renamed to delegate_to_all_members; existing code using the old name will break.
- !GoogleSearchTools toolkit has been removed entirely; callers must switch to DuckDuckGoTools.
- !stream_events parameter has been removed from print_response, aprint_response, and CLI methods on Agent, Team, and Workflow.
- !get_messages_for_session has been removed from Agent and Team.
- !get_messages_from_last_n_runs has been removed from Session, Agent, and Team.
- !Using knowledge(...) with knowledge_filters now requires contents_db to be set; omitting it will break filtering.
- !The deprecated AgentOS parameters os_id, fastapi_app, enable_mcp, and replace_routes have been removed; use id, base_app, enable_mcp_server, and on_route_conflict respectively.
- !The default Nebius model endpoint changed from the AI Studio URL to api.tokenfactory.nebius.com; users targeting Nebius AI Studio must now explicitly pass that URL as base_url.
- !PostgreSQL sessions and memories tables require migration: created_at and feedback columns added to memories, and all JSON columns in PostgresDb converted to JSONB.
v2.2.12 Nov 14, 2025 · issue -276

Agno v2.2.12 adds a metadata Filter DSL for Knowledge searches and a Slack mention-only reply mode
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.12
```
└──▷ USE IT
Re-enable all-channel responses for a Slack-connected agent that previously relied on the old default behaviour.
python
```
slack_interface = SlackInterface(agent=my_agent, reply_to_mentions_only=False)
```
- ›Adds reply_to_mentions_only parameter to the Slack interface, controlling whether agents respond to all channel messages or only direct mentions (now defaults to mentions-only).
- ›Introduces a metadata-based Filter DSL for Knowledge searches supporting EQ, IN, GT, LT, NOT, AND, and OR expressions; PGVector-backed stores are supported in this release, with additional VectorDB support to follow.
└──▷ BREAKING ON UPGRADE
- !The Slack interface now defaults to replying only to mentions (reply_to_mentions_only); agents that previously answered all channel messages will silently stop doing so after upgrading unless reply_to_mentions_only is set to False.
v2.2.11 Nov 12, 2025 · issue -278

Agno v2.2.11 adds ParallelTools for web search/extraction, Claude context editing, Anthropic beta access, and expanded Gmail label management.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.11
```
└──▷ USE IT
Run AI-optimized parallel web search and content extraction inside an agent using the new ParallelTools toolkit.
python
```
from agno.tools.parallel_tools import ParallelTools

agent = Agent(
    tools=[ParallelTools()],
    ...
)
agent.run('Find and summarize the latest research on LLM context management')
```
- ›Adds ParallelTools toolkit providing AI-optimized web search and content extraction via both direct API integration and MCP server support.
- ›Enables all Anthropic API beta features on Agno Claude models via the betas parameter.
- ›Adds duration field to top-level Workflow metrics, exposing total runtime of a complete Workflow run.
- ›Extends the Gmail tool with label management: list custom labels, apply labels to emails, remove labels from emails, and delete custom labels.
v2.2.10 Nov 8, 2025 · issue -282

Agno v2.2.10 adds run_context as the standard state-sharing parameter across Workflows and introduces yield_run_output for Agent/Team runs.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.10
```
└──▷ USE IT
Pass run_context into a custom Python step to share and mutate state across a Workflow without relying on session-level globals.
python
```
from agno.workflow import Workflow, RunContext

def my_step(run_context: RunContext) -> str:
    run_context.state['processed'] = True
    return 'done'

wf = Workflow(steps=[my_step])
wf.run()
```
Stream Agent run events while yielding only final output, using the new yield_run_output flag instead of the deprecated yield_run_response.
python
```
for event in agent.run('Summarise this report', yield_run_output=True, stream=True):
    print(event)
```
- ›Adds yield_run_output flag on Agent/Team run/arun functions as the replacement for the to-be-deprecated yield_run_response.
- ›Promotes run_context as the recommended parameter for reading and modifying state across all Workflow surfaces — Agents, Teams, tools, steps, and custom Python functions used in steps.
- ›Improves event streaming from custom executor steps inside Workflows, including better handling of Agent/Team events emitted by a custom executor.
v2.2.9 Nov 7, 2025 · issue -283

Agno v2.2.9 adds strict_output for schema-enforced model responses, AG-UI state mapping, and multi-table AgentOS support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.9
```
- ›Adds strict_output parameter to all compatible models, guaranteeing generated responses adhere to the contextual output_schema; defaults to True.
- ›Supports knowledge_filters parameter on AgentOS run endpoints.
- ›Maps AG-UI request state data to session_state when running Agno Agents or Teams via the AG-UI integration.
- ›Enables multiple Agno tables of the same type (e.g., multiple session tables) within the same database when using AgentOS.
- ›Improves mapping of Agno CustomEvent events into AG-UI custom events with all relevant fields when streaming via the AG-UI interface.
+2 moreshow less
- ›Team members now automatically inherit the primary model from their parent team when no model is specified (secondary models reasoning_model, parser_model, and output_model are not inherited).
- ›Renames preferred identifiers for Mongo and Redis vector DB implementations to MongoVectorDb and RedisVectorDb.
v2.2.7 Nov 5, 2025 · issue -285

Agno v2.2.7 adds run_context access in tools/hooks, RedisVL vector DB support, vLLM embeddings, and MCP tool name prefixing.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.7
```
└──▷ USE IT
Access run-level state inside a custom tool by declaring the run_context parameter — useful for reading or writing shared state across tool calls within a single agent run.
python
```
from agno.agent import RunContext

def my_tool(query: str, run_context: RunContext) -> str:
    previous = run_context.state.get("last_query", "none")
    run_context.state["last_query"] = query
    return f"Previous query was: {previous}"
```
- ›Adds tool_name_prefix parameter to the MCPTools class to namespace all tool names for a given MCP server, preventing collisions when multiple MCP servers are in use.
- ›Introduces run_context as an injectable parameter in tools, hooks, tool hooks, dependency functions, and instructions functions for unified access to run-level state.
- ›Adds RedisVL as a supported VectorDB backend for Knowledge, enabling Redis-backed vector search.
- ›Adds vLLM embedder support, allowing local or remote vLLM models to be used for embeddings in Knowledge pipelines.
v2.2.6 Nov 1, 2025 · issue -289

Agno v2.2.6 adds conversational workflows, a Notion toolkit, model-as-string syntax, and session state on run events.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.6
```
└──▷ USE IT
Reference a model by string instead of instantiating a model object — useful for quickly switching providers in agent definitions.
python
```
from agno.agent import Agent

agent = Agent(model="openai:gpt-5")
```
- ›Supports defining models as a string (e.g., openai:gpt-5) when configuring Agents and Teams, eliminating the need to instantiate a model object.
- ›Adds session state access on RunOutput and RunCompleted events for Agents, and on TeamRunOutput and TeamRunCompleted events for Teams.
- ›New Notion Toolkit lets Agents read and interact with Notion pages.
- ›New Conversational Workflows capability gives Workflows a chat-like experience similar to Agent and Team, including session and history support.
- ›Adds input schema validation for Agents and Teams on AgentOS.
+3 moreshow less
- ›Extends FileTools toolkit with chunked reading of large files, partial updates to large files, and file deletion.
- ›Adds reranker support to the Milvus vector database search operation, reordering results by relevance after initial vector search.
- ›All model implementations now cache and reuse HTTP clients (client persistence) to reduce connection overhead.
v2.2.5 Oct 30, 2025 · issue -291

Agno v2.2.5 preserves custom routers when reprovisioning AgentOS via lifespan functions.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.5
```
- ›Supports preservation and reprovisioning of all previously registered non-built-in routers when updating the AgentOS through a lifespan function.
v2.2.4 Oct 30, 2025 · issue -291

Agno v2.2.4 adds num_history_messages for granular history control and AgentOS access in lifespan functions
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.4
```
└──▷ USE IT
Limit history context to the last 5 messages to reduce token usage in long-running conversations.
python
```
agent = Agent(
    ...
    num_history_messages=5,
)
```
- ›Adds num_history_messages parameter to control how many messages are considered when retrieving agent history.
- ›Enables access to the contextual AgentOS instance within FastAPI lifespan functions, allowing updates to the instance after initialization and first run.
- ›Supports Media instances when providing run input as a dictionary (in addition to a list of Message objects).
v2.2.3 Oct 29, 2025 · issue -292

Agno v2.2.3 adds AsyncMongoDb class for non-blocking MongoDB access in async agent flows.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.3
```
- ›Adds AsyncMongoDb class to support asynchronous MongoDB database operations in async agent and team workflows.
v2.2.2 Oct 29, 2025 · issue -292

Agno v2.2.2 adds LLM response caching, async SQLite, Claude Skills, Tavily Extract, and automatic MCP lifecycle management.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.2
```
└──▷ USE IT
Cache model responses during development to avoid redundant API calls and cut costs.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o', cache_response=True),
    description='A cost-efficient research assistant',
)
agent.print_response('Summarize the history of the Roman Empire')
```
Use SQLite as an async session store when running agents in an async application.
python
```
from agno.agent import Agent
from agno.storage.sqlite import AsyncSqliteDb

storage = AsyncSqliteDb(db_path='tmp/agent_sessions.db')
agent = Agent(storage=storage)

import asyncio
asyncio.run(agent.aprint_response('Hello!'))
```
- ›Adds cache_response=True on the model class to cache LLM responses, reducing costs and speeding up development and testing.
- ›Adds AsyncSqliteDb class for asynchronous access to SQLite databases.
- ›Adds summary_request_message on SessionSummaryManager to override the user instruction sent to the LLM when generating session summaries.
- ›Adds refresh_connection on MCPTools and MultiMCPTools to manually refresh MCP server connections.
- ›Enables automatic MCP connection lifecycle management: passing MCPTools or MultiMCPTools directly to an Agent or Team now handles connect and reconnect automatically per run.
+4 moreshow less
- ›Adds support for Claude's native Skills, enabling enhanced reasoning, code execution, and tool interactions via the Anthropic integration.
- ›Adds TavilyReader for Tavily-based knowledge base integration and extends TavilyTools with URL content extraction via the Tavily Extract API, with full async support.
- ›Adds Team Model Inheritance: member agents automatically inherit model, reasoning_model, parser_model, and output_model from their parent team when none is specified.
- ›Enables Slack interface output to use mrkdwn formatting by default.
v2.2.1 Oct 23, 2025 · issue -298

Agno v2.2.1 adds a PPTXReader class and max_tool_calls_from_history to control agent context size.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.1
```
└──▷ USE IT
Cap the number of past tool calls loaded into an agent's context to keep token usage in check during long-running sessions.
python
```
agent = Agent(
    tools=[...],
    max_tool_calls_from_history=5
)
```
- ›Adds max_tool_calls_from_history parameter to load a fixed number of tool calls from agent history, reducing token consumption and managing context size.
- ›Adds PPTXReader class to support ingesting Microsoft PowerPoint (.pptx) files.
v2.2.0 Oct 22, 2025 · issue -299

Agno v2.2.0 adds new Agent/Team events, stream_events flag, session state methods, and three new AgentOS session endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.2.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.2.0
```
└──▷ USE IT
Stream all agent events (tool calls, hooks, session summaries) in a run for real-time UI updates.
python
```
async for event in agent.arun('Summarize the latest reports', stream=True, stream_events=True):
    print(event)
```
Persist updated session context mid-conversation without waiting for the next run.
python
```
await agent.aupdate_session_state({'last_topic': 'network anomalies', 'alert_level': 'high'})
```
Retrieve a specific run from a completed team session via the new AgentOS endpoint.
```
$ curl -X GET 'https://<agentOS-host>/sessions/<session-id>/runs/<run-id>' \
  -H 'Authorization: Bearer <token>'
```
- ›Adds stream_events flag to Agent, Team, Workflow, and all run methods to emit all events when streaming a response (previously tool-call events were always yielded; non-RunContent events are now gated behind this flag).
- ›Adds update_session_state and aupdate_session_state methods on Agent and Team for direct, DB-persisted session state updates.
- ›Adds add_team_history_to_members config on Team to share team-level request/response history with member agents.
- ›Adds three new AgentOS session endpoints: POST /sessions (create a new empty session), GET /sessions/{id}/runs/{id} (get a run by ID), and PATCH /sessions/{id} (update an existing session).
- ›Adds PostHookStarted, PostHookCompleted, SessionSummaryCreationStarted, SessionSummaryCreationCompleted, and RunContentCompleted events for both Agent and Team, enabling fine-grained UI streaming control.
+3 moreshow less
- ›Workflow .arun now returns an AsyncIterator, consistent with Agent and Team, enabling event-by-event async streaming.
- ›Concurrent memory creation: automatic memory creation now starts in a background thread/task at the beginning of an Agent/Team run, reducing total run latency when memory generation is enabled.
- ›Improves get_run_output and get_last_run_output on Agent/Team to support retrieval of runs from member agents after team execution.
└──▷ BREAKING ON UPGRADE
- !Workflow.arun(..., stream=True) now returns an AsyncIterator; callers must replace await workflow.arun(...) with async for event in workflow.arun(...).
- !All events except RunContent events are now gated behind stream_events=True; tool-call events that were previously always yielded will no longer appear unless stream_events=True is set.
- !stream_intermediate_steps is deprecated in favour of stream_events.
v2.1.10 Oct 21, 2025 · issue -300

Agno v2.1.10 adds experimental Culture for collective agent learning, Gmail mark-as-read/unread tools, and standalone Knowledge on AgentOS.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.10
```
- ›Adds mark-as-read and mark-as-unread functions to the Gmail toolkit.
- ›[Experimental] Introduces Culture, a shared space for agents to think, write, and build on each other's ideas, enabling collective learning across an agent group.
- ›Enables Knowledge to be added and managed via any AgentOS interface without requiring it to be attached to an Agent or Team.
v2.1.9 Oct 20, 2025 · issue -301

Agno v2.1.9 adds trackable message IDs and session_state propagation to Workflow Condition and Router steps.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.9
```
└──▷ USE IT
Access session_state inside a Condition evaluator to make routing decisions based on contextual workflow state.
python
```
from agno.workflow import Condition

def my_evaluator(step_output, session_state):
    return session_state.get('user_tier') == 'premium'

condition = Condition(evaluator=my_evaluator, ...)
```
- ›Adds id field to the Message class, available on RunOutput message lists, enabling message tracking in storage.
- ›Extends session_state access to evaluator and selector functions in Condition and Router Workflow Step classes.
v2.1.8 Oct 17, 2025 · issue -304

Agno v2.1.8 adds class-based workflow executors, streaming post-hooks, Jira worklogs, and a renamed knowledge search endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.8
```
- ›Renames the knowledge search endpoint from search_vectors to search_knowledge.
- ›Supports class-based executors in Workflows by defining a class that implements the __call__ method.
- ›Adds post-hook support on streaming flows.
- ›Extends JiraTools toolkit to support creating worklogs.
- ›Updates GoogleCalenderTools to notify attendees when creating, updating, or deleting calendar events.
└──▷ BREAKING ON UPGRADE
- !The knowledge search endpoint is renamed from search_vectors to search_knowledge; any client code calling search_vectors will break and must be updated.
v2.1.6 Oct 16, 2025 · issue -305

Agno v2.1.6 adds SurrealDB support via new SurrealDb class and renames store_tool_results to store_tool_messages
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.6
```
- ›Adds the SurrealDb class for complete SurrealDB integration with Agents, Teams, and Workflows.
- ›Renames the store_tool_results flag to store_tool_messages for clarity; tool message pairs (tool result + the assistant message containing the corresponding tool call) are now removed together to maintain valid message sequences required by most model providers.
└──▷ BREAKING ON UPGRADE
- !The store_tool_results flag is renamed to store_tool_messages; any code or config referencing store_tool_results will break on upgrade.
v2.1.5 Oct 15, 2025 · issue -306

Agno v2.1.5 adds async Postgres, knowledge search endpoints, workflow executor event filtering, and reasoning support for Gemini/Claude.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.5
```
└──▷ USE IT
Suppress verbose tool call and history messages from run output when you only care about the final response.
python
```
agent = Agent(
    ...,
    store_history_messages=False,
    store_tool_messages=False,
)
```
Filter workflow executor events so only top-level workflow lifecycle events (not agent/team sub-events) are streamed to the client.
python
```
workflow.run(
    ...,
    stream_intermediate_events=True,
    stream_executor_events=False,
)
```
Re-enable AgentOS access logs after upgrading, since they are now off by default.
python
```
serve(access_log=True)
```
- ›Adds store_history_messages and store_tool_messages flags to Agent and Team to control whether history and tool messages are persisted on run output.
- ›Adds stream_executor_events to workflows for filtering events emitted by agents, teams, or custom functions — complementing the existing stream_intermediate_events (for workflow-level events like WorkflowStarted, StepStarted) and stream_member_events on Team.
- ›Adds access_log=True parameter to serve() to re-enable AgentOS access logs, which are now off by default.
- ›Adds async Postgres support across the library for non-blocking database operations.
- ›Adds knowledge search endpoints to the AgentOS API, enabling vector database searches via the AgentOS API.
+3 moreshow less
- ›Adds service account authentication support to GoogleSheetsTools.
- ›Adds native reasoning model support for Gemini 2.5+, Anthropic Claude, and VertexAI Claude when used as reasoning models with Agents.
- ›Allows MCP server URLs without the conventional /mcp path segment when using MCPToolbox.
└──▷ BREAKING ON UPGRADE
- !AgentOS access logs are now disabled by default; existing setups relying on access logging must explicitly pass access_log=True to serve() to restore the previous behavior.
v2.1.4 Oct 10, 2025 · issue -311

Agno v2.1.4 adds workflow history, a GoogleDriveTools class, AG-UI custom events, and tool post-hooks on failure.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.4
```
- ›Adds GoogleDriveTools class to give agents read and write access to Google Drive.
- ›Adds workflow history support, enabling continuous conversational context across all or individual workflow steps.
- ›Extends tool post-hooks to also execute when a tool run fails with an exception, enabling failure-specific cleanup or logging logic.
- ›AG-UI integration now delivers Agno custom events to the AG-UI interface in the standard AG-UI custom event format.
- ›Parallel step event streaming in workflows now yields events immediately as they are produced rather than collecting all events and yielding at the end.
v2.1.3 Oct 8, 2025 · issue -313

Agno v2.1.3 adds Claude on Vertex AI, OpenRouter fallback models, and MCP server support for custom FastAPI apps
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.3
```
└──▷ USE IT
Expose an AgentOS instance with a custom FastAPI app as an MCP server so external MCP clients can call your agents.
python
```
agent_os = AgentOS(app=my_fastapi_app, enable_mcp_server=True)
```
- ›Enables AgentOS instances running a custom FastAPI base app to be exposed as MCP servers via the enable_mcp_server parameter.
- ›Adds a new Claude model class for serving Claude models through Vertex AI.
- ›Adds fallback model support to the OpenRouter class, allowing multiple models to be defined so that if the primary model fails a fallback is used automatically.
- ›Agents, Teams, and Workflows exposed via an AgentOS MCP server can now use MCP tools themselves.
- ›Updates FileTools toolkit to handle relative paths across all its methods.
v2.1.2 Oct 7, 2025 · issue -314

Agno v2.1.2 adds an A2A interface for AgentOS and a field-labelled CSV reader for structured knowledge ingestion.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.2
```
- ›Adds A2A interface to AgentOS, enabling Agents, Teams, and Workflows to be exposed and run in Agent-to-Agent (A2A) compatible format.
- ›Adds a field-labelled CSV reader that preserves field–value relationships when ingesting CSV knowledge data.
- ›Supports passing user_id in the forwarded_props field when initiating an AG-UI run.
- ›Extends AgentOS API routers to accept additional file types, including more audio formats.
- ›Supports local binary paths (e.g. ./script) as MCP server commands in MCPTools and MultiMCPTools classes.
v2.1.1 Oct 3, 2025 · issue -317

Agno v2.1.1 adds a prefix option for AGUI, WhatsApp, and Slack interfaces to support multiple interfaces on one AgentOS instance.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.1
```
- ›Adds a prefix parameter to AGUI, Whatsapp, and Slack interfaces, enabling multiple interfaces to run on the same AgentOS instance with distinct route prefixes.
v2.1.0 Oct 1, 2025 · issue -319

Agno v2.1.0 adds JWT middleware, pre/post hooks, guardrails (PII/prompt-injection/OpenAI Moderation), and Requesty LLM gateway support.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.1.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.1.0
```
- ›Adds built-in JWT Middleware to AgentOS for validating tokens and extracting claims into AgentOS endpoints.
- ›Adds support for any custom FastAPI-compatible middleware on the AgentOS.
- ›Adds pre_hooks and post_hooks configuration on agents and teams for input/output validation or transformation at the start or end of a run.
- ›Adds built-in Guardrails as pre-hooks, including prompt injection checks, PII detection (SSN, credit cards, phone numbers, emails), OpenAI Moderation, and support for custom guardrails.
- ›Adds base_app parameter to AgentOS for configuring a custom FastAPI app (replacing the now-deprecated fastapi_app).
+8 moreshow less
- ›Adds on_route_conflict parameter to AgentOS for controlling behavior when routes conflict on base_app (replacing deprecated replace_routes).
- ›Adds enable_mcp_server parameter to AgentOS for converting it into an MCP server (replacing deprecated enable_mcp).
- ›Adds id parameter to AgentOS as the OS identifier (replacing deprecated os_id).
- ›Adds support for the Requesty LLM gateway provider for affordable LLM access with advanced governance.
- ›Adds batch embeddings support to speed up embedding generation and reduce API calls to embedding providers.
- ›Enables concurrent (parallel) execution of async generator tools during streaming.
- ›Enables concurrent member execution during async team streaming via Team.arun(..., stream=True); note that event order is no longer guaranteed.
- ›Uses the user's unique phone number as the default session ID for WhatsApp interface sessions, enabling conversation history.
└──▷ BREAKING ON UPGRADE
- !Async team member events during Team.arun(..., stream=True) are now received concurrently — the order of member events is no longer guaranteed. Code depending on a specific event order from team members will behave differently.
- !The use_batch parameter has been removed from the PGVectorDB class.
v2.0.11 Sep 26, 2025 · issue -324

Agno v2.0.11 adds metadata fields to LiteLLM and improves AgentOS MCP tool and DB registration logic.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.11
```
- ›Adds metadata and additional fields to the LiteLLM model class, enabling richer model configuration and request context.
- ›Improves AgentOS logic for finding and registering MCP tools when setting up an AgentOS instance.
- ›Improves AgentOS logic for finding and registering DBs, now rejecting incompatible DB instances that share the same IDs.
v2.0.10 Sep 25, 2025 · issue -325

Agno v2.0.10 adds overwrite_db_session_state flag to overwrite persisted session state in the database.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.10
```
└──▷ USE IT
Force a fresh session state on the next run instead of resuming from the previously stored state in the database.
python
```
agent = Agent(..., overwrite_db_session_state=True)
```
- ›Adds overwrite_db_session_state flag to overwrite the session state persisted in the database, enabling clean session resets without manual DB intervention.
v2.0.9 Sep 24, 2025 · issue -326

Agno v2.0.9 adds MCP Toolbox for Databases, Ollama Cloud support, bulk DB writes, and session_state in AgentOS run endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.9
```
- ›Adds session_state and dependencies parameters to AgentOS run endpoints, enabling callers to pass session context directly into agent runs.
- ›New MCP Toolbox toolkit integrates Google's MCP Toolbox for Databases, giving agents structured access to database tools via the MCP protocol.
- ›Ollama Model class now supports Ollama Cloud via an API key, enabling cloud-hosted Ollama model inference alongside local deployments.
- ›All database implementations now support bulk writes, allowing multiple Sessions and Memories to be persisted in a single DB call.
- ›Workflows can now be used in AgentOS together with the Slack interface.
+2 moreshow less
- ›New methods added to the Scrape Graph Toolkit.
- ›Storage layer now raises critical errors on read/write failures rather than silently logging them, surfacing DB issues to callers.
└──▷ BREAKING ON UPGRADE
- !Storage errors that were previously logged silently are now raised as exceptions; code that relied on silent failure on DB read/write errors will now encounter raised exceptions.
v2.0.8 Sep 22, 2025 · issue -328

Agno v2.0.8 adds CometAPI as a model provider, allow_partial_failure for MultiMCPTools, and dependencies access inside custom tools.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.8
```
└──▷ USE IT
Keep a multi-MCP agent running even when one MCP server is unavailable at startup.
python
```
from agno.tools.mcp import MultiMCPTools

tools = MultiMCPTools(
    servers=["npx -y @modelcontextprotocol/server-github", "npx -y @modelcontextprotocol/server-slack"],
    allow_partial_failure=True
)
```
- ›Adds allow_partial_failure flag to MultiMCPTools toolkit, letting multi-server MCP setups continue when individual servers fail.
- ›Exposes dependencies as a built-in argument on custom tools, making injected dependencies directly accessible inside tool function bodies.
- ›Adds CometAPI as a new model provider.
- ›Supports multiple text_contents entries in add_contents() on Knowledge, enabling bulk text ingestion in a single call.
v2.0.7 Sep 18, 2025 · issue -332

Agno v2.0.7 adds a LlamaCpp Model class for local Llama CPP inference and a chat_history field to TeamSessionDetailSchema.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.7
```
- ›Adds LlamaCpp Model class, enabling local Llama CPP model support as a first-class model backend.
- ›Adds chat_history field to TeamSessionDetailSchema, exposing team session conversation history via the schema.
v2.0.6 Sep 18, 2025 · issue -332

Agno v2.0.6 adds FileGenerationTools for PDF/CSV/JSON/TXT output and a new Nexus Router Model class.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.6
```
└──▷ USE IT
Give an agent the ability to produce downloadable file artifacts (PDF, CSV, JSON, TXT) as part of its responses.
python
```
from agno.agent import Agent
from agno.tools.file_generation import FileGenerationTools

agent = Agent(
    tools=[FileGenerationTools()],
    description="An agent that can generate and save file artifacts.",
)
agent.print_response("Summarise this dataset and save it as a CSV report.")
```
- ›Adds FileGenerationTools toolkit, enabling agents to generate file artifacts in PDF, CSV, JSON, and TXT formats.
- ›Adds a Model class for the Nexus Router, exposing it as a first-class model provider.
- ›Stores the main workflow input in WorkflowRunOutput and persists it to the database.
v2.0.5 Sep 17, 2025 · issue -333

Agno v2.0.5 adds replace_routes=False for custom FastAPI integration, Discord user ID context, and DuckDuckGo search_engine param.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.5
```
- ›Adds replace_routes=False parameter to AgentOS custom FastAPI integration, letting existing routes take precedence over AgentOS routes instead of being overwritten by default.
- ›Adds userid in context for Discord integration, making the caller's identity available to agents handling Discord events.
- ›Updates DuckDuckGo tools with a new search_engine parameter for configurable search engine selection.
- ›Extends the v1 → v2 migration script to support metrics parsing and MongoDB migrations.
- ›Adds accurate token metric tracking for the OpenAI Responses API.
v2.0.4 Sep 12, 2025 · issue -338

Agno v2.0.4 adds TypedDict input schemas, SiliconFlow model support, and session_state in workflow function steps.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.4
```
└──▷ USE IT
Persist intermediate state across steps in a workflow by writing to session_state inside a custom function step.
python
```
def custom_function_step(step_input: StepInput, session_state):
    session_state["last_processed"] = step_input.message
    return step_input
```
Define a structured agent input schema using TypedDict instead of Pydantic.
python
```
from typing import TypedDict
from agno.agent import Agent

class ScanInput(TypedDict):
    target: str
    depth: int

agent = Agent(input_schema=ScanInput)
```
- ›Adds session_state as a parameter in custom Python function steps for workflows, enabling direct mutation of workflow session state from within a step function.
- ›Adds extra_body parameter to OpenAIChat and OpenAILike model classes for passing additional request body fields to the OpenAI-compatible API.
- ›Supports TypedDict in input_schema for agents, teams, and workflows alongside existing Pydantic support for structured input definition.
- ›Adds SiliconFlow as a new model provider class.
- ›Extends MCP (Model Context Protocol) async tool support to all AgentOS evals.
v2.0.3 Sep 10, 2025 · issue -340

Agno v2.0.3 adds WorkflowTools, MemoryTools, Gemini TTS, and custom encoding support for reader classes.
└──▷ GET THIS VERSION
```
$ git clone --branch v2.0.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v2.0.3
```
- ›Adds WorkflowTools class, usable as a tool for agents and teams to run workflows from within an agent, with reasoning support via think/analyze.
- ›Adds MemoryTools class, usable as a tool for agents and teams to add, update, and delete memories, with reasoning support via think/analyze.
- ›Adds encoding parameter support on the reader class, allowing custom text encoding to be passed when reading documents.
- ›Adds support for additional kwargs on AgentOS API run endpoints, enabling extra arguments when running an agent, team, or workflow via AgentOS.
- ›Adds Gemini Text to Speech (TTS) support.
v1.8.2 Sep 8, 2025 · issue -342

Agno v1.8.2 adds response_model structured output support for AG-UI and Discord, plus updated_at on session responses.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.8.2
```
└──▷ USE IT
Return a typed, structured response from a Discord-connected agent instead of raw text.
python
```
from agno.client.discord import DiscordClient
from pydantic import BaseModel

class AnalysisResult(BaseModel):
    summary: str
    risk_level: str

client = DiscordClient(agent=my_agent, response_model=AnalysisResult)
```
- ›Adds response_model support to AG-UI, enabling structured output from agents in AG-UI apps.
- ›Adds response_model support to DiscordClient, enabling structured output from agents in Discord apps.
- ›Adds updated_at field to AgentSessionResponse and TeamSessionResponse.
- ›Extends JSON Schema constraint support for Gemini models.
v1.8.1 Aug 27, 2025 · issue -354

Agno v1.8.1 adds Neo4j graph tools, OpenAI reasoning summaries, and timezone support for Teams.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.8.1
```
└──▷ USE IT
Query and traverse a Neo4j graph database from an Agno agent to investigate relationships between entities.
python
```
from agno.agent import Agent
from agno.tools.neo4j import Neo4jTools

agent = Agent(
    tools=[Neo4jTools(uri='bolt://localhost:7687', user='neo4j', password='<password>')],
    show_tool_calls=True,
)
agent.print_response('Find all nodes connected to the user with id 42')
```
Get a readable reasoning summary from an OpenAI reasoning model response instead of raw chain-of-thought tokens.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIResponses

agent = Agent(
    model=OpenAIResponses(id='o3', summary='auto'),
    markdown=True,
)
agent.print_response('Explain the steps to assess a phishing email')
```
- ›Adds Neo4jTools class to explore and manipulate graphs in a Neo4j database from within agents.
- ›Adds reasoning summary support to the OpenAIResponses class for OpenAI reasoning models.
- ›Adds timezone_identifier field to Team, bringing it to parity with the existing Agent functionality.
- ›Allows OpenAIChat to accept both httpx.Client and httpx.AsyncClient for custom HTTP client configuration.
v1.8.0 Aug 25, 2025 · issue -356

Agno v1.8.0 adds MemoriTools, file inputs for Workflows, agentic crawling, and Vertex AI Search support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.8.0
```
└──▷ USE IT
Give an agent access to GibsonAI Memori for persistent memory across sessions.
python
```
from agno.tools.memori import MemoriTools

agent = Agent(tools=[MemoriTools()], ...)
```
- ›Adds MemoriTools toolkit, enabling Agents and Teams to interact with GibsonAI's Memori memory service.
- ›Adds agentic_crawler parameter to ScrapeGraphTools for agentic web crawling.
- ›Adds files=[] parameter to Workflow.run and Workflow.arun for passing file inputs directly to workflow runs.
- ›Adds Vertex AI Search support to the Gemini model integration.
- ›Updates DuckDuckGoTools to work with the ddgs package (replaces duckduckgo-search).
└──▷ BREAKING ON UPGRADE
- !DuckDuckGoTools now requires the ddgs package instead of duckduckgo-search; users must install ddgs for DuckDuckGo search to function.
v1.7.12 Aug 20, 2025 · issue -361

Agno v1.7.12 adds Team collaborate streaming, OpenAI verbosity control, Gemini URL context tool, Vertex AI embedder support, and DynamoDB throughput config.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.12
```
└──▷ USE IT
Tune how much detail OpenAI returns in responses by setting verbosity on OpenAIChat.
python
```
from agno.models.openai import OpenAIChat

model = OpenAIChat(id="gpt-4o", verbosity=2)
```
- ›Adds verbosity parameter to OpenAIChat and OpenAIResponses for controlling OpenAI output verbosity.
- ›Allows specifying DynamoDB provisioned throughput when initializing DynamoDbStorage, enabling capacity control at construction time.
- ›Adds Vertex AI support for GeminiEmbedder, enabling Gemini embeddings via the Vertex AI backend.
- ›Adds streaming support for Team in collaborate mode, delivering incremental output for multi-agent collaborative workflows.
- ›Adds support for the Gemini URL context tool, enabling Gemini models to fetch and reason over web URLs as context.
v1.7.11 Aug 14, 2025 · issue -363

Agno v1.7.11 adds InMemoryStorage, TrafilaturaTools, DashScope/Qwen models, BrandfetchTools, and Bedrock File support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.11
```
└──▷ USE IT
Prototype an agent quickly without a database by swapping in InMemoryStorage instead of a persistent backend.
python
```
from agno.storage.memory import InMemoryStorage
from agno.agent import Agent

agent = Agent(
    storage=InMemoryStorage(),
)
agent.run('Summarize the latest threat intel report.')
```
Equip an agent with web scraping capabilities to extract clean text from arbitrary URLs.
python
```
from agno.agent import Agent
from agno.tools.trafilatura import TrafilaturaTools

agent = Agent(
    tools=[TrafilaturaTools()],
)
agent.run('Extract the main article text from https://example.com/blog/post')
```
Run a Qwen model through DashScope when you need Alibaba Cloud-hosted LLM inference.
python
```
from agno.models.dashscope import DashScope
from agno.agent import Agent

agent = Agent(
    model=DashScope(id='qwen-max'),
)
agent.run('List the top five open-source SIEM platforms.')
```
- ›Adds InMemoryStorage class for lightweight, optionally persistence-backed session storage, compatible with custom backends such as AWS S3 and Snowflake.
- ›Adds TrafilaturaTools SDK for web scraping and text extraction using the Trafilatura library.
- ›Adds DashScope integration class to run Qwen models natively.
- ›Adds BrandfetchTools toolkit (sync and async) for agents to fetch brand information and assets via the Brandfetch API.
- ›Adds workers parameter to the FastAPI app for controlling concurrency.
+2 moreshow less
- ›Adds File input support for compatible AWS Bedrock models.
- ›Adds async hybrid search support for the Milvus vector database integration.
v1.7.10 Aug 12, 2025 · issue -363

Agno v1.7.10 adds GPT-5 support, password-protected PDF ingestion, GitHub pagination, and a Team role parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.10
```
└──▷ USE IT
Define a specialized team purpose so the orchestrator knows how to route tasks to it.
python
```
from agno.team import Team

research_team = Team(
    name='Research Team',
    role='Gather and synthesize information from web sources to answer factual questions',
    members=[...]
)
```
- ›Adds role parameter to the Team class for defining a team's purpose and specialization.
- ›Adds password-protected PDF support to PDFKnowledgeBase for ingesting secured documents into knowledge bases.
- ›Supports GPT-5 via the OpenAIResponses class.
- ›Adds pagination with metadata for GitHub Tools.
v1.7.9 Aug 7, 2025 · issue -363

Agno v1.7.9 adds reranker support in PgVector hybrid search and page-number-aware PDF chunking
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.9
```
- ›Adds stream_intermediate_steps support when using an output model, enabling streaming of intermediate agent steps alongside structured output.
- ›Adds reranker support to PgVector hybrid search, allowing result re-ranking in vector+keyword search pipelines.
- ›Adds page number handling to PDF Readers, including a flag to control whether pages are split during chunking.
v1.7.8 Aug 6, 2025 · issue -363

Agno v1.7.8 adds output_model for Agents and Teams, OpenAI service_tier support, Gemini thinking, and Google toolkit enhancements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.8
```
└──▷ USE IT
Route an agent's final structured output through a cheaper or specialized model while keeping a powerful model for reasoning.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='o3'),
    output_model=OpenAIChat(id='gpt-4o-mini'),
)
agent.print_response('Summarise the quarterly results.')
```
Use OpenAI Flex Processing to reduce cost on latency-tolerant batch workloads.
python
```
from agno.models.openai import OpenAIChat

model = OpenAIChat(id='gpt-4o', service_tier='flex')
```
- ›Adds output_model parameter to Agent and Team classes, letting the final response be generated by a separate model rather than the primary model.
- ›Adds service_tier field to OpenAIChat and OpenAIResponses to enable OpenAI Flex Processing.
- ›Adds Gemini thinking output to responses via the Gemini integration.
- ›Adds custom port support for the Google Sheets Toolkit authentication flow.
- ›Enhances Google Calendar toolkit with unified authentication.
v1.7.7 Jul 31, 2025 · issue -364

Agno v1.7.7 adds sync-friendly MCP integration, Morph code-edit tools, Claude interleaved thinking, and LiteLLM file/image inputs.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.7
```
└──▷ TRY IT
Install the arxiv tool extra to enable arxiv paper search in an agent without manually managing the dependency.
```
$ pip install agno[arxiv]
```
- ›Revamps MCPTools and MultiMCPTools so both classes can be initialized and used without an async context manager, simplifying synchronous workflows.
- ›Introduces MorphTools (Morph Fast Apply model) as a callable tool for intelligently merging code with update snippets at 98% accuracy and 4500+ tokens/second.
- ›Adds support for Claude interleaved thinking — reasoning steps interspersed between other content blocks in Claude model responses.
- ›Adds file and image input support to LiteLLM for multimodal understanding workflows.
- ›Upgrades ZepTools compatibility to Zep v3.
v1.7.6 Jul 24, 2025 · issue -364

Agno v1.7.6 adds Portkey models, BitbucketTools, JinaEmbedder, EvmTools, LinkupTools, RowChunking, and non-blocking Workflows 2.0 background execution.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.6
```
└──▷ USE IT
Chunk a CSV file row-by-row for precise retrieval — useful when each row is a self-contained record like a CVE entry or an alert.
python
```
from agno.document.chunking.row import RowChunking
from agno.document.reader.csv_reader import CSVReader

reader = CSVReader(chunking_strategy=RowChunking())
documents = reader.read('alerts.csv')
```
Give an agent access to Bitbucket repositories — list repos, create PRs, and more — by attaching BitbucketTools.
python
```
from agno.tools.bitbucket import BitbucketTools
from agno.agent import Agent

agent = Agent(
    tools=[BitbucketTools(username="<username>", password="<app-password>", workspace="<workspace>")],
    markdown=True,
)
agent.print_response("List all open pull requests in the agno repo")
```
- ›Adds BitbucketTools class for interacting with Bitbucket Cloud repository APIs from an agent.
- ›Adds JinaEmbedder class for using Jina-hosted embedding models.
- ›Adds EvmTools class for executing transactions on EVM-compatible blockchains via the web3 library.
- ›Adds LinkupTools class for web search capabilities inside agents.
- ›Adds RowChunking as a CSV-specific chunking strategy for document ingestion.
+5 moreshow less
- ›Adds Portkey hosted model support, enabling Portkey as a model provider.
- ›Introduces background (non-blocking) execution for Workflows 2.0, with polling support for retrieving results.
- ›Adds async execution support (ainvoke) for the AWS Bedrock model integration.
- ›Adds new tools to the Daytona agent toolkit.
- ›Adds AG-UI support for frontend tool calls and surfacing backend tool calls.
v1.7.5 Jul 17, 2025 · issue -364

Agno v1.7.5 adds SurrealDB as a vector DB backend and cache_session control for memory management.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.5
```
- ›Adds cache_session attribute to agent/session configuration, allowing users to disable session caching for improved memory management.
- ›Adds SurrealDB support as a vector database backend for knowledge bases.
- ›Adds Workflows 2.0 support inside FastAPIApp, enabling the new workflow engine to run as a FastAPI application.
v1.7.4 Jul 16, 2025 · issue -364

Agno v1.7.4 ships a redesigned step-based Workflows 2.0 (beta) and Pydantic model input support for Agent and Team.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.4
```
└──▷ USE IT
Pass a validated Pydantic model directly into an agent run instead of raw text, enabling type-safe, structured inputs.
python
```
from pydantic import BaseModel
from agno.agent import Agent

class ScanRequest(BaseModel):
    target: str
    depth: int

agent = Agent(model=...)
agent.run(ScanRequest(target="example.com", depth=3))
```
- ›Adds Workflows 2.0 (beta), a complete redesign of the workflow system using a step-based architecture that supports sequential, parallel, conditional, and loop-based execution, dynamic step routing, mixed components (agents, teams, and functions), and shared session state across steps.
- ›Both Agent and Team now accept a Pydantic model as structured input on run() and print_response().
v1.7.3 Jul 15, 2025 · issue -364

Agno v1.7.3 adds session_state on agent/team runs and GCSPDFKnowledgeBase for Google Cloud Storage PDFs.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.3
```
└──▷ USE IT
Seed a fresh agent run with pre-populated session state to carry context from an external system into the conversation.
python
```
agent.run('Continue the investigation', session_state={'case_id': 'INC-4821', 'severity': 'high'})
```
- ›Adds GCSPDFKnowledgeBase class to load and query PDFs stored on Google Cloud Storage as a knowledge base source.
- ›Adds session_state parameter to agent and team run calls, allowing callers to pass initial session state at invocation time.
v1.7.2 Jul 10, 2025 · issue -364

Agno v1.7.2 adds MySQLStorage backend, XAi live search, OpenAI deep research models, and memory growth tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.2
```
└──▷ USE IT
Track memory growth during a performance evaluation to diagnose leaks in long-running agent workloads.
python
```
from agno.eval.performance import PerformanceEval
from agno.agent import Agent

eval = PerformanceEval(agent=Agent(), memory_growth_tracking=True)
eval.run()
```
Use OpenAI deep research models for in-depth, multi-step research tasks inside an agent.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(model=OpenAIChat(id="o3-deep-research"))
agent.print_response("Research the latest advances in quantum error correction.")
```
- ›Adds MySQLStorage class as a session storage backend for agents, teams, and workflows.
- ›Adds memory_growth_tracking attribute on PerformanceEval to enable debug logs for memory growth during performance evaluations.
- ›Adds agent and team as optional parameters in tool hooks for greater flexibility.
- ›Supports live search on the XAi model provider.
- ›Supports o4-mini-deep-research and o3-deep-research OpenAI model identifiers.
v1.7.1 Jul 4, 2025 · issue -364

Agno v1.7.1 adds debug_level to Agent/Team, Gemini thinking params, Valyu/Oxylabs toolkits, and new Serper tools.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.1
```
└──▷ USE IT
Enable verbose model logging on an agent to diagnose LLM request/response details during development.
python
```
from agno.agent import Agent

agent = Agent(
    model=my_model,
    debug_level=2,
)
```
Configure a Gemini model to expose its chain-of-thought reasoning alongside the final response.
python
```
from agno.models.gemini import Gemini

model = Gemini(
    id="gemini-2.0-flash-thinking-exp",
    thinking_budget=1024,
    include_thoughts=True,
)
```
Search academic literature from within an agent using the new Valyu deep-search toolkit.
python
```
from agno.agent import Agent
from agno.tools.valyu import ValyuTools

agent = Agent(tools=[ValyuTools()])
agent.print_response("Find recent papers on retrieval-augmented generation")
```
- ›Adds debug_level parameter (int 1 or 2) to both Agent and Team classes for controlling logging verbosity, with 2 enabling more verbose model logs.
- ›Adds thinking_budget and include_thoughts parameters to the Gemini model class for configuring Gemini thinking behavior.
- ›Adds parser_model parameter support to Team for structured output via a dedicated parser model.
- ›Adds search_news, search_scholar, and scrape_webpage tools to the Serper toolkit.
- ›New OxylabsTools toolkit for web-scraping capabilities in agents.
+1 moreshow less
- ›New Valyu toolkit for deep search of academic sources.
v1.7.0 Jun 26, 2025 · issue -365

Agno v1.7.0 adds add_tool(), streaming structured output, and a Linear teams tool
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.7.0
```
└──▷ USE IT
Add a new tool to an already-initialised agent at runtime without rebuilding it from scratch.
python
```
agent = Agent(tools=[existing_tool])
agent.add_tool(new_tool)
```
- ›Adds add_tool(tool) convenience method to Agent and Team to append new tools after initialisation.
- ›Streaming with response_model now stays in streaming mode: calling run(..., stream=True) or arun(..., stream=True) with a response_model set returns Iterator[RunResponseEvent] / AsyncIterator[RunResponseEvent] instead of switching off streaming; the structured output appears on RunResponseContentEvent and the final RunResponseCompletedEvent.
- ›Adds a Linear tool to retrieve the list of teams (get_team_details).
└──▷ BREAKING ON UPGRADE
- !Calling run(..., stream=True) or arun(..., stream=True) on Agent or Team with a response_model set no longer returns a single RunResponse object — it now returns Iterator[RunResponseEvent] / AsyncIterator[RunResponseEvent]. Code that consumed the old single-object response must be updated to iterate over events instead.
v1.6.4 Jun 23, 2025 · issue -365

Agno v1.6.4 adds Brightdata web scraping, OpenCV webcam capture, DiscordClient bot integration, and a FileTools search method.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.6.4
```
- ›Adds search method to FileTools for searching files within the toolkit.
- ›Adds Brightdata Toolkit with multiple web-based tools including web scraping and data feed capabilities.
- ›Adds OpenCV Video/Image Toolkit with tools for capturing images and video via webcam.
- ›Adds DiscordClient app for connecting an agent or team to Discord as a Discord bot.
└──▷ BREAKING ON UPGRADE
- !SerperApiTools is renamed to SerperTools; any code importing or referencing SerperApiTools will break.
v1.6.3 Jun 18, 2025 · issue -365

Agno v1.6.3 adds store_events to RunResponse, metadata filtering for CSV knowledge bases, and user control flows on the Playground.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.6.3
```
- ›Adds store_events parameter to RunResponse/TeamRunResponse to optionally persist all events that occurred during an agent or team run.
- ›Adds metadata filtering support for csv and csv_url knowledge base types.
- ›Adds user control flows support on the Agno Platform Playground.
- ›Shows team member responses during team runs on the Agno Platform Playground.
- ›Shows behind-the-scenes activity during agent and team runs on the Agno Platform Playground.
└──▷ BREAKING ON UPGRADE
- !Async knowledge-base function names (e.g. asearch_knowledge_base) are renamed to match their sync counterparts — any model function-calling configuration referencing the old a-prefixed names will stop working.
v1.6.1 Jun 13, 2025 · issue -365

Agno v1.6.1 adds Nebius embeddings, Firestore memory/storage, async DocumentKnowledgeBase, and enum support in custom tools.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.6.1
```
└──▷ USE IT
Suppress member-level event noise when you only care about top-level team events in a streaming pipeline.
python
```
team = Team(
    members=[...],
    stream_member_events=False
)
```
- ›Adds stream_member_events to team configuration to optionally disable streaming of member events.
- ›Adds agent_name to agent events and team_name to team events in event payloads; adds team_session_id to team-member events.
- ›Adds enum parameter support in custom tools across all models.
- ›Adds async support to DocumentKnowledgeBase.
- ›Adds Nebius as a supported embedding model provider.
+1 moreshow less
- ›Adds Firestore as a memory and storage provider for agents.
v1.6.0 Jun 10, 2025 · issue -365

Agno v1.6.0 overhauls streaming events for agents, teams, and workflows with granular typed events and member-event propagation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.6.0
```
└──▷ USE IT
Inspect a non-streaming run response status to detect paused or cancelled runs.
python
```
response = agent.run('Analyze the logs')
if response.status == 'CANCELLED':
    print('Run was cancelled before completion')
elif response.status == 'PAUSED':
    print('Run is awaiting input')
```
- ›Adds RunResponseContent, RunError, RunCancelled, ToolCallStarted, and ToolCallCompleted event types to agent streaming runs via agent.run(..., stream=True) or agent.arun(..., stream=True).
- ›Adds RunStarted, RunCompleted, ReasoningStarted, ReasoningStep, ReasoningCompleted, MemoryUpdateStarted, and MemoryUpdateCompleted intermediate event types for agents when stream_intermediate_steps=True.
- ›Adds RunResponse.status attribute indicating whether a run response is RUNNING, PAUSED, or CANCELLED.
- ›Adds team-scoped streaming event types — TeamRunResponseContent, TeamRunError, TeamRunCancelled, TeamToolCallStarted, TeamToolCallCompleted — plus intermediate events (TeamRunStarted, TeamRunCompleted, TeamReasoningStarted, TeamReasoningStep, TeamReasoningCompleted, TeamMemoryUpdateStarted, TeamMemoryUpdateCompleted) when stream_intermediate_steps=True.
- ›Teams now propagate and yield streaming events from individual team members as they execute, surfacing member-level activity in the top-level event stream.
+1 moreshow less
- ›Workflows now support WorkflowRunResponseStartedEvent and WorkflowRunResponseCompletedEvent events for structured run lifecycle signalling.
└──▷ BREAKING ON UPGRADE
- !RunResponse no longer has an event attribute; code reading RunResponse.event will break.
- !Streaming run events are reformulated — existing code consuming the old event shapes from agent.run(..., stream=True) or agent.arun(..., stream=True) must be updated to the new typed event types.
- !Team streaming events are reformulated with new Team-prefixed event types; existing code consuming team stream events must be updated.
- !Workflows must now yield WorkflowRunResponseStartedEvent and WorkflowRunResponseCompletedEvent; workflows that do not yield these events will be missing lifecycle signals.
v1.5.10 Jun 7, 2025 · issue -365

Agno v1.5.10 adds Playground file upload, async evals, and an Exa Research tool integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.10
```
- ›Adds research tool to ExaTools, enabling deep research queries against Exa's research API directly from agents.
- ›Adds async support to all evaluations, allowing evals to run non-blocking in async workflows.
- ›Adds file upload support to the Agno Playground, routing PDF, CSV, DOCX, and other files directly to agents/teams or to an attached knowledge base.
v1.5.9 Jun 5, 2025 · issue -365

Agno v1.5.9 adds AG-UI app, vLLM, LightRAG, 4 new toolkits, PDFBytesKnowledgeBase, and location-aware agents
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.9
```
└──▷ USE IT
Ingest a PDF received as bytes (e.g. from an HTTP response or upload) directly into a knowledge base without writing it to disk.
python
```
from agno.knowledge.pdf_bytes import PDFBytesKnowledgeBase
import httpx

pdf_bytes = httpx.get('https://example.com/report.pdf').content
kb = PDFBytesKnowledgeBase(pdf_bytes=pdf_bytes)
kb.load()
```
Make an agent location-aware so its instructions automatically include where it is running — useful for geo-sensitive tasks.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    add_location_to_instructions=True,
)
agent.print_response('What businesses near me are open right now?')
```
Give an agent access to Google search results via Serper for real-time web lookups.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.serper import SerperTools

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    tools=[SerperTools()],
)
agent.print_response('What are the latest CVEs disclosed this week?')
```
- ›Adds SerperTools toolkit to enable agents to search Google via Serper.
- ›Adds DaytonaTools toolkit to let agents execute code remotely on Daytona sandboxes.
- ›Adds AWSSESTools toolkit to send emails via AWS SES.
- ›Adds PDFBytesKnowledgeBase class to ingest in-memory PDF content via bytes or IO streams instead of file paths.
- ›Adds add_location_to_instructions parameter to automatically detect and inject the agent's current location into the system message.
+10 moreshow less
- ›Adds search_posts method to XTools for searching posts on X.
- ›Adds GmailTools attachment support for sending emails with attachments.
- ›Updates FastAPIApp to replace agent with agents and team with teams, and adds workflows support; agents/teams/workflows are now selected via query param (e.g. ?agent_id=my-agent).
- ›Adds AG-UI compatible FastAPI app to expose Agno agents and teams to AG-UI clients.
- ›Adds vLLM model support for running self-hosted vLLM inference via Agno.
- ›Adds LangDB AI Gateway integration as a model provider.
- ›Adds LightRAG server support, providing a graph-based RAG system for document retrieval and knowledge querying.
- ›Adds Parser Model capability to apply structured output to a model response using an external model.
- ›Adds URL expansion to the Crawl4ai toolkit so shortened URLs are resolved to their final destination before crawling.
- ›Adds MCP support for Qdrant via the Qdrant MCP server cookbook integration.
└──▷ BREAKING ON UPGRADE
- !FastAPIApp now requires agents instead of agent and teams instead of team; callers must also explicitly specify which agent, team, or workflow to run (e.g. ?agent_id=my-agent), so existing single-agent setups will break without updating both field names and the request URL.
v1.5.8 Jun 3, 2025 · issue -365

Agno v1.5.8 adds SlackApp, VisualizationTools, BraveSearch toolkit, and reworks FastAPIApp/WhatsappAPI serving
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.8
```
└──▷ USE IT
Give an agent the ability to produce matplotlib charts on demand during a run.
python
```
from agno.agent import Agent
from agno.tools.visualization import VisualizationTools

agent = Agent(
    name="ChartAgent",
    tools=[VisualizationTools()],
)
agent.print_response("Plot a bar chart of monthly sales: Jan=120, Feb=95, Mar=140")
```
Enable Brave web search for an agent using the new BraveSearch toolkit.
python
```
from agno.agent import Agent
from agno.tools.brave_search import BraveSearch

agent = Agent(
    name="WebSearchAgent",
    tools=[BraveSearch()],
)
agent.print_response("What are the latest CVEs disclosed this week?")
```
- ›Adds SlackApp class to build Slack-connected agents that respond to direct messages, group chats, and automatically create threads for replies.
- ›Adds VisualizationTools toolkit (backed by matplotlib) giving agents the ability to generate graphs.
- ›Adds BraveSearch toolkit so agents can search the web via the Brave Search API.
- ›Adds infer as a parameter to Mem0Tools, exposing inference control in the memory toolkit.
- ›Passes knowledge_filters through when self.add_references=True (traditional RAG path), keeping filter behavior consistent with Agentic RAG.
+2 moreshow less
- ›FastAPIApp now exposes a .serve() method on the instance, replacing the standalone serve_fastapi_app function, and the run endpoint moves from /run to /runs.
- ›WhatsappAPI now exposes a .serve() method on the instance, replacing the standalone serve_whatsapp_app function.
└──▷ BREAKING ON UPGRADE
- !FastAPIApp no longer has a default prefix, and the run endpoint is renamed from /run to /runs — any client or integration hitting <domain>/run will break.
- !serve_fastapi_app is replaced by .serve() on the FastAPIApp instance — call sites using the standalone function will break.
- !serve_whatsapp_app is replaced by .serve() on the WhatsappAPI instance — call sites using the standalone function will break.
v1.5.6 May 29, 2025 · issue -366

Agno v1.5.6 adds Team Evals, async Workflow support via arun, and an Anthropic MCP connector tool.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.6
```
└──▷ USE IT
Cap the total number of tool calls an agent may make across a full run to prevent runaway loops.
python
```
from agno.agent import Agent
from my_tools import search_tool

agent = Agent(
    tools=[search_tool],
    tool_call_limit=10,
)
agent.run('Research the latest CVEs in OpenSSL')
```
- ›Adds arun method to Workflows, enabling async Python usage of the Workflow class.
- ›Revamps tool_call_limit to enforce the limit across an entire agent run, not per-call.
- ›Adds evaluation (Evals) support for Teams, extending the existing eval framework to multi-agent team configurations.
- ›Adds team_session_state management on the Team class, propagating shared state to all members and sub-teams.
- ›Improves performance of user memory updates and session summary generation by parallelising writes.
└──▷ BREAKING ON UPGRADE
- !Managing team_session_state now requires setting it on the Team object directly instead of via session_state; existing code using session_state for this purpose will no longer propagate team session state correctly.
v1.5.5 May 27, 2025 · issue -366

Agno v1.5.5 adds Claude file upload, prompt caching, Qdrant hybrid search, Markdown knowledge bases, and AI/ML API integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.5
```
└──▷ USE IT
Retrieve messages from the last N sessions so an agent can reason across conversation history.
python
```
agent = Agent(
    ...
    search_previous_sessions_history=True,
)
```
Set a TTL on Redis-backed agent storage so stale session data expires automatically.
python
```
storage = RedisStorage(
    ...
    expire=3600,
)
```
- ›Adds search_previous_sessions_history to enable a get_previous_session_messages(number_of_sessions: int) tool that lets agents retrieve and analyse messages from the last N sessions.
- ›Adds expire key to Redis storage configuration to set TTL on Redis keys.
- ›Adds cache_creation_input_tokens to agent session metrics for tracking Anthropic prompt-cache write statistics.
- ›Supports direct file upload to Anthropic for use as agent input (Claude File Upload).
- ›Enables Python code execution in a secure, sandboxed environment via the Claude 4 Code Execution Tool.
+6 moreshow less
- ›Adds prompt caching for Anthropic models, allowing resumption from specific prompt prefixes to reduce processing time and cost on repetitive tasks.
- ›Adds support for Vercel v0 models.
- ›Adds Qdrant hybrid search support.
- ›Adds native MarkdownKnowledgeBase support for Markdown-based knowledge bases.
- ›Integrates the AI/ML API platform, providing access to 300+ models including DeepSeek, Gemini, and ChatGPT at enterprise-grade rate limits.
- ›Adds support for Pydantic and dataclass objects as direct inputs to agent tool functions.
v1.5.4 May 23, 2025 · issue -366

Agno v1.5.4 adds Human-in-the-loop control flows, a Mem0 memory toolkit, and Firecrawl web search support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.4
```
└──▷ USE IT
Give an agent the ability to dynamically decide when to ask the user for input during a run.
python
```
from agno.agent import Agent
from agno.tools.user_control_flow import UserControlFlowTools

agent = Agent(
    tools=[UserControlFlowTools(), ...],
    ...
)
```
- ›Adds @tool(requires_confirmation=True) decorator to pause agent runs and require explicit user confirmation before a tool executes.
- ›Adds @tool(requires_user_input=True) decorator to halt agent execution and prompt for user input before continuing.
- ›Adds @tool(external_execution=True) decorator to signal that a tool function will be executed outside the agent context.
- ›Adds UserControlFlowTools() — include it in an agent to enable dynamic, model-driven user-input pauses anywhere in a run.
- ›Adds agent.continue_run and agent.acontinue_run methods to resume a paused agent run after user control flow requirements are satisfied.
+4 moreshow less
- ›Adds a Mem0 toolkit for managing memories inside Mem0 from within an agent.
- ›Adds Firecrawl web search support inside FirecrawlTools.
- ›Adds MongoDB hybrid search support for vector store retrieval.
- ›Adds an auto_suggest parameter to the Wikipedia toolkit's summary function.
v1.5.3 May 21, 2025 · issue -366

Agno v1.5.3 improves accuracy evaluation methodology for more reliable agent-based assessment.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.3
```
- ›Updates the accuracy evaluation mechanism to use a more precise agent-based approach for measuring agent performance.
v1.5.2 May 20, 2025 · issue -366

Agno v1.5.2 adds FastAPI/WhatsApp app wrappers, Couchbase vector DB, BigQuery tools, and async S3 readers
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.2
```
└──▷ USE IT
Use Azure Cosmos DB for MongoDB (vCore) as a drop-in vector store by enabling the compatibility flag on the existing MongoDB vector DB class.
python
```
from agno.vectordb.mongodb import MongoDBVectorDb

vector_db = MongoDBVectorDb(
    connection_string="<your-cosmos-vcore-connection-string>",
    database_name="agno_kb",
    collection_name="embeddings",
    cosmos_compatibility=True,
)
```
Give every tool in a toolkit a consistent stop-after-call and show-result behaviour without decorating each function individually.
python
```
from agno.tools import Toolkit

class MyTools(Toolkit):
    def __init__(self):
        super().__init__(
            stop_after_tool_call_tools=["run_query"],
            show_result_tools=["run_query", "fetch_report"],
        )
```
- ›Adds FastAPIApp class — a convenience wrapper that spins up a FastAPI server exposing an agent or team with minimal boilerplate.
- ›Adds WhatsappAPIApp class — implements the WhatsApp protocol so an Agno agent can run on WhatsApp, with image/audio/video input, image response generation, and reasoning support.
- ›Adds stop_after_tool_call_tools and show_result_tools properties to the base Toolkit class, mirroring the per-tool behavior previously only available via the @tool decorator.
- ›Enables cosmos_compatibility=True on the MongoDB vector DB class to add Azure Cosmos DB for MongoDB (vCore) as a supported vector store backend.
- ›Adds Couchbase as a supported vector DB for knowledge bases.
+4 moreshow less
- ›Adds async support for pdf and text S3 readers.
- ›Adds a Google BigQuery toolkit for querying BigQuery from agents.
- ›Extends knowledge-base filters (manual and agentic) to work with Teams, not just individual agents.
- ›72% speed improvement to WebsiteReader._extract_main_content, unlocking faster large-scale web knowledge ingestion.
v1.5.1 May 16, 2025 · issue -366

Agno v1.5.1 adds Nebius as a model provider, extends vector DB filter support to pgvector/Milvus/Weaviate/Chroma, and adds SSL to Redis storage.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.5.1
```
└──▷ USE IT
Enable SSL when connecting to a Redis storage backend to secure session data in transit.
python
```
from agno.storage.redis import RedisStorage

storage = RedisStorage(
    host="my-redis-host",
    port=6380,
    ssl=True
)
```
- ›Adds ssl parameter to the Redis storage class, enabling encrypted connections to Redis backends.
- ›Adds Nebius (Nebius Studio) as a new model provider via an OpenAI-compatible interface.
- ›Extends filtering support to additional vector databases: pgvector, Milvus, Weaviate, and Chroma.
v.1.5.0 May 13, 2025 · issue -366

Agno v1.5.0 adds Azure OpenAI DALL-E image generation, OpenTelemetry auto-instrumentation, Milvus hybrid search, and streamable-HTTP MCP transport.
└──▷ GET THIS VERSION
```
$ git clone --branch v.1.5.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v.1.5.0
```
- ›Adds hybrid_search support to the Milvus vector DB integration.
- ›Adds streamable-HTTP transport support for MCP servers via MCPTools.
- ›Adds an OpenInference auto-instrumentor for Agno agents, enabling tracing to any OpenTelemetry-compatible provider (Arize, Langfuse, Langsmith).
- ›Adds Azure OpenAI image generation via DALL-E through Azure AI Foundry.
- ›Adds ability to run accuracy evaluations with pre-generated answers; agent, prompt, and expected_answer are now accepted fields on the accuracy eval class.
└──▷ BREAKING ON UPGRADE
- !The performance evaluation class PerfEval is renamed to PerformanceEval; any code referencing PerfEval will break.
- !The accuracy evaluation class now requires three fields — agent, prompt, and expected_answer — that were not previously required; existing instantiations omitting these fields will break.
- !Duplicate information has been removed from streaming events when stream=True during concurrent agent runs; consumers that relied on that duplicated data in individual events will need to update their handling.
v1.4.7 May 13, 2025 · issue -366

Agno v1.4.7 adds Azure OpenAI image generation, OpenTelemetry auto-instrumentation, Milvus hybrid search, and streamable-HTTP MCP transport.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.7
```
└──▷ USE IT
Enable hybrid search on a Milvus vector DB to combine dense and sparse retrieval for higher-recall knowledge base queries.
python
```
from agno.vectordb.milvus import Milvus

vdb = Milvus(
    collection="my_collection",
    hybrid_search=True,
)
```
- ›Adds hybrid_search support to the Milvus vector DB integration.
- ›Adds streamable-HTTP transport support for MCP servers via MCPTools.
- ›Adds an auto-instrumentor for Agno agents contributed to the OpenInference project, enabling tracing with any OpenTelemetry-compatible provider (Arize, Langfuse, Langsmith).
- ›Adds Azure OpenAI image generation tool backed by DALL-E via Azure AI Foundry.
- ›Extends accuracy evaluations to run against pre-generated answers across all evals classes.
└──▷ BREAKING ON UPGRADE
- !The PerfEval class is renamed to PerformanceEval; any code importing or instantiating PerfEval will break.
- !The accuracy evaluation class now requires three new mandatory fields: agent, prompt, and expected_answer; existing instantiations that omit these will raise errors.
- !Duplicate information has been removed from streaming events when stream=True during concurrent agent runs; code that parsed or depended on the previous event shape will need to be updated.
v1.4.6 May 10, 2025 · issue -366

Agno v1.4.6 adds Cerebras model support, Claude web search, and metadata-filtered knowledge bases with agentic filter detection.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.6
```
└──▷ USE IT
Let the agent automatically extract filter values from the user's natural-language query, avoiding manual filter construction.
python
```
agent = Agent(
    knowledge=knowledge_base,
    enable_agentic_knowledge_filters=True
)
agent.run("Tell me about John Doe's performance review")
```
Tag documents with metadata at ingest time so they can be filtered later by any knowledge_filters call.
python
```
knowledge_base = PDFKnowledgeBase(path=[
    {"path": "alice_records.pdf", "metadata": {"user_id": "alice"}},
    {"path": "bob_records.pdf",   "metadata": {"user_id": "bob"}}
])
```
- ›Adds knowledge_filters parameter to Agent(...) initialization and to agent.run(...) calls for explicit metadata-based document filtering in knowledge bases.
- ›Adds enable_agentic_knowledge_filters=True on Agent to let the agent automatically detect and apply knowledge filters extracted from user queries.
- ›Adds metadata parameter to PDFKnowledgeBase path entries and to knowledge_base.load_document(path=..., metadata=...) for attaching filterable metadata at ingest time.
- ›Adds current_user_id and current_session_id as default variables in session_data for tools, making user and session context available inside tool execution.
- ›Adds Cerebras as a model provider (both OpenAILike and SDK integrations).
+2 moreshow less
- ›Adds support for Claude's web search tool.
- ›Knowledge Base metadata filtering (beta) supports PDF, Text, DOCX, JSON, and PDF_URL knowledge base types, and Qdrant, LanceDB, and MongoDB vector databases.
v1.4.5 May 6, 2025 · issue -366

Agno v1.4.5 adds AWS Bedrock embeddings, Gemini video generation, and a revamped Apify integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.5
```
- ›Adds AwsBedrockEmbedder class for generating embeddings via AWS Bedrock, defaulting to the cohere.embed-multilingual-v3 model.
- ›Adds video generation capabilities to GeminiTools.
- ›Revamps ApifyTools for full compatibility with Apify actors.
v1.4.4 May 4, 2025 · issue -366

Agno v1.4.4 adds async retrievers, OpenAI File uploads, Gemini video URLs, and expanded Llama model capabilities.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.4
```
└──▷ USE IT
Use an async retriever to integrate non-blocking document lookup into an agent pipeline.
python
```
async def my_retriever(query: str, **kwargs):
    results = await async_search(query)
    return results

agent = Agent(retriever=my_retriever, ...)
await agent.arun('What does the policy say about data retention?')
```
Attach a PDF file directly to an OpenAIChat agent prompt for in-context document analysis.
python
```
from agno.models.openai import OpenAIChat
from agno.agent import Agent
from agno.media import File

agent = Agent(model=OpenAIChat(id='gpt-4o'))
agent.run('Summarize this report.', files=[File(filepath='report.pdf')])
```
Pass a video URL to a Gemini agent for multimodal video analysis.
python
```
from agno.models.google import Gemini
from agno.agent import Agent
from agno.media import Video

agent = Agent(model=Gemini(id='gemini-2.0-flash'))
agent.run('Describe what happens in this video.', videos=[Video(url='https://example.com/incident.mp4')])
```
- ›The retriever parameter now accepts an async function, enabling async custom retrieval with agent.arun and agent.aprint_response.
- ›Adds support for attaching File objects to prompts for agents using OpenAIChat models, including PDF and document uploads.
- ›Adds Video(url=...) input support for Gemini models.
- ›Expands Llama and LlamaOpenAI model classes with structured output and image input support.
v1.4.3 Apr 30, 2025 · issue -367

Agno v1.4.3 adds native Llama API model classes, AWS session token support for Claude, and DynamoDB profile-based auth.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.3
```
- ›Adds native SDK and OpenAI-like model classes for the Llama API.
- ›Adds AWS session token support for Claude, enabling use of credentials from assumed IAM roles.
- ›Adds AWS profile-based authentication support for DynamoDB.
- ›Adds reasoning model support for o4-mini (and anticipated o4) in the OpenAI reasoning model class.
v1.4.2 Apr 24, 2025 · issue -367

Agno v1.4.2 adds MCP SSE transport, tool hooks, shared team session state, and new Cartesia, Gemini, and Groq tool integrations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.2
```
- ›Adds MCP SSE transport support, enabling agents to connect to SSE MCP Servers alongside the existing transport options.
- ›Adds tool hooks that wrap around all tool calls for both Toolkits and custom tools, enabling pre/post-call logic across every tool invocation.
- ›Adds shared Team Session State — a single state dictionary accessible across a team leader and all team members via tools given to the leader or members.
- ›Adds CartesiaTool for text-to-speech capabilities using Cartesia.
- ›Adds a Gemini image tool for generating images using Gemini models.
+3 moreshow less
- ›Adds Groq audio tools for audio translation, transcription, and generation using Groq models.
- ›Expands result sets returned by PubmedTools.
- ›Allows custom tools to return any type — the return value is now handled and converted automatically before being passed to the model.
v1.4.1 Apr 23, 2025 · issue -367

Agno v1.4.1 adds meeting notification sending and richer PubMed article data to its toolkits.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.1
```
- ›Adds option in the Google Calendar / meeting toolkit to send meeting notifications to attendees when creating or updating events.
- ›Enhances PubmedTools with more comprehensive article data, returning additional metadata fields beyond basic citation info.
v1.4.0 Apr 23, 2025 · issue -367

Agno v1.4.0 promotes Memory to GA, adds OpenAITools and ZepTools, and brings include/exclude tool filtering to all toolkits.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.4.0
```
└──▷ USE IT
Limit a large toolkit to only the tools your agent actually needs, reducing attack surface and token overhead.
python
```
from agno.tools.some_toolkit import SomeToolkit

agent = Agent(
    tools=[SomeToolkit(include_tools=["search", "fetch"])],
)
```
- ›Adds include_tools and exclude_tools parameters to all toolkits, enabling selective enabling/disabling of individual tools inside larger toolkits.
- ›Adds OpenAITools class to enable text-to-speech and image generation through OpenAI's APIs.
- ›Adds ZepTools and AsyncZepTools classes to manage Agent memories via zep-cloud.
- ›Promotes Agentic user Memory management from beta to generally available, with enable_user_memories and enable_session_summaries now set directly on the Agent or Team.
- ›Adds reasoning model support (e.g. Deepseek-R1) via Azure AI Foundry.
└──▷ BREAKING ON UPGRADE
- !Agents now default to the new Memory class instead of the deprecated AgentMemory; agent.memory.messages is replaced by run.messages for run in agent.memory.runs (or agent.get_messages_for_session()).
- !create_user_memories is renamed to enable_user_memories and must now be set directly on the Agent or Team.
- !create_session_summary is renamed to enable_session_summaries and must now be set directly on the Agent or Team.
v1.3.5 Apr 21, 2025 · issue -367

Agno v1.3.5 adds async support for five vector DBs, reasoning events on RunResponse, and Google Gemini cache support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.3.5
```
- ›Populates reasoning_content on RunResponse for all reasoning types across stream/non-stream and async/non-async modes, with a unified JSON structure for Reasoning events.
- ›Adds async support for ClickHouse, ChromaDB, Cassandra, PineconeDB, and Pgvector vector database backends.
- ›Adds Google Gemini caching support: cache files and send cached content to Gemini models.
v1.3.4 Apr 19, 2025 · issue -367

Agno v1.3.4 adds a web browser tool, proxy support for URL and PDF readers, and improved memory management.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.3.4
```
└──▷ USE IT
Pass custom Azure client parameters to the embedder at construction time.
python
```
from agno.embedder.azure_openai import AzureOpenAIEmbedder

embedder = AzureOpenAIEmbedder(
    client_params={
        'api_version': '2024-02-01',
        'azure_deployment': 'my-embedding-deployment'
    }
)
```
- ›Adds proxy parameter to the URL reader, enabling requests through a proxy when fetching remote content.
- ›Adds proxy parameter to the PDF reader, enabling proxy-routed PDF retrieval.
- ›Adds client_params argument support to AzureOpenAIEmbedder, allowing custom client parameters to be passed through.
- ›Adds mode attribute to Team class data serialization, exposing team mode in serialized output.
- ›Adds a new webbrowser tool for agents to interact with web browsers.
+2 moreshow less
- ›Improves memory management with updates to the Memory system for better session and memory handling.
- ›Gives database session state preference over in-memory session state for more consistent agent state persistence.
v1.3.3 Apr 17, 2025 · issue -367

Agno v1.3.3 adds Ollama and AzureOpenAI reasoning support, Gemini file upload, and expanded token metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.3 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.3.3
```
- ›Adds audio, reasoning, and cached token counts to metrics where available across models.
- ›Enables native reasoning model support for Ollama and AzureOpenAI providers.
- ›Enables direct use of uploaded files with Gemini models.
v.1.3.2 Apr 16, 2025 · issue -367

Agno v1.3.2 adds Redis as a Memory storage backend and new agent convenience methods for session and user memory retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch v.1.3.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v.1.3.2
```
└──▷ USE IT
Retrieve the previous session summary and user memories programmatically after an agent run.
python
```
summary = agent.get_session_summary()
user_memories = agent.get_user_memories()
print(summary)
print(user_memories)
```
- ›Adds add_member_tools_to_system_message to team configuration, allowing the member tool names to be removed from the system message sent to the team leader for broader transfer-function compatibility.
- ›Adds agent.get_session_summary() method to retrieve the previous session summary from an agent.
- ›Adds agent.get_user_memories() method to retrieve the current user's memories from an agent.
- ›Supports Redis as a storage provider for Memory, enabling persistent memory backed by Redis.
- ›Supports additional instructions on MemoryManager and SessionSummarizer for customizing memory behavior.
+1 moreshow less
- ›Supports skipping SSL verification for Confluence connections when required.
v1.3.0 Apr 13, 2025 · issue -367

Agno v1.3.0 revamps Memory with a new class, adds user/session params to agent.run(), and ships Redis session storage.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.3.0
```
└──▷ USE IT
Serve multiple users from a single agent instance by scoping each call to a specific user and session.
python
```
agent.run("What did I order last time?", user_id="user-42", session_id="session-abc123")
```
- ›Adds user_id and session_id parameters to agent.run(), scoping memory access to a single user and session to enable multi-user, multi-session applications from one agent configuration.
- ›Introduces a new Memory class (beta) supporting add, update, delete, and semantic search over user memories, with agent-driven memory management.
- ›Adds Redis as a session storage provider.
v1.2.16 Apr 11, 2025 · issue -367

Agno v1.2.16 adds knowledge bases with agentic RAG to Teams, mirroring existing Agent functionality.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.16 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.16
```
└──▷ USE IT
Attach a knowledge base to a Team with agentic RAG so the team leader can search documents before delegating tasks.
python
```
team = Team(
    members=[agent1, agent2],
    knowledge=knowledge_base,
    retriever=my_custom_retriever,
    search_knowledge=True,
)
```
- ›Adds knowledge, retriever, and search_knowledge fields to Team, enabling knowledge bases and agentic RAG on teams (previously only available on Agent).
- ›Improves Teams task forwarding reliability and makes the team leader more conversational, with new reasoning-with-teams examples.
v1.2.14 Apr 8, 2025 · issue -367

Agno v1.2.14 adds expanded GithubTools, async MongoDB VectorDB support, and stream_intermediate_resp on print_response.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.14 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.14
```
└──▷ USE IT
Stream intermediate agent responses to the console as they arrive, useful for long-running tasks where you want live visibility.
python
```
agent.print_response(stream_intermediate_resp=True)
```
- ›Adds stream_intermediate_resp parameter to print_response for streaming intermediate responses.
- ›Expands GithubTools with many additional capabilities.
- ›Adds async support for MongoDB as a vector database, enabling use in async knowledge bases.
- ›Converts all utility scripts to be Windows-compatible.
v1.2.12 Apr 8, 2025 · issue -367

Agno v1.2.12 adds ReasoningTools, timezone-aware agents, and Google Cloud JSON session storage
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.12
```
└──▷ USE IT
Ensure an agent's date-aware instructions reflect the user's local timezone rather than UTC.
python
```
from agno.agent import Agent

agent = Agent(
    timezone_identifier="America/New_York",
    # ... other params
)
```
Give an agent an advanced reasoning scratchpad so it can work through complex problems step-by-step before responding.
python
```
from agno.agent import Agent
from agno.tools.reasoning import ReasoningTools

agent = Agent(
    tools=[ReasoningTools()],
    # ... other params
)
```
- ›Adds timezone_identifier parameter to the Agent class to include the agent's timezone alongside the current date in its instructions.
- ›Adds ReasoningTools class providing an advanced reasoning scratchpad for agents.
- ›Adds JSON-based session storage on Google Cloud via a new Google Cloud Storage backend for memory/session state.
- ›Extends async/await support to URLKnowledgeBase, FireCrawlKnowledgeBase, and DocxKnowledgeBase for non-blocking knowledge base operations.
- ›Enables thinking support for the @tool decorator.
v1.2.10 Apr 5, 2025 · issue -367

Agno v1.2.10 adds KnowledgeTools for agent-driven thinking, searching, and document analysis over a knowledge base.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.10
```
└──▷ USE IT
Equip an agent with KnowledgeTools so it can autonomously search and reason over documents in a knowledge base at query time.
python
```
from agno.tools.knowledge import KnowledgeTools

agent = Agent(
    knowledge=knowledge_base,
    tools=[KnowledgeTools(knowledge=knowledge_base)],
)
```
- ›Adds KnowledgeTools class enabling agents to think, search, and analyse documents within a knowledge base.
v1.2.9 Apr 5, 2025 · issue -367

Agno v1.2.9 adds MultiMCPTools for connecting agents to multiple MCP servers in a single interface.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.9
```
└──▷ USE IT
Connect an agent to multiple MCP servers at once using the new MultiMCPTools class.
python
```
from agno.tools.mcp import MultiMCPTools

tools = MultiMCPTools(
    commands=[
        "npx -y @modelcontextprotocol/server-filesystem /tmp",
        "npx -y @modelcontextprotocol/server-brave-search"
    ]
)

agent = Agent(tools=[tools], ...)
```
- ›Adds MultiMCPTools class to connect agents to multiple MCP servers simultaneously, with a simplified interface that only accepts command.
- ›Updates Gemini model support for structured outputs when tools are in use.
└──▷ BREAKING ON UPGRADE
- !The MCPTools interface now only allows command to be passed; any previously supported parameters beyond command will no longer be accepted.
v1.2.8 Apr 4, 2025 · issue -367

Agno v1.2.8 adds instructions and add_instructions to Toolkit so tool usage guidance flows into the model system message.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.8
```
└──▷ USE IT
Attach tool-specific instructions to a custom toolkit so the model always receives guidance on how to use it, without manually editing the agent system prompt.
python
```
from agno.tools import Toolkit

class MySearchToolkit(Toolkit):
    def __init__(self):
        super().__init__(
            name="my_search",
            instructions="Always prefer recent results. Limit queries to 10 words.",
            add_instructions=True,
        )

    def search(self, query: str) -> str:
        ...
```
- ›Adds instructions and add_instructions fields to the Toolkit class, allowing per-toolkit usage instructions to be injected into the model's system message when add_instructions=True.
v1.2.7 Apr 2, 2025 · issue -367

Agno v1.2.7 adds Gemini image generation, async knowledge base/vector DB support, and result caching on all toolkits.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.7
```
└──▷ USE IT
Load a large PDF knowledge base asynchronously to speed up ingestion in an async agent pipeline.
python
```
import asyncio
from agno.knowledge.pdf import PDFKnowledgeBase

kb = PDFKnowledgeBase(path='reports/')
asyncio.run(kb.aload())
```
- ›Adds image generation via the gemini-2.0-flash-exp-image-generation model, enabling agents to produce images directly through Gemini.
- ›Adds result caching to all Agno Toolkits and any custom functions decorated with @tool.
- ›Adds async/await support to LanceDb, Milvus, and Weaviate vector DBs, enabling use in agent.arun and agent.aprint_response.
- ›Adds async/await support to JSONKnowledgeBase, PDFKnowledgeBase, PDFUrlKnowledgeBase, CSVKnowledgeBase, CSVUrlKnowledgeBase, ArxivKnowledgeBase, WebsiteKnowledgeBase, YoutubeKnowledgeBase, and TextKnowledgeBase.
- ›Enables knowledge_base.aload() for async knowledge base loading, substantially increasing ingestion speed in async contexts.
v1.2.5 Mar 27, 2025 · issue -368

Agno v1.2.5 adds E2B sandbox code execution, MCP tool filtering, async @tool() decorator, and team-leader tool support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.5
```
└──▷ USE IT
Limit an MCP server's exposed tools to a safe subset — useful when a server offers many tools but you only want the model to access a few.
python
```
MCPTools(include_tools=['read_file', 'list_dir'])
```
Equip a team leader with its own tools and cap how many tool calls it can make per run.
python
```
Team(members=[...], tools=[my_tool], tool_call_limit=5)
```
Define an async tool with a post-hook to run non-blocking I/O after each tool call.
python
```
@tool(post_hook=async_post_hook)
async def fetch_data(url: str) -> str:
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as resp:
            return await resp.text()
```
- ›Adds tools and tool_call_limit parameters to Team, allowing the team leader itself to be equipped with tools and act as an agent.
- ›Expands MCPTools with include/exclude filtering so you can restrict which tools from an MCP server the model can access.
- ›The @tool() decorator now supports async functions, including async pre- and post-hooks.
- ›Adds E2BTools to run code inside an E2B Sandbox.
v1.2.4 Mar 25, 2025 · issue -368

Agno v1.2.4 makes tool_choice configurable on Teams and adds Teams playground endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.4
```
- ›Adds tool_choice configuration support to Teams, enabling control over tool selection behavior at the team level.
- ›Adds Teams playground endpoints for interacting with multi-agent teams via the playground interface.
v1.2.2 Mar 24, 2025 · issue -368

Agno v1.2.2 adds tool call visibility for Teams.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.2
```
- ›Adds support for showing tool calls in Teams, making agent collaboration steps visible during multi-agent workflows.
v1.2.0 Mar 24, 2025 · issue -368

Agno v1.2.0 adds Financial Datasets and Docker tool integrations, plus reasoning for Teams and simplified MCPTools creation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.2.0
```
- ›Simplifies creation of MCPTools for connecting agents to external MCP servers.
- ›Adds FinancialDatasetsTools for accessing data from financialdatasets.ai.
- ›Adds Docker tools for managing local Docker environments from within an agent.
- ›Enables reasoning support for Teams.
v1.1.16 Mar 21, 2025 · issue -368

Agno v1.1.16 adds async Qdrant VectorDB support and a Claude Think Tool integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.16 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.16
```
- ›Adds async support for Qdrant VectorDB, enabling non-blocking vector database operations for improved performance and efficiency.
- ›Introduces the Claude Think Tool, implementing Anthropic's 'think tool' pattern to give Claude agents an explicit reasoning step before responding.
v1.1.15 Mar 21, 2025 · issue -368

Agno v1.1.15 adds function result caching for 9 tool classes and improves tool-call display in print_response.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.15 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.15
```
- ›Adds result caching to DuckDuckGoTools, ExaTools, FirecrawlTools, GoogleSearchtools, HackernewsTools, NewspaperTools, Newspaper4kTools, Websitetools, and YFinanceTools to speed up iteration, avoid rate limits, and reduce costs during agent testing.
- ›Tool calls are now rendered in a separate panel from the response panel when using print_response and aprint_response, including when combined with response_model.
v1.1.14 Mar 20, 2025 · issue -368

Agno v1.1.14 ships Teams 2.0 with three coordination modes, LiteLLM support, and a new use_json_mode parameter.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.14 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.14
```
└──▷ USE IT
Stand up a routing team that directs queries to specialised member agents and returns structured output.
python
```
from agno.team import Team
from agno.agent import Agent

research_agent = Agent(name='Researcher', ...)
writer_agent = Agent(name='Writer', ...)

team = Team(
    mode='route',
    members=[research_agent, writer_agent],
    response_model=MyOutputModel,
    debug_mode=True,
)
team.print_response('Summarise the latest AI papers')
```
Force JSON-mode output from an agent when the target model does not support native structured output.
python
```
from agno.agent import Agent
from pydantic import BaseModel

class Report(BaseModel):
    title: str
    summary: str

agent = Agent(
    response_model=Report,
    use_json_mode=True,
)
agent.print_response('Generate a threat report')
```
- ›Adds Team class supporting three modes — 'collaborate', 'coordinate', and 'route' — replacing the old Agent(team=[]) pattern with a dedicated first-class teams implementation.
- ›Adds use_json_mode: bool = False parameter to Agent and Team; when combined with response_model=YourModel, forces JSON-mode output instead of the new default of native structured output — making response_model the only setting required for structured output.
- ›Adds debug_mode=True on Agent/Team and team.print_response(...) to surface revamped debug logs for both agents and teams.
- ›Adds LiteLLM support as a native model implementation and via the existing OpenAILike interface.
- ›Enables WebsiteTools to update combined knowledgebases alongside standard knowledgebases.
+2 moreshow less
- ›Adds agentic shared context between team members and sharing of individual team member responses across the team.
- ›Supports passing images, audio, and video to member agents in team workflows, and enables structured output returns from member agents in 'route' mode.
└──▷ BREAKING ON UPGRADE
- !Agent.structured_output is replaced by Agent.use_json_mode; the old parameter is deprecated and will be removed in a future major version.
- !Agent.team is deprecated with the release of the new Team implementation and will be removed in a future major version; migrate to the Team class.
v.1.1.13 Mar 14, 2025 · issue -368

Agno v1.1.13 adds OpenAI File Search, web/document citations, and Cohere Command A support
└──▷ GET THIS VERSION
```
$ git clone --branch v.1.1.13 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v.1.1.13
```
- ›Adds support for OpenAI's built-in File Search tool in OpenAIResponses, automatically uploading File objects attached to agent prompts.
- ›Adds extraction of URL citations from OpenAI's built-in Web Search tool responses via OpenAIResponses.
- ›Adds extraction of document citations from Claude responses when File objects are attached to agent prompts via Anthropic.
- ›Adds support and examples for Cohere's new flagship model Command A.
v1.1.12 Mar 13, 2025 · issue -368

Agno v1.1.12 adds improved citation capture and storage with Gemini and Perplexity integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.12 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.12
```
- ›Improves support for capturing, displaying, and storing citations from models, with integration for Gemini and Perplexity.
v1.1.11 Mar 13, 2025 · issue -368

Agno v1.1.11 adds OpenAI Responses API support with web search, an OpenWeather tool, and Reddit reply actions.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.11 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.11
```
- ›Adds a new model implementation for OpenAI's Responses API, including support for the built-in websearch tool.
- ›Adds an OpenWeather API tool for retrieving real-time weather information.
- ›Adds post reply and comment reply actions to the Reddit tool.
v1.1.10 Mar 12, 2025 · issue -368

Agno v1.1.10 adds File prompts, LMStudio provider, AgentQL/Browserbase tools, a custom API tool, and Cohere vision support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.10 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.10
```
- ›Introduces a new File type that can be added to prompts and passed to model providers (Gemini and Anthropic Claude supported).
- ›Adds LMStudio as a model provider.
- ›Adds an AgentQL toolkit for connecting agents to websites for scraping and interaction.
- ›Adds a Browserbase tool for browser automation.
- ›Adds a custom API tool that can call any arbitrary API endpoint.
+1 moreshow less
- ›Adds image understanding support for Cohere models (vision).
v1.1.9 Mar 6, 2025 · issue -368

Agno v1.1.9 adds IBM WatsonX and DeepInfra model providers plus MCP tool support for agents.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.9 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.9
```
- ›Adds MCPTools class to integrate Model Context Protocol (MCP) servers with Agno agents.
- ›Adds IBM WatsonX as a model provider via a new WatsonX integration.
- ›Adds DeepInfra as a model provider, including reasoning support for OpenAI-compatible DeepSeek models.
- ›Updates knowledgebase, vector DB, and reader interfaces with async support.
v1.1.8 Mar 3, 2025 · issue -368

Agno v1.1.8 adds video file upload support in Playground for Gemini models and a base_url property for AzureOpenAI.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.8
```
- ›Adds base_url property to AzureOpenAI to support non-default Azure endpoint URLs.
- ›Enables video file upload in the Playground UI, allowing compatible Gemini models to interpret uploaded video content.
v1.1.7 Feb 26, 2025 · issue -369

Agno v1.1.7 adds audio file upload to the Playground for transcription and sentiment analysis.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.7
```
- ›Adds audio file upload support to the Playground, enabling models to perform transcription, sentiment analysis, and audio interpretation interactively.
v1.1.6 Feb 25, 2025 · issue -369

Agno v1.1.6 adds support for Claude 3.7 Sonnet and extended thinking in messages.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.6
```
- ›Adds support for the Claude 3.7 Sonnet model, including extended thinking in messages.
v1.1.5 Feb 24, 2025 · issue -369

Agno v1.1.5 adds audio responses, image understanding for XAI/Together.ai, Webex messaging, and Upstash vector DB support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.5
```
└──▷ USE IT
Generate an audio response from an agent and save it as a WAV file for voice-mode use cases.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.utils.audio import write_audio_to_file

agent = Agent(
    model=OpenAIChat(
        id="gpt-4o-audio-preview",
        modalities=["text", "audio"],
        audio={"voice": "alloy", "format": "wav"},
    ),
)
agent.print_response("Tell me a 5 second story")
if agent.run_response.response_audio is not None:
    write_audio_to_file(
        audio=agent.run_response.response_audio.base64_audio,
        filename="response.wav"
    )
```
- ›Adds audio response support (streaming and non-streaming) via agent.run_response.response_audio, using OpenAIChat with id='gpt-4o-audio-preview' and the modalities and audio parameters; audio data is available as response_audio.base64_audio and can be written to file with write_audio_to_file().
- ›Adds image understanding support for XAI and Together.ai model providers, enabling multimodal agents on those backends.
- ›Adds a Webex integration tool for sending messages via Webex.
- ›Adds Upstash as a supported vector database backend.
- ›Adds Grounding and Search support for Gemini models to improve response accuracy and recency.
v1.1.4 Feb 17, 2025 · issue -369

Agno v1.1.4 adds get_emails_by_thread and send_email_reply methods to GmailTools
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.4 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.4
```
└──▷ USE IT
Reply to an existing Gmail thread from an agent tool, preserving conversation context.
python
```
from agno.tools.gmail import GmailTools

tools = GmailTools()
thread = tools.get_emails_by_thread(thread_id="<thread_id>")
tools.send_email_reply(thread_id="<thread_id>", message="Thanks, I'll follow up shortly.")
```
- ›Adds get_emails_by_thread and send_email_reply methods to GmailTools, enabling agents to read full email threads and reply inline.
- ›Adds metadata support to OpenAIChat.
v1.1.2 Feb 15, 2025 · issue -369

Agno v1.1.2 adds o3 model reasoning support and migrates GeminiEmbedder to Google's new genai SDK
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.2
```
└──▷ USE IT
Generate embeddings with the updated GeminiEmbedder after migrating to the new genai SDK interface.
python
```
embeddings = GeminiEmbedder("text-embedding-004").get_embedding(
    "The quick brown fox jumps over the lazy dog."
)
```
- ›Updates GeminiEmbedder to use Google's new genai SDK, dropping the models/ prefix from model IDs (e.g. 'text-embedding-004' instead of 'models/text-embedding-004').
- ›Adds reasoning support for OpenAI's o3 models.
└──▷ BREAKING ON UPGRADE
- !GeminiEmbedder now requires model IDs without the models/ prefix — callers passing 'models/text-embedding-004' must change to 'text-embedding-004'.
v1.1.1 Feb 14, 2025 · issue -369

Agno v1.1.1 adds file/image uploads to Agent UI, MP3 support in ModelsLabTools, and custom Firecrawl API URLs.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.1
```
- ›Adds MP3 to the FileType enum in ModelsLabTools, with API routing via MODELS_LAB_URLS and MODELS_LAB_FETCH_URLS dicts keyed by MP3, MP4, and GIF — enabling audio generation calls alongside existing video/GIF generation.
- ›Adds support for a custom API URL parameter in the Firecrawl integration, letting users point the tool at self-hosted or alternate Firecrawl endpoints.
- ›Agent UI now supports file and image uploads alongside prompts, accepting .pdf, .csv, .txt, .docx, .json (files) and .png, .jpeg, .jpg, .webp (images).
└──▷ BREAKING ON UPGRADE
- !The ModelsLabTools constructor in /libs/agno/tools/models_labs.py has changed: the url and fetch_url parameters have been removed. API URLs are now determined automatically from the file_type value. Any code passing url or fetch_url to ModelsLabTools will break on upgrade.
v1.1.0 Feb 12, 2025 · issue -369

Agno v1.1.0 overhauls model support with Azure AI Foundry, full AWS Bedrock coverage, Google SDK Gemini, and exponential-backoff retries.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.1.0
```
└──▷ USE IT
Automatically retry agent calls with exponential backoff when hitting rate limits from a model provider.
python
```
from agno.agent import Agent
from agno.models.openai import OpenAIChat

agent = Agent(
    model=OpenAIChat(id='gpt-4o'),
    exponential_backoff=True,
)
agent.print_response('Summarize the latest AI research trends.')
```
- ›Enables optional exponential backoff retries on model failures (e.g. rate-limit errors) when exponential_backoff is set to True on an agent.
- ›Expands AWS Bedrock support to all Bedrock models through a rewritten AwsBedrock implementation (note: AwsBedrock does not support async-await).
- ›Switches the Gemini implementation to Google's genai SDK (v1.0.0), enabling better feature parity and easier future Gemini integrations.
- ›Adds Exa Answers capability support via ExaTools.
- ›Renames GoogleSearch to GoogleSearchTools for consistency across the toolset.
+2 moreshow less
- ›Extends async-await support to all models (excluding AwsBedrock) as part of the models refactor.
- ›Improves metrics and visibility for all models in the Agent UI as part of the models overhaul.
└──▷ BREAKING ON UPGRADE
- !The Gemini implementation via the Vertex API is replaced by the Google SDK implementation — existing code using the Vertex-based Gemini class will need to migrate.
- !The Gemini implementation via the OpenAI client is replaced by the Google SDK implementation — existing code using the OpenAI-client-based Gemini class will need to migrate.
- !OllamaHermes has been removed; users must migrate to the Ollama implementation.
- !GoogleSearch is renamed to GoogleSearchTools — any code importing or referencing GoogleSearch by name will break.
v1.0.8 Feb 7, 2025 · issue -369

Agno v1.0.8 adds Perplexity model support, a Todoist toolkit, JSON knowledge-base reader, Weaviate vector DB, Google Sheets tool, and custom retriever support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.8 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.8
```
└──▷ USE IT
Use Perplexity as the model provider for an agent to leverage its online search-backed responses.
python
```
from agno.models.perplexity import Perplexity
from agno.agent import Agent

agent = Agent(model=Perplexity())
agent.print_response('What are the latest developments in AI safety?')
```
Equip an agent with the Todoist toolkit to create and manage tasks programmatically.
python
```
from agno.tools.todoist import TodoistTools
from agno.agent import Agent

agent = Agent(tools=[TodoistTools()])
agent.print_response('Add a task to review the quarterly report by Friday.')
```
- ›Adds Perplexity as a model provider, enabling agents to use Perplexity AI models.
- ›Adds a Todoist toolkit for managing tasks from within agents.
- ›Adds a JSON file reader for loading JSON files into knowledge bases.
- ›Adds name_exists function to the LanceDB vector store integration.
- ›Adds async support for Mistral model provider.
+1 moreshow less
- ›Adds async support for Cohere model provider.
v1.0.7 Feb 5, 2025 · issue -369

Agno v1.0.7 adds Google Sheets toolkit, Weaviate vector store, and async support for Mistral and Cohere
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.7 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.7
```
- ›Mistral now supports async execution via agent.arun() and agent.aprint_response().
- ›Cohere now supports async execution via agent.arun() and agent.aprint_response().
- ›Adds a new Google Sheets toolkit for reading, creating, and updating Google Sheets.
- ›Adds Weaviate as a supported vector store backend.
v1.0.6 Feb 4, 2025 · issue -369

Agno v1.0.6 adds a Google Maps toolkit and a URL reader/knowledge base for document ingestion.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.6 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.6
```
- ›New Google Maps toolkit covering business discovery, directions, navigation, geocoding, and nearby-places lookup.
- ›New URL reader and knowledge base that fetches any URL and stores its text contents in the document store.
v1.0.5 Feb 3, 2025 · issue -369

Agno v1.0.5 adds Gmail tools, Mistral vision support, Claude async, and Exa find_similar
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.5 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.5
```
└──▷ USE IT
Search for similar content using the new find_similar capability in ExaTools.
python
```
from agno.tools.exa import ExaTools

exa = ExaTools()
results = exa.find_similar('https://example.com/threat-report')
```
- ›Adds find_similar method to ExaTools for similarity-based search.
- ›Adds a Gmail toolkit with tools for mail search, sending mail, and related operations.
- ›Enables async usage of Claude models via await agent.aprint_response() and await agent.arun(), including async tool calls.
- ›Adds Mistral vision model support.
v1.0.2 Jan 31, 2025 · issue -370

Agno v1.0.2 caches model clients for faster agent startup and renames TwitterTools to XTools with Twitter API v2 support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.2 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.2
```
- ›Renames TwitterTools to XTools and updates capabilities to be compatible with Twitter API v2.
- ›Caches model client instantiation across all models, improving Agno agent startup time.
└──▷ BREAKING ON UPGRADE
- !TwitterTools has been renamed to XTools; any code importing or referencing TwitterTools will break on upgrade.
v1.0.1 Jan 30, 2025 · issue -370

Agno v1.0.1 enables response caching for Mistral models.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.1 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.1
```
- ›Enables caching support for Mistral models.
v1.0.0 Jan 30, 2025 · issue -370

Agno v1.0.0 introduces an Evals framework and a fully restructured multi-modal API with typed Image, Audio, Video, and Artifact classes.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.0 https://github.com/agno-agi/agno.git
# already have the repo? check out this version:
$ git checkout v1.0.0
```
└──▷ USE IT
Build a PDF knowledge base using the renamed embedder id parameter and updated import paths.
python
```
from agno.knowledge.pdf_url import PDFUrlKnowledgeBase
from agno.vectordb.pgvector import PgVector
from agno.embedder.ollama import OllamaEmbedder

knowledge_base = PDFUrlKnowledgeBase(
    urls=['https://phi-public.s3.amazonaws.com/recipes/ThaiRecipes.pdf'],
    vector_db=PgVector(
        table_name='recipes',
        db_url='postgresql+psycopg://ai:ai@localhost:5532/ai',
        embedder=OllamaEmbedder(id='llama3.2', dimensions=3072),
    ),
)
knowledge_base.load(recreate=True)
```
- ›Adds an Evals system to measure performance, accuracy, and reliability of agents.
- ›Typed multi-modal input classes — Image, Audio, Video — now accepted by agent.run() and agent.print_response(), with fields for url, filepath, content, detail, format, and id.
- ›Typed output artifact classes — ImageArtifact, AudioArtifact, VideoArtifact, AudioOutput — now returned on RunResponse.images, RunResponse.audio, RunResponse.videos, and RunResponse.response_audio.
- ›Embedders now accept id instead of model as the identifier parameter (e.g. OllamaEmbedder(id='llama3.2', dimensions=3072)).
- ›All toolkit classes are now suffixed with Tools (e.g. DuckDuckGoTools).
+6 moreshow less
- ›Model namespace moved from phi.model.x to agno.models.x; knowledge base namespace moved from phi.knowledge_base.x to agno.knowledge.x.
- ›Document readers renamed with _reader suffix under agno.document.reader.* (e.g. agno.document.reader.pdf_reader).
- ›Storage classes renamed for clarity: PgAgentStorage → PostgresAgentStorage, SqlAgentStorage → SqliteAgentStorage, MongoAgentStorage → MongoDbAgentStorage, S2AgentStorage → SingleStoreAgentStorage.
- ›Workflow storage classes renamed: SqlWorkflowStorage → SqliteWorkflowStorage, PgWorkflowStorage → PostgresWorkflowStorage, MongoWorkflowStorage → MongoDbWorkflowStorage.
- ›Model classes renamed: AzureOpenAIChat → AzureOpenAI, CohereChat → Cohere, DeepSeekChat → DeepSeek, GeminiOpenAIChat → GeminiOpenAI, HuggingFaceChat → HuggingFace, Hermes → OllamaHermes.
- ›Performance improvement: several internal Pydantic models converted to dataclasses to reduce overhead.
└──▷ BREAKING ON UPGRADE
- !All imports under phi.* are replaced by agno.* — code importing from phi.model.x, phi.knowledge_base.x, phi.document.reader.*, etc. will break.
- !All toolkit class names must now be suffixed with Tools (e.g. DuckDuckGo is now DuckDuckGoTools).
- !agent.run(images=[...]) and agent.print_response(images=[...]) now require Image objects instead of bare values; same for Audio and Video.
- !RunResponse.images is now a list of ImageArtifact; RunResponse.audio is a list of AudioArtifact; RunResponse.videos is a list of VideoArtifact; RunResponse.response_audio is now of type AudioOutput — any code accessing these fields by prior type assumptions will break.
- !Embedders no longer accept the model parameter — it must be replaced with id.
- !PgAgentStorage, SqlAgentStorage, MongoAgentStorage, S2AgentStorage are renamed to PostgresAgentStorage, SqliteAgentStorage, MongoDbAgentStorage, SingleStoreAgentStorage respectively.
- !SqlWorkflowStorage, PgWorkflowStorage, MongoWorkflowStorage are renamed to SqliteWorkflowStorage, PostgresWorkflowStorage, MongoDbWorkflowStorage respectively.
- !Model classes AzureOpenAIChat, CohereChat, DeepSeekChat, GeminiOpenAIChat, HuggingFaceChat, Hermes are renamed to AzureOpenAI, Cohere, DeepSeek, GeminiOpenAI, HuggingFace, OllamaHermes respectively.
- !Assistant, llm, PhiTools, PythonAgent, and DuckDbAgent have been removed with no direct replacement.
- !The similarity_threshold parameter on semantic chunking is replaced by threshold.
- !Knowledge base phi.knowledge.pdf.PDFUrlKnowledgeBase is now at agno.knowledge.pdf_url.PDFUrlKnowledgeBase; phi.knowledge.csv.CSVUrlKnowledgeBase is now at agno.knowledge.csv_url.CSVUrlKnowledgeBase.

Agno

Summary

What Agno answers

Examples

Command line

Release history