agno-agi/agno

Agno is an open-source Python framework for building, orchestrating, and evaluating autonomous AI agents. It provides a comprehensive toolkit for creating agents with persistent memory, retrieval-augmented generation (RAG) capabilities, and multi-modal processing, while supporting complex workflows through teams and sequential steps. The system includes robust infrastructure for production deployment, featuring extensive database backends, observability integrations, and evaluation suites for reliability and performance testing.

191 changes.

The project rebranded from Phidata to Agno and executed a major architectural overhaul, releasing version 3.0 with a modular library structure and comprehensive new features. This period focused on expanding the framework's capabilities by adding extensive model provider support, vector database integrations, and a robust AgentOS platform with diverse storage backends. Significant effort was also directed toward building a complete observability ecosystem and rigorous test coverage to ensure stability across the new architecture.

124 changes.

This period focused on building out the AgentOS runtime with comprehensive management capabilities, including a centralized registry, component persistence, scheduling, and human-in-the-loop approval workflows. It introduced core agent intelligence features such as the Skills system, Learning Machine for memory, and Context Providers, while establishing a robust evaluation framework for accuracy, performance, and reliability. The work was heavily supported by extensive documentation, new model integrations, and broad test coverage across the new subsystems.

Users can now connect to the AIMLAPI platform by instantiating the new AIMLAPI model class, which defaults to the gpt-5.6-luna model and reads the API key from the AIMLAPI\_API\_KEY environment variable. The integration automatically attaches partner attribution headers (X-AIMLAPI-Partner-ID, X-AIMLAPI-Source) to all requests for analytics purposes, while ensuring that any user-defined headers take precedence over these defaults.

libs/agno/agno/models/aimlapi · high confidence

Users can now interact with Cerebras AI models through the Agno framework. This change introduces two new model classes: \Cerebras\, which uses the native Cerebras Cloud SDK for direct API access, and \CerebrasOpenAI\, which provides compatibility via the OpenAI-compatible endpoint. The integration supports structured outputs with JSON schema validation, tool calling (including parallel tool calls with specific handling for certain models like \llama-4-scout-17b-16e-instruct\), and streaming responses. Authentication is handled via the \CEREBRAS\_API\_KEY\ environment variable.

libs/agno/agno/models/cerebras, libs/agno/agno/models/lmstudio · high confidence

Users can now access AI models (such as GPT, Claude, Gemini, and DeepSeek) through the CometAPI service by using the new CometAPI model class. This integration allows configuration via the COMETAPI\_KEY environment variable and defaults to the gpt-5-mini model at the https://api.cometapi.com/v1 endpoint, supporting standard OpenAI-compatible chat interactions and model listing.

libs/agno/agno/models/cometapi · high confidence

Introduces the DeepSeek model integration, including the \DeepSeek\ class and module exports. This update enables users to interact with DeepSeek models (defaulting to \deepseek-v4-flash\) with built-in support for the API's 'thinking mode', which is enabled by default for capable models and can be toggled via the \use\_thinking\ parameter. The implementation also addresses authentication by raising a clear \ModelAuthenticationError\ if the \DEEPSEEK\_API\_KEY\ environment variable is missing, and ensures correct request formatting for tools and media inputs.

libs/agno/agno/models/deepseek · high confidence

Introduces a new \DynamoDb\ class that enables storing agent sessions, runs, user memory, metrics, evaluations, knowledge, and traces in Amazon DynamoDB. The implementation includes table schema definitions, serialization utilities that correctly handle boolean values (preventing invalid \True\ string storage), and batch write operations with exponential-backoff retries to ensure data integrity against throttling.

libs/agno/agno/db/dynamo · high confidence

The cookbook/gemini\_3 directory now provides a comprehensive progressive guide for building agents with Gemini 3.7-flash and Gemini 3.1-pro-preview. It includes examples for basic chat, tool use, web search, and multimodal inputs (audio, video, PDF, CSV). It also covers advanced capabilities like server-side file search with citations, prompt caching for cost savings, local knowledge bases with ChromaDB, agentic memory and learning, multi-agent teams, and step-based workflows with parallelism and quality gates. Finally, it includes a deployment script to expose all agents, teams, and workflows as a single web service via AgentOS.

_cookbook/gemini\3 · high confidence

Users can now interact with HuggingFace Hub Inference models via the new \HuggingFace\ model class. This addition supports standard request parameters (such as temperature, max\_tokens, and stop sequences), API key configuration via the \HF\_TOKEN\ environment variable, and both synchronous and asynchronous client usage for streaming and non-streaming completions.

libs/agno/agno/models/deepinfra, libs/agno/agno/models/huggingface · high confidence

Users can now interact with IBM WatsonX models (such as the default Granite model) through the Agno framework. This change introduces the WatsonX model class, which handles authentication via environment variables (IBM\_WATSONX\_API\_KEY, IBM\_WATSONX\_PROJECT\_ID), supports standard generation parameters (temperature, max\_tokens, etc.), and enables tool calling capabilities. It also includes basic handling for image inputs and warnings for currently unsupported audio, file, and video inputs.

libs/agno/agno/models/ibm · high confidence

Users can now use LangChain vector stores as a backend for knowledge retrieval by instantiating the new LangChainVectorDb class. This integration allows passing an existing LangChain vectorstore or retriever to the SDK, enabling document search via the standard search interface. Note that write operations (insert, upsert, delete) and advanced filtering features are not supported; users must manage document lifecycle directly within their LangChain vectorstore.

libs/agno/agno/vectordb/langchaindb · high confidence

Introduces a new \LightRag\ vector database implementation for the Agno SDK, enabling users to connect to a LightRAG server (defaulting to \http://localhost:9621\) for document storage and retrieval. This integration supports API key authentication via a configurable header and provides standard vector database operations such as inserting, upserting, and searching documents. The implementation explicitly notes that per-user isolation and advanced filtering are not supported by the underlying LightRAG server, issuing warnings when these parameters are provided.

libs/agno/agno/vectordb/lightrag, libs/agno/agno/vectordb/llamaindex, libs/agno/agno/vectordb/singlestore · high confidence

Introduces two new model classes, \Llama\ and \LlamaOpenAI\, in the \agno.models.meta\ package to enable interaction with the Llama API. The \Llama\ class provides a native integration using the \llama-api-client\ SDK, while \LlamaOpenAI\ offers an OpenAI-compatible interface for users preferring that pattern. Both classes support configuration of API keys (via \LLAMA\_API\_KEY\ environment variable), request parameters (such as temperature and top\_p), and JSON schema outputs, with appropriate fallbacks and error handling when optional dependencies are missing.

libs/agno/agno/models/meta · high confidence

Users can now interact with LLMs via two new model providers: LlamaCpp and Nexus. The LlamaCpp provider connects to a local inference server (defaulting to http://127.0.0.1:8080/v1) and uses the ggml-org/gpt-oss-20b-GGUF model ID by default. The Nexus provider connects to a local API endpoint (defaulting to http://localhost:8000/llm/v1/) and uses the openai/gpt-4 model ID by default. Both are implemented as OpenAI-compatible interfaces.

libs/agno/agno/models/nexus · high confidence

Users can now interact with MiniMax models (defaulting to MiniMax-M3) via a new provider integration. This implementation leverages MiniMax's OpenAI-compatible API, automatically retrieving the API key from the MINIMAX\_API\_KEY environment variable, and includes specific logic to strip inline thinking tags from streamed responses to prevent them from leaking into the main response panel.

libs/agno/agno/models/groq, libs/agno/agno/models/langdb, libs/agno/agno/models/minimax · high confidence

Users can now interact with Moonshot (Kimi) models, such as kimi-k3 and kimi-k2.x, via the new MoonShot provider. This integration supports structured output (JSON schema and JSON mode) and handles media by uploading files and videos to Moonshot's API for extraction or playback. It also exposes reasoning controls: use\_thinking toggles the thinking mode for K2.x models, while reasoning\_effort adjusts the depth of thought for K3 models.

libs/agno/agno/models/moonshot · high confidence

Users can now store sessions, memories, traces, and metrics in a MySQL database using either the synchronous \MySQLDb\ or the new asynchronous \AsyncMySQLDb\ class. Both implementations support configurable table names, schema management, and automatic schema creation, with the async variant requiring the \asyncmy\ driver and SQLAlchemy's async engine.

libs/agno/agno/db/mysql · high confidence

This change introduces the Ollama model integration to the Agno library, providing two distinct interfaces for users. The primary \Ollama\ class enables standard chat interactions with local or remote Ollama instances, supporting features like tool calls, structured outputs, and configurable request parameters. Additionally, a new \OllamaResponses\ class is added, which allows users to interact with Ollama models using the OpenAI Responses API format (available in Ollama v0.13.3+), facilitating stateless API calls and compatibility with tools expecting the OpenAI Responses schema.

libs/agno/agno/models/ollama · high confidence

Users can now use OpenSearch as a vector database backend for storing and retrieving embeddings. This new integration supports synchronous and asynchronous operations, multiple KNN engines (Lucene, FAISS, nmslib), and various distance metrics (cosine, L2, inner product). It includes features like bulk document operations, advanced filtering, and optional reranking, with specific compatibility notes for different OpenSearch versions (e.g., nmslib deprecation in 3.0+, FAISS cosine support in 2.19+).

libs/agno/agno/vectordb/couchbase, libs/agno/agno/vectordb/elasticsearch, libs/agno/agno/vectordb/opensearch · high confidence

Users can now route model requests through the Portkey AI Gateway by using the new Portkey model class. This integration requires the portkey-ai library and handles authentication via the PORTKEY\_API\_KEY environment variable, supporting virtual keys and custom configuration for routing and retries.

libs/agno/agno/models/portkey · high confidence

Users can now use Redis as a vector database backend for knowledge storage and retrieval. This change introduces the \RedisDb\ class (also available as \RedisVectorDb\ and the deprecated \RedisDB\ alias) which integrates with the \redisvl\ library to provide vector search capabilities. The implementation supports both synchronous and asynchronous operations, allows configuration of search types and distance metrics, and includes logic for handling user-based data isolation via owner tags.

libs/agno/agno/vectordb/redis · high confidence

Users can now interact with the Siliconflow API by instantiating the new Siliconflow model class. This provider defaults to the Qwen/QwQ-32B model and requires authentication via the SILICONFLOW\_API\_KEY environment variable, connecting to the https://api.siliconflow.cn/v1 endpoint.

libs/agno/agno/models/siliconflow · high confidence

Users can now use SurrealDB as a vector database backend for storing and searching document embeddings. This change introduces the \SurrealDb\ class, which supports both synchronous and asynchronous connections (via HTTP or WebSocket) and utilizes HNSW indexes for efficient similarity search. The implementation handles schema definition, embedding generation (defaulting to OpenAI if not specified), and standard vector operations like upsert, delete, and search with configurable distance metrics.

libs/agno/agno/vectordb/surrealdb · high confidence

Users can now persist sessions, runs, memories, metrics, evaluations, knowledge, and traces using SurrealDB. This new backend supports both HTTP and WebSocket connections, handles automatic table creation, and manages serialization of dates and record IDs to ensure compatibility with the existing SDK interfaces.

libs/agno/agno/db/singlestore, libs/agno/agno/db/surrealdb · high confidence

Users can now interact with the Tuning Engines AI control plane using an OpenAI-compatible interface. This new provider allows routing model requests through Tuning Engines for governed access, policy controls, and usage reporting, requiring the TUNING\_ENGINES\_API\_KEY environment variable for authentication.

_libs/agno/agno/models/tuning\engines · high confidence

Users can now store and retrieve vector embeddings using Upstash Vector. This change introduces the \UpstashVectorDb\ class, allowing configuration of connection details (URL, token), custom or hosted embedding models, and namespace isolation. It supports metadata filtering via user IDs and includes retry logic for network resilience.

libs/agno/agno/vectordb/upstashdb · high confidence

Users can now store sessions, memories, metrics, evaluations, knowledge, learnings, and traces in a Valkey database. This change introduces the \ValkeyDb\ class and its supporting schemas and utilities, enabling Valkey to be used as both a storage and vector database backend via the \valkey-glide-sync\ client.

libs/agno/agno/db/valkey · high confidence

Users can now use Valkey as a vector database for storing and searching embeddings. This change introduces the \ValkeyDb\ class in the \agno.vectordb.valkey\ module, which leverages the \valkey-glide-sync\ client and Valkey's search capabilities (FT.\* commands) to support vector indexing (HNSW/FLAT), distance metrics, and metadata filtering. The implementation includes support for user isolation via owner tags and provides backward-compatible aliases (\ValkeyVectorDb\, \ValkeyDB\) for the new \ValkeyDb\ class.

libs/agno/agno/vectordb/valkey · high confidence

Introduces a new \Claude\ model class within the \vertexai\ module that enables running Anthropic Claude models via Google Cloud Vertex AI. This implementation configures the \AnthropicVertex\ SDK client using project, region, and base URL settings, and handles request parameter routing for features like thinking, output configuration, and sampling parameters.

libs/agno/agno/models/vertexai · high confidence

Added the \02\_agents/07\_knowledge\ cookbook directory containing Python examples for retrieval-augmented generation (RAG) and knowledge filtering, including agentic RAG with PgVector and LanceDB, custom retrievers, knowledge filters, and reference formatting. Included a README with prerequisites and a test log documenting the results of running these examples, noting missing dependencies for some scripts.

_cookbook/02\_agents/07\knowledge · high confidence

Users can now interact with models hosted on Fireworks and Together AI through new provider integrations. The Fireworks provider defaults to the 'accounts/fireworks/models/gpt-oss-120b' model and requires the FIREWORKS\_API\_KEY environment variable, while the Together provider defaults to 'MiniMaxAI/MiniMax-M2.7' and requires the TOGETHER\_API\_KEY environment variable. Both providers inherit from the OpenAI-like interface, allowing users to configure API keys and base URLs via environment variables or direct instantiation.

libs/agno/agno/models/together · high confidence

Users can now interact with N1N AI models by instantiating the new N1N class, which extends the existing OpenAI-compatible interface. The provider automatically reads the API key from the N1N\_API\_KEY environment variable and connects to the https://api.n1n.ai/v1 endpoint, allowing seamless integration with N1N's model offerings using the same patterns as other OpenAI-like providers.

libs/agno/agno/models/n1n · high confidence

Users can now interact with Nebius Token Factory models via a new Nebius provider class. This implementation extends the existing OpenAI-like client, automatically reading the NEBIUS\_API\_KEY from the environment and pointing to the Token Factory API endpoint (https://api.tokenfactory.nebius.com/v1/). It enforces authentication by raising a clear error if the API key is missing.

libs/agno/agno/models/nebius · high confidence

Users can now interact with Nvidia and Sambanova AI models through the library. This change introduces new model classes (Nvidia and Sambanova) that inherit from the existing OpenAILike base, allowing integration with their respective APIs using environment variables (NVIDIA\_API\_KEY and SAMBANOVA\_API\_KEY) for authentication. The Nvidia provider defaults to the 'meta/llama-3.3-70b-instruct' model, while Sambanova defaults to 'Meta-Llama-3.1-8B-Instruct'.

libs/agno/agno/models/nvidia · high confidence

Users can now integrate with Perplexity AI models (defaulting to 'sonar') via a new \Perplexity\ model class. This implementation handles authentication via the \PERPLEXITY\_API\_KEY\ environment variable, supports streaming responses, and correctly parses provider-specific features such as URL citations and token usage metrics.

libs/agno/agno/models/perplexity · high confidence

Users can now interact with the Vercel v0 API by instantiating the new V0 model class. This integration leverages the existing OpenAI-compatible client structure, requiring the V0\_API\_KEY environment variable for authentication and defaulting to the https://api.v0.dev/v1/ endpoint.

libs/agno/agno/models/vercel · high confidence

Users can now interact with vLLM inference servers using the new VLLM model class, which extends the existing OpenAI-like interface. This integration automatically retrieves the API key from the VLLM\_API\_KEY environment variable and defaults the server URL to http://localhost:8000/v1/, raising a clear authentication error if the key is missing. It also supports vLLM-specific parameters such as top\_k sampling and the enable\_thinking flag, which are passed through the request's extra\_body.

libs/agno/agno/models/dashscope, libs/agno/agno/models/vllm · high confidence

New shell and batch scripts have been added to the \libs/agno/scripts\ directory to streamline local development and release workflows. These include \format.sh\/\format.bat\ for code formatting with ruff, \validate.sh\/\validate.bat\ for linting and type checking with ruff and mypy, \test.sh\/\test.bat\ for running unit tests with coverage, and \generate\_requirements.sh\ for managing dependencies via uv. Additionally, \release\_manual.sh\ provides a guided workflow for building and publishing the package to PyPI, including pre-release detection and upload steps.

libs/agno/scripts · high confidence

The \testing\_resources\ directory now includes a set of sample files (Markdown, HTML, XML, LaTeX, and plain text) to serve as test data for the 07\_knowledge cookbook examples, enabling users to verify document processing workflows with diverse content types.

_cookbook/07\_knowledge/testing\resources · high confidence

The advanced knowledge cookbook now includes a suite of new examples demonstrating how to extend the knowledge system beyond standard vector search. Users can bypass the Knowledge class with a custom retriever function (01\_custom\_retriever.py), implement domain-specific chunking strategies like paragraph splitting (02\_custom\_chunking.py), integrate LightRAG for graph-based multi-hop reasoning (03\_graph\_rag.py), and use KnowledgeTools to enable think/search/analyze workflows (04\_knowledge\_tools.py). The cookbook also introduces a KnowledgeProtocol for building custom knowledge sources from non-standard backends (05\_knowledge\_protocol.py) and demonstrates pgvector prefix\_match for typeahead search (06\_prefix\_search.py). Finally, it provides a comprehensive set of per-user isolation examples across 17 vector databases (Cassandra, Chroma, ClickHouse, Couchbase, Elasticsearch, etc.), showing how to scope retrieval to individual users while maintaining shared content visibility.

_cookbook/07\_knowledge/04\advanced · high confidence

The Agno library has been released as version 3.0, introducing a comprehensive set of new capabilities and structural changes. This release adds advanced filtering DSL for knowledge base searches, pre/post hooks for agents and guardrails, and built-in follow-up suggestions for agents and teams. It also introduces fallback model support, remote agent setup, and a Notion database backend for the wiki context provider. On the security and stability front, the library now includes a robust secret redaction mechanism to prevent credential leakage in logs and API responses, centralizes path safety for filesystem tools, and unifies model authentication errors. Additionally, it replaces heavyweight run output collectors with a new RunMetrics system, adds debug mode toggles, and provides Streamlit integration components for username and API key management.

libs/agno/agno · high confidence

This location now contains a comprehensive set of reference examples for knowledge management, organized into a structured archive. It covers diverse chunking strategies—including agentic, code, CSV, markdown, fixed-size, recursive, and semantic chunking (with custom prompts and tokenizers)—as well as cloud content sources for Azure Blob, GCS, S3, GitHub, and SharePoint. Additionally, it provides examples for custom knowledge retrievers (sync, async, and with runtime dependencies) and demonstrates the KnowledgeProtocol.

_cookbook/07\_knowledge/09\archive · high confidence

Users can now utilize an asynchronous PostgreSQL database implementation via the new \agno.db.async\_postgres\ module, which exposes the \AsyncPostgresDb\ class for non-blocking database operations.

_libs/agno/agno/db/async\postgres · high confidence

Added a new cookbook entry in \cookbook/91\_tools/mcp/dynamic\_headers\ that demonstrates how an AgentOS application can forward runtime identity information (user, session, run, tenant, and agent details) as HTTP headers to an MCP server. The example includes a FastMCP server that logs received headers and an AgentOS client that uses a custom \header\_provider\ within \MCPTools\ to inject these dynamic values during tool execution.

_cookbook/91\_tools/mcp/dynamic\headers · high confidence

Added cookbook examples in the \16\_skills\ directory demonstrating how to define and use agent skills, including basic skill usage and attaching skills to a Team leader. The examples cover code-review and git-workflow skills with helper scripts for style checking and commit message validation.

_cookbook/02\_agents/16\skills · high confidence

Added cookbook examples demonstrating the new result offloading feature, which allows agents to store large tool outputs in a database and reference them via an envelope to keep context windows small, and a new finance toolkit that provides swappable data providers for market data queries.

(repo-wide) · high confidence

The cookbook/90\_models directory has been reorganized, introducing a new README that documents supported LLM providers (including OpenAI, Anthropic, Google, AWS Bedrock, Azure, Groq, DeepSeek, Mistral, Cohere, Ollama, LM Studio, llama.cpp, llmman, Tuning Engines) and common usage patterns. New example files have been added for the AIMLAPI provider (basic, image agent, structured output, tool use, retry) and the Anthropic provider has been expanded with examples for adaptive thinking, advisor tools, trailing user messages, context management, MCP connectors, and various file input types (CSV, PDF, images). Test logs and validation prompts have been added to track cookbook quality, and a .gitignore file has been created to exclude media files.

_cookbook/90\models · high confidence

The cookbook/12\_context directory has been significantly expanded to demonstrate a wider range of context providers and integration patterns. New examples include a WorkspaceContextProvider for repository-aware file access, a WikiContextProvider with pluggable backends (filesystem, git, and Notion database), and web search integration via Exa and Parallel (including MCP endpoints). The Slack provider now supports media tools and message search, while Google Drive access is demonstrated with Shared Drive support. The cookbook also illustrates advanced patterns such as composing multiple providers on a single agent, chaining providers for engineering briefings, and creating custom context providers.

_cookbook/12\context · high confidence

Adds the Cohere model provider to the Agno library, enabling users to interact with Cohere's chat API (defaulting to the command-a-03-2025 model). The implementation uses the Cohere Python SDK v2 (ClientV2/AsyncClientV2) and supports synchronous and asynchronous chat, tool calling with strict mode, and standard generation parameters like temperature and top\_p. It also handles API key configuration via the CO\_API\_KEY environment variable and includes logic to format tool definitions for Cohere's requirements.

libs/agno/agno/models/cohere · high confidence

The \libs/agno\_infra\ package is introduced as a new lightweight framework and CLI for managing agentic infrastructure. It provides a unified interface for deploying and managing resources across AWS (including EC2, ECS, RDS, S3, and IAM) and Docker environments, supporting application types such as FastAPI, Streamlit, Celery, and Django. The release includes the core library code, a command-line interface (\ag\/\agno\), and an Apache 2.0 license.

_libs/agno\infra · high confidence

This change introduces the foundational structure for remote agent capabilities by adding the \agno/remote\ package. It defines a \BaseRemote\ class and a \RemoteDb\ dataclass that act as a client-side abstraction for interacting with a remote AgentOS backend. The \RemoteDb\ class handles database table mapping for sessions, knowledge, memory, and other entities, and exposes asynchronous methods for managing sessions (create, get, update, delete) and memories, effectively enabling local agents to persist state and interact with remote resources.

libs/agno/agno/remote · high confidence

Users can now use ClickHouse as a vector database backend for storing and searching embeddings. This change introduces the \Clickhouse\ client class, which supports synchronous and asynchronous operations, HNSW indexing with configurable quantization (e.g., bf16), and distance metrics like cosine similarity. The implementation includes table creation, embedding storage, and search capabilities, integrating with the existing knowledge base and embedder infrastructure.

libs/agno/agno/vectordb/clickhouse · high confidence

A new A2A (Agent-to-Agent) interface has been added to AgentOS, allowing Agno Agents, Teams, and Workflows to be exposed via standard A2A-compatible REST endpoints. This includes a FastAPI router that handles agent card discovery, message sending, and streaming, along with utility functions to map A2A request formats to internal run inputs and responses. The interface also defines specific scope mappings for read and run permissions on agents, teams, and workflows, enabling secure integration with A2A clients.

libs/agno/agno/os/interfaces/a2a · high confidence

Users can now interact with AWS Bedrock and Anthropic Claude models via the new \agno.models.aws\ package. The \AwsBedrock\ class provides a generic interface to various Bedrock models, supporting synchronous and asynchronous calls, custom boto3 sessions, and SSO authentication. The \Claude\ class offers a specialized wrapper for Anthropic's Claude models on Bedrock, handling credential management (including session token rotation) and configuring request parameters. Both providers are exposed through the \agno.models.aws\ module for easy import.

libs/agno/agno/models/aws · high confidence

Adds the \Claude\ model class and \SystemPromptBlock\ utility to the Agno library, enabling direct interaction with Anthropic's Claude models. This integration supports native structured outputs, multi-block prompt caching with per-block TTL control, and interleaved extended thinking capabilities. It also includes handling for Anthropic beta features, MCP server configurations, and specific model variants like Sonnet 4.5.

libs/agno/agno/models/anthropic · high confidence

Adds a new Cassandra-based vector database implementation to the Agno SDK, enabling users to store and retrieve vector embeddings in a Cassandra cluster. The integration supports both synchronous and asynchronous operations, automatically derives vector dimensions from the configured embedder, and implements user-scoped data isolation via a v2-to-v3 migration path for existing tables.

libs/agno/agno/vectordb/cassandra · high confidence

Adds a new ChromaDB vector database implementation to the Agno SDK, enabling users to store and retrieve vector embeddings using the ChromaDB library. This integration supports multiple search modes including vector similarity, keyword search, and hybrid search (combining both via Reciprocal Rank Fusion). It also introduces per-user collection scoping to isolate data by user ID, automatic batch size detection for efficient upserts, and configurable distance metrics. The feature requires the \chromadb\ package to be installed.

libs/agno/agno/vectordb/chroma · high confidence

Agents can now use CodeMode, a new toolkit that provides a persistent IPython kernel for the duration of a session. This allows the model to execute Python and shell commands, keeping variables, imports, and helper functions alive across turns for long-running analysis. The toolkit includes a bridge to inject host toolkits into the kernel, snapshot/restore capabilities using dill, and specific error handling for kernel states.

libs/agno/agno/tools/code · high confidence

The cookbook now includes a new 'CodingTools' section demonstrating a composable toolkit for coding agents, featuring core file operations (read, edit, write) and opt-in shell/exploration tools (run\_shell, grep, find, ls). The examples highlight that \run\_shell\ is disabled by default to prevent arbitrary command execution, requiring explicit enablement, and showcase usage with GPT-5.2 and GPT-5.6 Luna models.

_cookbook/91\_tools/coding\tools · high confidence

Adds a new FastAPI router at \agno/os/routers/components\ that exposes endpoints for creating, updating, retrieving, and deleting components (agents and teams). This includes logic for handling component dependencies, version conflicts, and draft configurations, along with serialization support for workflow step containers and registry integration for UI workflow rehydration.

libs/agno/agno/os/routers/components · high confidence

Users can now store sessions, runs, memories, metrics, evaluations, knowledge, and traces in Google Cloud Firestore. This adds a new \FirestoreDb\ class that manages collections for each data type, automatically creates required single-field and composite indexes via the Firestore Admin API, and handles pagination, sorting, and batched writes (respecting the 500-operation limit).

libs/agno/agno/db/firestore, libs/agno/agno/db/redis · high confidence

The Google models package now includes a new GeminiInteractions class that leverages Google's Interactions API for server-side conversation history, reducing token costs and improving latency. To prevent forcing all users to install the newer google-genai\>=2.0.0 library, the package uses lazy loading for GeminiInteractions, allowing standard Gemini usage to remain compatible with older SDK versions.

libs/agno/agno/models/google · high confidence

Adds a new \LiteLLM\ model wrapper that allows users to interact with various LLM providers through the unified LiteLLM interface. This includes support for streaming, tool calls, structured outputs, and file inputs, along with automatic environment validation and client preservation across background tasks.

libs/agno/agno/models/litellm, libs/agno/agno/models/mistral · high confidence

Added a new Milvus vector database client that supports vector, keyword, and hybrid search modes. The integration includes built-in sparse vector generation for keyword matching, allowing users to perform combined semantic and lexical searches. It also supports per-user data isolation via a dedicated owner field and allows configuring distance metrics and authentication tokens for both local and cloud-based Milvus deployments.

libs/agno/agno/vectordb/milvus · high confidence

This change adds a new \OpenAIResponses\ model class to interact with OpenAI's Responses API, featuring support for reasoning models (o3, o4-mini, gpt-5), background mode for long-running tasks, and automatic recovery when chained responses expire. It also introduces \OpenResponses\ as a base class for other providers implementing the Open Responses spec (e.g., Ollama, OpenRouter) and \OpenAILike\ for generic OpenAI-compatible endpoints. The \OpenAIChat\ class is updated to accept both \httpx.Client\ and \httpx.AsyncClient\ instances, and a new \Requesty\ provider is added to route requests through the Requesty service.

libs/agno/agno/models/openai · high confidence

Users can now store and query vector embeddings using PostgreSQL with the pgvector extension. This change adds the PgVector class, supporting both synchronous and asynchronous operations, and allows configuration of HNSW or Ivfflat indexing strategies. It also introduces hybrid search capabilities (combining vector similarity with full-text search), prefix matching for text queries, and the ability to apply a reranker to refine search results. Additionally, users can control schema creation and set similarity thresholds to filter results.

libs/agno/agno/vectordb/pgvector · high confidence

A new Registry component has been added to centralize the management of non-serializable objects such as tools, models, databases, agents, teams, and workflows. This registry supports structured deduplication of catalog entries, handles toolkit-qualified tool rehydration to prevent silent tool loss, and distinguishes between declared and discovered tools to control their availability in the Studio build palette.

libs/agno/agno/registry · high confidence

The \agno/skills\ module is introduced, providing a structured way to load, validate, and execute agent skills from local directories. Users can now define skills via \SKILL.md\ files containing frontmatter and instructions, with support for embedded scripts and reference documents. The system includes a \Skills\ orchestrator that generates tools (\get\_skill\_instructions\, \get\_skill\_reference\, \get\_skill\_script\) for agents to access these capabilities. It features robust validation against the Agent Skills spec, path safety checks to prevent directory traversal, and cross-platform script execution support (including shebang parsing for Windows).

libs/agno/agno/skills · high confidence

Users can now store and search vector embeddings using the Weaviate vector database. This change adds the Weaviate client implementation, including support for both synchronous and asynchronous operations, configurable vector indices (HNSW, FLAT, DYNAMIC), and distance metrics (COSINE, DOT, L2\_SQUARED, HAMMING, MANHATTAN). It also introduces user-scoped data isolation via a \user\_id\ property and supports hybrid search with a configurable alpha parameter.

libs/agno/agno/vectordb/weaviate · high confidence

The new agnoctl tool provides a unified command-line interface for scaffolding new AgentOS projects and managing MCP server connections across multiple coding agents. It supports interactive project creation with nine deployment templates (Docker, AWS, Azure, Fly, GCP, Helm, Modal, Railway, and Render) and automates the configuration of MCP server entries for Claude Code, Claude Desktop, OpenAI Codex, and Cursor. The tool handles secure credential storage, respects client-specific configuration scopes (user vs. project), and includes safety checks to prevent credential leakage over unencrypted connections.

libs/agnoctl · high confidence

This change adds a new, bounded read-only page filesystem and search capability to the Knowledge system, allowing agents to browse, read, and search published documentation pages using a safe, shell-emulated command grammar (ls, cat, rg, etc.) without executing arbitrary shell commands. The implementation includes a PageFileSystem with configurable output and pattern limits, a PageCoordinator for managing PostgreSQL-backed storage and vector search, and transport adapters for both chat and MCP tool interfaces. Users can now query documentation pages through typed, bounded tools that return structured results, with built-in safeguards against excessive output, regex timeouts, and path traversal.

libs/agno/agno/knowledge/page · high confidence

The \agno/scheduler\ package is now included, providing a complete scheduling system. Users can manage schedules via a \ScheduleManager\ (direct DB access), execute them via \ScheduleExecutor\ (HTTP calls with run polling), and monitor them via a \SchedulePoller\ (background loop). A \SchedulerConsole\ CLI offers Rich terminal views for schedules and runs. Cron expressions and timezones are validated using \croniter\ and \pytz\, and the executor enforces endpoint provenance to prevent drift.

libs/agno/agno/scheduler · high confidence

The AgentOS API now exposes a dedicated router for agent management and execution, consolidating agent-related endpoints into a new \agno/os/routers/agents\ module. This change introduces a structured \AgentResponse\ schema that enriches agent configuration details with fields such as \is\_component\, \current\_version\, and \stage\, and provides a factory-based discovery mechanism for UI workflows. The router implements the core execution logic, including support for both inline and resumable background streaming, file upload handling, and integration with the job queue for checkpointing and run continuation.

libs/agno/agno/os/routers/agents · high confidence

Agents now have a dedicated, durable filesystem for storing and retrieving notes, decisions, and running documents that persist across sessions. This new \agno.fs\ module provides a pluggable storage backend (defaulting to a database via SQLAlchemy, with a local disk option) and a toolkit of tools (\read\_file\, \write\_file\, \append\_file\, \replace\_lines\, \list\_files\, \search\_content\, \move\_file\, \delete\_file\, \check\_lines\) that agents can use to manage their own private state. The filesystem supports namespaced isolation, templated namespaces for multi-tenancy (e.g., \{user\_id}\), and configurable size quotas. It is designed to be attached to an agent via \FileSystem.tools()\ and integrates with the agent's instructions to guide proper usage conventions.

libs/agno/agno/fs · high confidence

The \agno.context\ package now provides a first-party \ContextProvider\ API, allowing agents to access external data sources through a unified interface. This release includes built-in providers for Google services (Calendar, Gmail, Drive), SQL databases, local filesystems, and Model Context Protocol (MCP) servers. Each provider supports natural-language querying via sub-agents, configurable read/write scopes, and distinct exposure modes (agent-wrapped or direct tools) to prevent tool name collisions.

libs/agno/agno/context · high confidence

Users can now optimize stored memories to reduce token usage and manage context window limits. This change introduces a new \agno/memory/strategies\ module containing a base \MemoryOptimizationStrategy\ interface, a \SummarizeStrategy\ that combines multiple memories into a single comprehensive summary, and a factory for instantiating these strategies. The implementation includes a token counting utility to track compression ratios and supports both synchronous and asynchronous optimization workflows.

libs/agno/agno/memory/strategies · high confidence

AgentOS now supports offloading media files (images, audio, video, and generic files) to external storage backends instead of keeping them in the database. This adds a new \agno.media\ module with a unified \MediaReference\ model and storage interfaces (\MediaStorage\, \AsyncMediaStorage\) implemented for local filesystem, Amazon S3, and Google Cloud Storage. Users can now configure these backends to handle media uploads, downloads, and presigned URL generation, allowing the AgentOS to manage large media assets efficiently while keeping the database lightweight.

libs/agno/agno/os · high confidence

This change adds a new \agno.os.public\ module that enables administrators to explicitly expose specific agents, teams, and workflows to anonymous users via a bounded public execution surface. The implementation includes a \PublicSurface\ configuration class for selecting components and defining limits (body size, run duration, active runs), a \PublicLimiter\ that enforces atomic rate limits and concurrency controls using a shared PostgreSQL table, and a \PublicMiddleware\ that handles ASGI admission, identity resolution, and request validation. This allows public access to selected resources while preserving Control Plane access and ensuring resource isolation through database-backed admission.

libs/agno/agno/os/public · high confidence

A new cancellation management subsystem has been added to the run execution layer, providing a \BaseRunCancellationManager\ interface with synchronous and asynchronous methods for registering, cancelling, and checking run states. The package includes an \InMemoryRunCancellationManager\ for single-process scenarios and a \RedisRunCancellationManager\ for distributed environments, allowing users to persist cancellation intent across multiple processes or services. The module also supports 'cancel-before-start' semantics for background runs and includes lazy loading for the Redis dependency to avoid unnecessary import overhead.

_libs/agno/agno/run/cancellation\management · high confidence

The \agno.eval\ package now provides a comprehensive evaluation framework for assessing agent and team behavior. Users can run accuracy evaluations to score responses against expected outputs, use the new Agent-as-Judge capability to grade outputs against custom criteria with an LLM judge (supporting both binary pass/fail and numeric 1-10 scoring modes), and perform reliability checks to verify that agents make the correct tool calls with the correct arguments. The suite runner allows grouping these checks into \Case\ objects, running them sequentially, and producing a \SuiteResult\ suitable for CI gates. Additionally, performance evaluations now include median and 95th percentile metrics for runtime and memory usage, and all evaluations support async execution and database persistence for tracking run history.

libs/agno/agno/eval · high confidence

The \agno/workflow\ package now provides a complete set of workflow orchestration components, including \Workflow\, \Step\, \Parallel\, \Loop\, \Condition\, and \Router\, along with a specialized \WorkflowAgent\ for agent-driven orchestration. Users can now define complex, multi-step processes with branching logic, parallel execution, and iterative loops. A key addition is the Human-In-The-Loop (HITL) support, allowing workflows to pause for user confirmation or input at specific steps via the \@pause\ decorator or explicit \HumanReview\ configuration. The system also supports Common Expression Language (CEL) for dynamic condition and routing logic, and enables remote workflow execution through \RemoteWorkflow\.

libs/agno/agno/workflow · high confidence

The session management layer now provides distinct session classes—AgentSession, TeamSession, and WorkflowSession—each tailored to its specific execution context. AgentSession and TeamSession support unified run persistence with filtering by agent or team identifiers, while WorkflowSession introduces structured history retrieval for pipeline-based workflows. A new SessionSummaryManager enables configurable, model-driven conversation summarization with limits on recent runs and message counts, and shared utilities handle run indexing and serialization across all session types.

libs/agno/agno/session · high confidence

The AgentOS now includes a dedicated middleware package that adds JWT authentication support (with optional RBAC and audience verification), a TrailingSlashMiddleware to normalize URL paths by stripping trailing slashes, and an MCPRoutingMiddleware to handle MCP endpoint hostname and path routing. The JWT middleware also introduces stub classes to handle missing PyJWT dependencies gracefully, ensuring the application fails with a clear error message rather than crashing silently.

libs/agno/agno/os/middleware · high confidence

The \agno/learn\ module is now available, providing a unified system for agents to learn and remember. This includes a \LearningMachine\ orchestrator that coordinates multiple learning stores (user profile, user memory, session context, entity memory, and learned knowledge), along with configuration classes, data schemas, and a \Curator\ for memory maintenance tasks like pruning and deduplication. A migration utility is also included to re-key legacy entity memory rows for proper user-scoping.

libs/agno/agno/learn · high confidence

Adds a new in-memory storage backend for session, memory, and metrics data, providing a lightweight, zero-configuration alternative to persistent databases for development and testing. This implementation supports core operations like session retrieval with optional run limiting, deletion with user filtering, and daily metric calculation, while utilizing an internal cache to optimize the performance of reading historical session runs.

_libs/agno/agno/db/in\memory · high confidence

Users can now store and search vector embeddings using LanceDB. This change adds the \LanceDb\ class and \SearchType\ enum to the \agno.vectordb\ package, providing support for both synchronous and asynchronous operations, configurable distance metrics, and backward compatibility with older LanceDB API versions for listing tables.

libs/agno/agno/vectordb/lancedb · high confidence

The \agno/memory\ package now exposes a \MemoryManager\ class and associated optimization strategies (such as \SummarizeStrategy\) to handle user memory lifecycle. This component provides a unified interface for storing, retrieving, and managing conversation memories, with support for both synchronous and asynchronous database backends. Users can now configure memory behaviors, including enabling or disabling memory deletion and updates, and utilize the manager to persist and query user-specific memory data.

libs/agno/agno/memory · high confidence

The knowledge package has been reorganized to improve startup performance and clarify data structures. The main \agno.knowledge\ module now uses PEP 562 lazy loading, meaning heavy dependencies like cloud storage clients and readers are not imported until actually needed. New data models have been introduced: \Content\ (with status tracking and authentication fields), \Document\ (with async embedding support), and \KnowledgeProtocol\ (defining the interface for custom knowledge bases). The \FileSystemKnowledge\ implementation now exposes specific tools (\grep\_file\, \list\_files\, \get\_file\) and includes path traversal protection. Additionally, \RemoteKnowledge\ provides a unified base for loading content from S3, GCS, SharePoint, GitHub, and Azure Blob Storage.

libs/agno/agno/knowledge · high confidence

The MongoDB database integration has been expanded to include a new \AsyncMongoDb\ class, allowing users to perform non-blocking database operations in async applications. This implementation supports both the modern PyMongo async client (recommended, requiring \pymongo\>=4.9\) and the legacy Motor library, automatically detecting and preferring the available driver. The update also introduces a lazy import mechanism for the async client in the \agno.db.mongo\ package to avoid unnecessary dependencies during synchronous usage, and includes comprehensive schema definitions and index management utilities for both sync and async contexts.

libs/agno/agno/db/mongo · high confidence

Users can now store and query vector embeddings in MongoDB using the new \MongoDb\ class (aliased as \MongoVectorDb\). This implementation supports both synchronous and asynchronous operations, allowing non-blocking integration with async applications. It includes built-in hybrid search capabilities that combine vector similarity with keyword filtering, configurable via weights and rank constants. The client automatically handles Atlas Search index creation and provides specific compatibility mode for Azure Cosmos DB for MongoDB vCore. Additionally, it surfaces embedding failures during ingestion and includes metadata handling for fields like \user\_id\ to enable efficient filtering.

libs/agno/agno/vectordb/mongodb, libs/agno/agno/vectordb/qdrant · high confidence

The \agno/tracing\ module now provides built-in OpenTelemetry-based tracing that automatically captures agent runs, model calls, tool executions, and workflow steps, storing the resulting traces and spans directly in the configured Agno database via a custom \DatabaseSpanExporter\. Users can enable this feature by calling \setup\_tracing(db)\ to configure the tracer provider and instrument Agno components, with support for both immediate (\SimpleSpanProcessor\) and batched (\BatchSpanProcessor\) export modes to suit different performance needs.

libs/agno/agno/tracing · high confidence

The reasoning module now provides built-in support for native reasoning models across multiple providers, including Anthropic Claude (with thinking), DeepSeek (R1, V4, V3.1, V3.2), Gemini (2.5+, 3.0+), OpenAI (o1, o3, o4, GPT-5), Azure AI Foundry, Groq, Ollama, Moonshot, and VertexAI. This enables agents to automatically detect reasoning-capable models, extract and stream their chain-of-thought content, and integrate reasoning metrics into the parent run.

libs/agno/agno/reasoning · high confidence

Users can now connect to external A2A-compatible agent servers using the new A2AClient. This client supports both REST and JSON-RPC protocols, allowing you to send messages with text, images, audio, video, and files, and receive responses as structured TaskResults or streamed events. The included utilities automatically map these A2A responses into Agno's native RunOutput and RunOutputEvent formats, enabling seamless integration with existing Agno agent workflows.

libs/agno/agno/client/a2a · high confidence

A new AG-UI interface has been added to the AgentOS, allowing you to expose an Agent or Team via a FastAPI router that speaks the AG-UI protocol. This interface handles streaming events (text, tool calls, reasoning, and state deltas), supports multimodal inputs (images, audio, video, files), and enables client-side tool execution with human-in-the-loop resumption. It also supports custom route prefixes and integrates with session state and user identity resolution.

libs/agno/agno/os/interfaces/agui · high confidence

Added a new set of cookbook examples in \cookbook/91\_tools/advisor\_tools\ demonstrating how to use \AdvisorTools\ to let an agent consult external models for feedback. The examples cover basic single-advisor usage, polling multiple advisors for diverse perspectives, escalating complex tasks to larger models via string-based model IDs, applying custom system messages for domain-specific reviews, and running advisor queries in parallel using async variants.

_cookbook/91\_tools/advisor\tools · high confidence

This change introduces the dedicated knowledge router for AgentOS, exposing REST endpoints for uploading content (files, text, URLs), managing content status, and performing vector searches. It adds support for configuring chunking strategies (size and overlap), selecting specific readers, and handling remote knowledge bases, providing a structured API for interacting with the system's knowledge base.

libs/agno/agno/os/routers/knowledge · high confidence

This change introduces the initial implementation of the Team router for AgentOS, exposing REST endpoints to manage and run teams. It includes schema definitions for team configuration (TeamResponse) and router logic for handling team runs, including streaming responses, file uploads, and session management. This provides the foundational API surface for interacting with team-based agent workflows within the AgentOS platform.

libs/agno/agno/os/routers/teams · high confidence

A new \AgentOSClient\ class has been introduced in the SDK client module, providing a unified interface for interacting with the AgentOS API. This client supports both synchronous and asynchronous HTTP requests, enabling users to manage agents, teams, workflows, evaluations, memory, metrics, and traces remotely. It handles connection timeouts and server unavailability gracefully, ensuring robust communication with the AgentOS backend.

libs/agno/agno/client · high confidence

This change introduces three new model providers for Azure, expanding the library's coverage of Azure AI services. Users can now interact with Azure AI Foundry models via the new \AzureAIFoundry\ class (using the \azure-ai-inference\ SDK), access Claude models hosted on Azure AI Foundry via \AzureFoundryClaude\ (using the \anthropic\ SDK), and utilize the new Azure OpenAI Responses API via \AzureOpenAIResponses\. The existing \AzureOpenAI\ chat provider is also updated to support Azure AD token providers and \azure\_ad\_token\ for authentication, alongside a fix to avoid injecting shared HTTP/2 clients that could cause transient errors.

libs/agno/agno/models/azure · high confidence

Users can now offload high-volume tracing data to ClickHouse via the new \ClickhouseDb\ adapter, which is designed specifically for trace and span ingestion and should be paired with a row-store like \PostgresDb\ for sessions and memories. The database layer also introduces a shared, centralized implementation for MCP OAuth token storage (\mcp\_oauth\_store.py\), consolidating logic for client registration, transaction management, and code/refresh token handling across sync SQLAlchemy backends.

libs/agno/agno/db · high confidence

The Discord integration is now available, allowing agents and teams to interact via Discord messages. This client supports processing text along with attached images, videos, audio, and files by using asynchronous reads for media content. It automatically creates threads for messages in text channels, passes the Discord user ID and username as context to the agent, and handles human-in-the-loop confirmations for tools requiring user approval.

libs/agno/agno/integrations · high confidence

A new cookbook entry has been added to demonstrate the \DoclingTools\ integration. It provides runnable examples showing how an agent can convert various document formats (PDF, DOCX, Markdown, HTML, XML, XLSX, PPTX, images, and audio/video) into different output formats like Markdown, JSON, YAML, and VTT. The examples also cover advanced configuration options, such as enabling OCR with specific engines (e.g., EasyOCR) and language settings for PDF processing.

_cookbook/91\_tools/docling\tools · high confidence

The cookbook now includes a new set of examples under \cookbook/07\_knowledge/05\_integrations/readers/docling/\ demonstrating the \DoclingReader\ integration. These examples cover processing audio files (WAV, MP3, MP4) with speech-to-text, office documents (DOCX, PPTX, DOTX), images (JPEG, PNG) with OCR, and markup formats (XML, HTML, LaTeX). The examples also illustrate various input types (local paths, URLs, file-like objects) and output formats (markdown, text, HTML, JSON, VTT, doctags). A fix ensures the \DoclingReader\ accepts local file path strings directly.

_cookbook/07\_knowledge/05\integrations/readers · high confidence

Added a new \GcsJsonDb\ database implementation that stores session, run, memory, metrics, evaluation, knowledge, and trace data as JSON files in a Google Cloud Storage bucket. This backend supports configurable table names, GCS project and credential settings, and includes utilities for calculating daily user metrics and handling schema versioning for migrations.

_libs/agno/agno/db/gcs\json · high confidence

This location introduces a comprehensive set of example agents (cookbooks) for interacting with Google Workspace services. The new files demonstrate how to build agents for Gmail (including daily digests, action item extraction, inbox triage with persistent memory, and draft replies), Google Calendar (event creation, daily briefings, and multi-person meeting scheduling), Google Drive (file search, document reading, folder organization, and shared drive compliance searches), Google Slides (presentation creation and content management), and Google Sheets (action tracking and sales pipeline forecasting). The cookbooks cover both OAuth and service account authentication patterns, showing users how to configure credentials, enable APIs, and use structured output schemas to get reliable results from models like gpt-5.5 and gpt-5.6-luna.

_cookbook/91\tools/google · high confidence

A new JSON-based database backend (JsonDb) is introduced for the Agno SDK, allowing users to store sessions, runs, memories, metrics, evaluations, knowledge, and traces in local JSON files. This implementation supports configurable table names, automatic directory creation, UTF-8 encoding, schema versioning with a migration manager, and utility functions for sorting and calculating daily usage metrics.

libs/agno/agno/db/json · high confidence

The cookbook/08\_learning directory now includes a comprehensive set of Python examples demonstrating the Learning Machine capabilities. These examples cover user profile and memory extraction in both automatic (ALWAYS) and agent-controlled (AGENTIC) modes, session context tracking with summary and planning features, cross-user learned knowledge storage, and entity memory for tracking external world facts. The examples also demonstrate custom profile schemas, extraction limits to prevent infinite loops, and the four core entity memory tools (remember, link, search, forget).

_cookbook/08\learning · high confidence

The \agno.learn.stores\ package introduces a unified storage backend system for agent learning, exposing a \LearningStore\ protocol and six concrete implementations: \UserProfileStore\ (structured long-term user fields), \UserMemoryStore\ (unstructured long-term memories), \SessionContextStore\ (current session state and planning), \LearnedKnowledgeStore\ (reusable cross-agent insights with semantic search), \EntityMemoryStore\ (facts about external entities like people or companies), and \DecisionLogStore\ (agent decision auditing). Each store supports configurable extraction modes (ALWAYS, AGENTIC, PROPOSE) and provides agent-facing tools for in-conversation updates, enabling agents to persist, recall, and leverage structured and unstructured knowledge across sessions.

libs/agno/agno/learn/stores · high confidence

A new cookbook example has been added to demonstrate an Agno Agent interacting with a PostgreSQL database via the MCP Toolbox. The demo includes a Docker Compose setup for the database and toolbox server, SQL initialization scripts with sample hotel data, and Python scripts for an interactive CLI agent, an AgentOS web interface, a type-safe agent using Pydantic models, and a sequential workflow for searching and booking hotels.

_cookbook/91\_tools/mcp/mcp\_toolbox\demo · high confidence

This location introduces a comprehensive set of new cookbook examples demonstrating how to build agents using the Model Context Protocol (MCP) with Agno. The new files include \README.md\ and \TEST\LOG.md\ for documentation and testing status, along with numerous Python scripts (\\.py\) showcasing various integrations: filesystem exploration, GitHub repository analysis, scientific paper search via BGPT, Airbnb listing searches, Brave search, database management with GibsonAI and MCPToolbox, personal memory with Graphiti and Mem0, shared world memory with emem, fiat payouts with Peer Cash, and media generation with Magic Hour. The examples cover different transport modes (stdio, SSE, streamable-http), protocol negotiation (legacy vs. auto), tool filtering (include/exclude), and structured content handling. Specific models like GPT-5.6 Luna, Claude Sonnet 4-5, and Groq's gpt-oss-120b are used in the examples.

_cookbook/91\tools/mcp · high confidence

Added new cookbook examples in the \91\_tools/mcp\ directory demonstrating how to use the \MCPTools\ class with both SSE and Streamable HTTP transports. The \sse\_transport\ and \streamable\_http\_transport\ directories now contain \server.py\ and \client.py\ scripts that show how to start example MCP servers and connect agents to them, including support for connecting to multiple servers with different transports simultaneously. The SSE example includes a note that SSE is deprecated in favor of Streamable HTTP for new servers.

_cookbook/91\_tools/mcp/sse\_transport, cookbook/91\_tools/mcp/streamable\_http\transport · high confidence

This change introduces the core API layer for user memory management within the AgentOS. It adds new FastAPI router files (\memory.py\, \schemas.py\) that expose endpoints for creating, reading, deleting, and optimizing user memories, along with the corresponding Pydantic request/response models. The implementation supports both synchronous and asynchronous database backends, handles user scoping via JWT tokens, and includes logic to gracefully handle memory data migrated from previous versions (v1).

libs/agno/agno/os/routers/memory · high confidence

This change introduces a new FastAPI router at /eval-runs that allows users to programmatically trigger and manage evaluation runs for agents and teams via the Operating System API. The endpoint supports four evaluation types: accuracy (comparing output to expected results), agent-as-judge (using an LLM to score outputs against criteria with numeric or binary scoring), performance (measuring latency and throughput with configurable warmup runs), and reliability (verifying expected tool calls with optional subset matching). Users can create, list, filter, sort, and delete evaluation runs, with results stored in the configured database (supporting both synchronous and asynchronous database backends). The API handles authentication, user scoping, and pagination for all evaluation operations.

libs/agno/agno/os/routers/evals · high confidence

This change introduces two new model classes for the OpenRouter provider: \OpenRouter\ and \OpenRouterResponses\. The \OpenRouter\ class adds support for dynamic model routing via a \models\ fallback list, allowing the system to automatically try alternative models if the primary one fails. It also enables the extraction and inclusion of generated images from OpenRouter's response data. The new \OpenRouterResponses\ class provides access to OpenRouter's beta OpenAI-compatible Responses API, including specific handling for reasoning models and the same fallback routing capability.

libs/agno/agno/models/openrouter · high confidence

Added a new set of example scripts in the \cookbook/91\_tools/parallel\ directory that demonstrate how to integrate the Parallel web research and monitoring APIs with the Agno framework. The collection includes a quick-start guide (\parallel\_tools.py\), a fast news search example (\news\_search.py\), and several deep-research and monitoring use cases: company enrichment (\company\_enrichment.py\), market research report generation (\market\_research.py\), competitor tracking (\competitor\_tracker.py\), and investment/M&A monitoring (\investment\_monitor.py\). It also provides a reference for the Task API's four output schema types (\output\_schemas.py\). These files show users how to configure \ParallelTools\ for different speeds and use cases, from quick lookups to scheduled change detection.

_cookbook/91\tools/parallel · high confidence

This change introduces a new PostgreSQL database implementation for the Agno library, providing both synchronous (PostgresDb) and asynchronous (AsyncPostgresDb) interfaces. It includes dedicated engine factories that configure connection pooling defaults (pre-ping, recycle) and JSON serialization, along with a bounded pool module to enforce connection checkout deadlines and prevent pool exhaustion. The backend manages database schemas, table creation, and validation, supporting a wide range of tables for sessions, runs, memory, metrics, evaluations, knowledge, traces, and MCP OAuth storage.

libs/agno/agno/db/postgres · high confidence

Added three new integration examples to the RAG cookbook: an agentic RAG setup using Infinity reranker with LanceDB and Cohere embeddings, an agentic RAG flow backed by LightRAG with Wikipedia and PDF sources, and a local RAG implementation using LangChain, Qdrant, and Ollama. These examples demonstrate various retrieval-augmented generation patterns with different vector databases and reranking strategies.

_cookbook/07\_knowledge/05\integrations/rag · high confidence

This change introduces a new REST API router for creating, listing, updating, and deleting scheduled tasks. Users can now define cron-based schedules that trigger specific API endpoints, with support for configuring payloads, timezones, timeouts, and retry logic. The API enforces strict validation on schedule names and endpoint paths, checks for required dependencies (croniter, pytz), and implements permission controls to ensure callers have the necessary scopes to target the specified endpoints. The response models provide detailed information about schedule state, run history, and management provenance.

libs/agno/agno/os/routers/schedules · high confidence

This change introduces a new Slack interface for AgentOS, enabling users to interact with agents, teams, and workflows directly within Slack. The implementation includes a full event handling system for processing messages and interactions, a Human-in-the-Loop (HITL) handler for managing approvals and user inputs, and streaming support for real-time updates. It also provides a Slack app manifest for easy configuration and includes security features like signature verification and event deduplication to ensure reliable and secure communication.

libs/agno/agno/os/interfaces/slack, libs/agno/agno/os/interfaces/whatsapp · high confidence

Added a comprehensive set of cookbook examples in cookbook/03\_teams/01\_quickstart and cookbook/03\_teams/02\_modes demonstrating Team execution modes (coordinate, route, broadcast, tasks), history persistence with SQLite, concurrent member execution, and nested team structures.

_cookbook/03\teams · high confidence

This change introduces a new Telegram interface that allows users to connect their Agno agents, teams, or workflows to Telegram. The implementation includes a FastAPI router with webhook support, handling incoming messages, commands (/start, /help, /new), and streaming responses. It supports various media types (photos, audio, video, documents) and includes features like session management, rate limiting, and HTML formatting for Telegram messages. Users can configure the bot with custom start, help, and error messages, and enable or disable streaming and reasoning display.

libs/agno/agno/os/interfaces/telegram · high confidence

The AgentOS now exposes a dedicated Traces API (GET /traces) that allows users to list, filter, and paginate execution traces for agents, teams, and workflows. The endpoint supports filtering by run, session, user, agent, team, workflow, status, and time range, and returns summary data including duration, span counts, and error counts. For scoped (non-admin) users, the API enforces data isolation by automatically scoping queries to their own user\_id, ensuring they can only view their own traces.

libs/agno/agno/os/routers/traces · high confidence

A new local-machine toolkit is available for managing files and shell commands within a scoped root directory. It includes tools for reading, writing, editing, moving, deleting, searching, and running shell commands, all restricted to the specified root path. Destructive operations (write, edit, delete, move, shell) require human confirmation by default, which can be handled via AgentOS approval cards or a manual console loop, while read operations run silently. The toolkit also supports read-only modes, defensive patterns like requiring a file to be read before writing, and exclusion patterns to hide sensitive files like .env.

_cookbook/91\_tools/workspace\tools · high confidence

The accuracy evaluation cookbook now includes a comprehensive set of examples demonstrating various evaluation scenarios. Users can now explore basic sync and async evaluations, numeric comparison tasks, team-based language routing, evaluations with pre-provided answers, tool-using agents, custom evaluator agents, and database logging to PostgreSQL. Additionally, a new example shows how to accumulate evaluation model metrics alongside agent metrics in the run output.

_cookbook/09\_evals/accuracy, cookbook/09\_evals/agent\_as\judge · high confidence

The 14\_advanced cookbook directory now includes a comprehensive set of examples demonstrating advanced agent capabilities. Users can learn how to cancel running agents and verify that partial content and messages are persisted in the database, manage background execution with polling and cancellation, and enforce process-wide concurrency limits for background runs. The examples also cover agent serialization, caching model responses, handling agent lifecycle events, and accessing detailed run metrics for both synchronous and asynchronous runs. Additionally, there are examples for background streaming with disconnect and resume capabilities, custom cancellation managers, and advanced context compression strategies.

_cookbook/02\_agents/14\advanced · high confidence

Added starter examples for creating and running agents with core settings, including basic agents, agents with instructions, and agents with tools (DuckDuckGo). Also introduced examples for persistent memory and learning behavior, demonstrating the LearningMachine for user-profile-based learning and the MemoryManager for structured memory storage and retrieval across sessions using SQLite.

_cookbook/02\_agents/01\quickstart · high confidence

The AgentOS now exposes a dedicated set of endpoints for managing human approvals, including listing, retrieving, checking status, and resolving (approving or rejecting) them. A key behavioral change is the enforcement of per-user data isolation: when user isolation is enabled, non-admin users can only view and interact with approvals assigned to them, while admins retain full visibility. Additionally, resolving an approval is restricted to admin users under isolation mode to prevent unauthorized state changes, and the API response models now include the current run status to help clients determine if a run has already continued.

libs/agno/agno/os/routers/approvals · high confidence

The SDK now includes a new \agno.api\ module that automatically records telemetry data for agent, team, workflow, and eval runs, as well as OS launches, in the background. This feature sends usage statistics to the Agno API without blocking the main application thread, using a bounded queue and configurable timeouts to ensure reliability. Users can configure the telemetry endpoint and timeouts via environment variables like \AGNO\_TELEMETRY\_TIMEOUT\ and \AGNO\_API\_RUNTIME\.

libs/agno/agno/api · high confidence

The tools cookbook now includes examples for dynamic tool selection using callable factories that vary the available tools based on user role or session state, as well as dynamic team member assembly. Additionally, it demonstrates support for Python typing.Literal parameters in tool definitions, allowing agents to enforce predefined value constraints for tool arguments.

_cookbook/02\_agents/04\tools · high confidence

Added a new cookbook demonstrating how to use \checkpoint="tool-batch"\ for mid-run persistence and crash recovery. The examples show how to simulate a worker crash and resume the run in place using \/continue\, how in-flight conversation messages are preserved when a model call fails (via the \flush\_in\_flight\_messages\_on\_error\ logic), and how to use the new \/checkpoints\ and \/checkpoints/{message\_index}\ HTTP endpoints to inspect the checkpoint timeline and resume from specific message boundaries.

_cookbook/02\_agents/18\checkpointing · high confidence

The knowledge chunking module now includes three new strategies alongside existing ones. AgenticChunking uses an LLM to determine natural text breakpoints based on context and supports custom prompts. CodeChunking leverages the Chonkie library to split code files using Abstract Syntax Trees (ASTs) for structurally relevant segments. PageMarkdownChunking provides a heading-aware markdown splitter that preserves newlines and code fences, adding page context and breadcrumbs to chunks for better retrieval. These are available via the ChunkingStrategyFactory.

libs/agno/agno/knowledge/chunking · high confidence

Added cookbook examples in the cloud integrations directory demonstrating how to load remote content from AWS S3, Azure Blob Storage (including SAS token authentication), Google Cloud Storage, SharePoint, and GitHub. The GitHub example specifically shows how to use a single configuration to access multiple repositories by specifying the repo at request time. A multi-source example demonstrates combining these providers into a single Knowledge instance with a shared vector database.

_cookbook/07\_knowledge/05\integrations/cloud · high confidence

Added a new cookbook section at cookbook/02\_agents/03\_context\_management featuring seven Python examples that demonstrate how to shape agent context. These include setting custom system messages and roles, defining dynamic instructions based on session state, configuring introduction messages, applying few-shot learning via additional input, filtering tool calls from history to manage context size, and customizing the datetime format injected into the agent's context.

_cookbook/02\_agents/03\_context\management · high confidence

A new cookbook (cookbook/93\_components) provides examples for saving and loading Agents, Teams, and Workflows to PostgreSQL or SQLite databases, enabling configuration-as-code patterns with versioning and deletion. It also demonstrates how AgentOS can automatically discover and populate its registry with models, tools, and databases from these components without explicit declaration, and shows how to enforce per-user component isolation via JWTs.

_cookbook/93\components · high confidence

Added a new cookbook in the \interchange\_model\ directory that demonstrates how to switch between different model providers (OpenAI Chat, OpenAI Responses, Anthropic Claude, Google Gemini, and AWS Claude) within a single agent session while preserving tool call history. The included scripts (\openai\_claude.py\, \openai\_chat\_responses.py\, \openai\_gemini.py\, \claude\_gemini.py\, and \all\_providers.py\) show how to maintain context and tool usage across provider boundaries using the \add\_history\_to\_context\ parameter.

_cookbook/02\_agents/14\_advanced/interchange\model · high confidence

Added three new cookbook examples demonstrating checkpoint-based agent capabilities. The regenerate demo shows how to redo the last response while preserving tool exchanges, with options to hide or keep the original run visible. The time-travel demos illustrate rewinding a run to specific message boundaries (end, last user, or index) and forking into a new sibling run. The fork-session demo shows how to deep-copy an entire session into a new independent session with fresh IDs, preserving lineage for nested forks.

_cookbook/02\_agents/19\_regenerate, cookbook/02\_agents/20\_time\_travel, cookbook/02\_agents/21\_fork\session · high confidence

Added a new \cookbook/frameworks\ section with quickstart and detailed examples for integrating external agent frameworks with AgentOS. This includes standalone and AgentOS-served examples for Agno (with Workspace tools), the Claude Agent SDK (with built-in and custom MCP tools), LangGraph (with tool calling and time-travel replay), and DSPy (with ReAct and web search). Additionally, new examples demonstrate integrating Google's Gemini Agents API (Antigravity) as both a managed agent loop and a toolkit, including session persistence and environment snapshotting.

cookbook/frameworks · high confidence

Added a new set of cookbook examples in the 'other' tools subsection demonstrating advanced agent tool capabilities. These examples show how to add tools after initialization, cache tool results, handle complex input types with Pydantic models, implement human-in-the-loop confirmation via pre-hooks, and selectively include or exclude specific tools from toolkits. Additionally, the examples illustrate how to control agent execution flow using the \stop\_after\_tool\_call\ feature, including scenarios with custom toolkits and dual inheritance.

_cookbook/91\tools/other · high confidence

Added a new cookbook section demonstrating runtime dependency injection and dynamic tool configuration for agents. The examples show how to pass dependencies into the agent context, how tools can access those dependencies via the run context, and how to define tools that are resolved dynamically at runtime based on session state.

_cookbook/02\_agents/15\dependencies · high confidence

The cookbook now includes runnable examples for handling agent exceptions, specifically demonstrating how to use \RetryAgentRun\ to automatically retry tool calls (both directly in tools and via post-hooks) and how to use \StopAgentRun\ to halt execution. Additionally, new workflow observability examples show how to trace multi-step Agno workflows using OpenInference with Arize Phoenix and Langfuse.

cookbook · high confidence

The \02\_agents/02\_input\_output\ cookbook now includes a comprehensive set of examples demonstrating how to control agent behavior through structured inputs and outputs. Users can now see how to use \input\_schema\ for validating agent inputs, \output\_schema\ and \output\_model\ for generating structured data, and \expected\_output\ to guide response formatting. The directory also introduces \followup\_suggestions.py\ and \followup\_suggestions\_streaming.py\, which demonstrate the new built-in capability to automatically generate follow-up prompts after a main response, available in both standard and streaming modes. Additional examples cover streaming responses, saving outputs to files, and capturing responses as variables.

_cookbook/02\_agents/02\_input\output · high confidence

Added a new set of cookbook examples in the \models\ tools subsection demonstrating how to use various AI toolkits for image, video, speech, and transcription capabilities. The new files include \aimlapi\_tools.py\ for the AIMLAPITools toolkit (supporting image, speech, transcription, and video generation via AI/ML API), \azure\_openai\_tools.py\ for Azure OpenAI image generation, \gemini\_image\_generation.py\ and \gemini\_video\_generation.py\ for GeminiTools (Imagen and Vertex AI Veo), \morph.py\ for MorphTools code editing, \nebius\_tools.py\ for NebiusTools image generation, and \openai\_tools.py\ for OpenAITools transcription and image generation. A README.md and TEST\_LOG.md were also added to document these examples and their verification status.

_cookbook/91\tools/models · high confidence

Added a new cookbook directory at cookbook/91\_tools/tool\_decorator containing examples that demonstrate various tool decorator features. These include basic tool definition, async tool handling, caching tool results, stopping execution after a tool call, applying decorators to class methods within Toolkits, using execution hooks for logging, providing per-tool instructions to guide model behavior, and verifying that per-tool instructions are correctly surfaced when tools are registered via a Toolkit.

_cookbook/91\_tools/tool\decorator · high confidence

Added a new \tool\_hooks\ cookbook directory containing examples for using tool execution hooks and accessing run message history. The examples demonstrate how to define pre- and post-hooks for individual tools and global hooks for all tools, including support for both synchronous and asynchronous execution. Specific use cases include logging tool calls, validating arguments (e.g., preventing deletion of specific customer profiles), and accessing the current run's message history via \run\_context.messages\ within hooks. The examples also show how to use hooks with custom Toolkits and manage session state within hook logic.

_cookbook/91\_tools/tool\hooks · high confidence

Added three complete, runnable agent examples in the cookbook that demonstrate serving agents as MCP tools. The Second Brain example provides a personal memory store using entity memory and file-system notes, pinned to a specific user identity. The Metrics Desk example exposes a production database as a read-only MCP tool, enforcing strict write-protection via SQLite authorizers to prevent data modification. The Team Brain example implements a shared decision log where team members authenticate via service-account tokens to ensure correct attribution of decisions.

cookbook/examples · high confidence

Added a new example demonstrating how to trace multi-agent teams using Langfuse via OpenInference. The \langfuse\_via\_openinference\_team.py\ script shows how to instrument an Agno team (comprising a market data agent and a news research agent) to send traces to Langfuse, supporting both synchronous and asynchronous execution paths.

cookbook/observability/teams · high confidence

This change introduces the \cookbook/11\_memory\ directory, providing a comprehensive set of examples for implementing persistent memory in Agno agents. It includes core patterns such as basic persistent memory, agentic memory management, multi-user multi-session chat (both sequential and concurrent), and custom memory manager configurations. Additionally, it features integration examples for external memory services including Mem0, Memori, Zep, Dakera, and inspeximus, demonstrating how to connect agents to various memory backends for cross-session context retention.

_cookbook/11\memory · high confidence

The cookbook/scripts directory now includes a suite of automation tools to standardize and run example code. A new Python checker (check\_cookbook\_pattern.py) enforces a consistent structure for Python examples, requiring module docstrings, specific section banners (e.g., 'Create', 'Run'), and a main execution gate, while prohibiting emojis. A companion runner (cookbook\_runner.py) allows users to execute cookbook scripts with concurrency, timeouts, and retry logic, capturing output for easier debugging. Additionally, shell and batch scripts are provided to format code using Ruff, validate code quality with Ruff and MyPy, and launch various supported databases (such as PostgreSQL, MySQL, Elasticsearch, and Redis) via Docker for local testing.

cookbook/scripts · high confidence

The \cookbook/data\_labeling\ directory now provides a comprehensive set of runnable examples for labeling, classification, and synthetic data generation. It includes 28 distinct workflows covering text, image, audio, video, and document modalities, with primitives for single-label and multi-label classification, structured extraction, span labeling, and pairwise preference ranking. The collection also introduces advanced composed patterns such as LLM-as-judge scoring, quality review pipelines, inter-annotator agreement metrics, and synthetic data generation techniques like instruction generation, rejection sampling, and critique-and-revision. Additionally, it features scale-out mechanics for high-volume processing and safety labeling for policy-taxonomy classification, all demonstrated using the agno framework with models like Gemini 3.5 Flash.

_cookbook/data\labeling · high confidence

This location introduces the database schema definitions for several new capabilities. The \approval.py\ schema supports human-in-the-loop approval workflows, while \jobs.py\ defines the durable job queue for background agent runs. \mcp\_oauth.py\ provides the table structures for the built-in OAuth authorization server used by the AgentOS MCP endpoint, and \service\_accounts.py\ defines the schema for machine identities. Additionally, \evals.py\ adds storage for Agent-as-Judge evaluation results, \scheduler.py\ defines the schema for scheduled jobs, and \memory.py\ and \knowledge.py\ define schemas for user memory and knowledge rows respectively.

libs/agno/agno/db/schemas · high confidence

The library introduces a new \agno.utils.print\_response\ package containing specialized modules for rendering execution output. The \agent.py\ module provides \print\_response\_stream\ to display live, streaming agent responses with support for reasoning steps, tool calls, and structured JSON output. The \team.py\ module adds \print\_response\ to visualize team execution, including member responses and reasoning. The \workflow.py\ module provides \print\_response\ for workflows, displaying step-by-step execution details, custom function results, and execution summaries. These utilities replace or supplement previous inline printing logic with a consistent, rich-formatted interface across all execution types.

_libs/agno/agno/utils/print\response · high confidence

The cookbook now includes a CodeSearch agent that answers questions about the repository by searching the codebase, and three wiki agents (LocalWiki, GitWiki, and NotionWiki) that allow users to read and write documentation. LocalWiki stores content in a local markdown folder, GitWiki syncs with a GitHub repository (gated by environment variables), and NotionWiki syncs with a Notion database (also gated by environment variables). All wiki agents support URL ingestion, media digestion, and HTML file generation.

_cookbook/01\demo/agents · high confidence

The cookbook now includes a 'Sorting Hat' agent that automatically inventories and organizes documentation files by analyzing folder contents and proposing a clean category structure. Additionally, a 'Workbench' agent is introduced, which provides a persistent, session-aware environment backed by SQLite storage and served via AgentOS, allowing users to maintain context across multiple interactions with streaming and tracing capabilities.

_cookbook/99\docs · high confidence

A new \agno.environments\ module has been introduced to support running agents against task sets multiple times to measure pass rates and generate supervised fine-tuning (SFT) datasets. This feature includes an async rollout engine that isolates attempts, a scoring system with fingerprinting to detect environment drift, and exporters that convert passing attempts into portable JSONL format for training. Users can now programmatically evaluate agent reliability across K attempts and export high-quality training data directly from evaluation results.

libs/agno/agno/environments · high confidence

Added a new \cookbook/environments\ section providing 28 progressive, single-file runnable examples for verifying agent reliability and generating supervised fine-tuning datasets. The \cookbook/environments/\_00\_quickstart/\ folder offers seven standalone scripts covering the full workflow: running K rollouts, scoring attempts, inspecting pass-rate grids, and exporting passing trajectories to JSONL. The \cookbook/environments/\_01\_first\_environment/\ folder introduces core concepts like typed output verification, environment/policy fingerprints, and stable summary contracts. These cookbooks demonstrate how to identify the 'learning zone' (tasks with partial pass rates) to find where agents are capable but inconsistent, and how to export only the successful attempts for training. The examples use \OpenAIResponses\ with \gpt-5.5\ and require \OPENAI\_API\_KEY\.

cookbook/environments · high confidence

Added cookbook examples for running multiple evaluation cases as an aggregated suite. The new \suite\_basic.py\ and \suite\_team\_scoring.py\ scripts demonstrate how to declare \Case\ objects and execute them via the built-in \cli()\ function, supporting features like tag-based filtering (\--tag\), named case selection (\--name\), JSON reporting (\--json-output\), and verbose output. The examples also show how to use the programmatic \run\_cases()\ and \await arun\_cases()\ entry points for CI integration, and include a \TEST\_LOG.md\ confirming successful execution of these suite workflows.

_cookbook/09\evals/suite · high confidence

The \agno/agents\ package now includes adapters for integrating external agent frameworks directly into the Agno ecosystem. This adds \AntigravityAgent\ for Google's Gemini Agents API, \ClaudeAgent\ for the Claude Agent SDK, \DSPyAgent\ for DSPy programs, and \LangGraphAgent\ for LangGraph compiled graphs. Each adapter implements the \BaseExternalAgent\ interface, allowing these external agents to be used with AgentOS endpoints or standalone via \.run()\ and \.print\_response()\, while supporting session persistence, streaming, and tool call event emission.

libs/agno/agno/agents · high confidence

Added four Python scripts to the fallback models cookbook demonstrating how to configure model fallbacks in agents. The examples cover basic fallback lists, error-specific routing using FallbackConfig (handling rate limits, context overflow, and general errors), handling mid-run failures triggered by tool calls, and setting up callbacks to monitor when a fallback model is activated.

_cookbook/02\_agents/17\_fallback\models · high confidence

The library now includes a new \agno.guardrails\ module that allows users to enforce safety checks on agent inputs. This introduces a \BaseGuardrail\ interface with synchronous and asynchronous \check\ methods, implemented by three specific guardrails: \OpenAIModerationGuardrail\ (which uses the OpenAI Moderation API to detect policy violations in text and images), \PIIDetectionGuardrail\ (which detects and optionally masks PII like SSNs, credit cards, emails, and phone numbers, and supports custom regex patterns), and \PromptInjectionGuardrail\ (which flags inputs containing common jailbreaking or prompt injection keywords).

libs/agno/agno/guardrails · high confidence

The \cookbook/02\_agents/08\_guardrails\ directory now provides a comprehensive set of examples for implementing safety checks and policy enforcement in Agno agents. Users can learn how to apply custom guardrails (e.g., blocking specific dangerous terms), integrate third-party firewalls like DeepKeep AI Firewall, and use built-in guardrails for PII detection (including masking), OpenAI content moderation, output validation, and prompt injection/jailbreak prevention. The examples demonstrate both pre-hook (input) and post-hook (output) integration patterns.

_cookbook/02\_agents/08\guardrails · high confidence

The cookbook now includes dedicated examples for agent hooks and human-in-the-loop (HITL) workflows. The new \09\_hooks\ directory demonstrates pre-hooks, post-hooks, tool hooks, stream lifecycle hooks, and session state hooks, including message history access within tool hooks. The \10\_human\_in\_the\_loop\ directory provides examples for confirmation flows (including advanced patterns, toolkit-based confirmation, and MCP toolkit integration), external tool execution, mixed external and regular tools, deterministic side-effect approval flows, and structured user feedback collection.

_cookbook/02\_agents/10\_human\_in\_the\loop · high confidence

Added a new cookbook section (02\_agents/11\_approvals) demonstrating the @approval decorator for human-in-the-loop (HITL) workflows. The examples cover blocking approvals (@approval) that pause execution before tool runs, and audit approvals (@approval(type='audit')) that log outcomes after execution. The suite includes scenarios for basic confirmation, async execution, external execution results, user input collection, team-level agent pauses, and post-hook audit logging, all utilizing persistent database records for approval lifecycle management.

_cookbook/02\_agents/11\approvals · high confidence

The \cookbook/integrations\ directory now includes dedicated examples for three partner integrations. The Parallel integration provides a progression of web-research agents using the Search, Extract, Task, and Monitor APIs, including persistent assistants, hybrid knowledge bases, research teams, deterministic workflows, and a deployable AgentOS application. The SurrealDB integration demonstrates memory management capabilities, covering standalone CRUD operations, agentic memory creation with custom instructions, and various search retrieval methods. Additionally, a new Discord integration shows how to run an Agno agent as a bot that maintains session state per thread.

cookbook/integrations · high confidence

Added a new set of cookbook examples in the knowledge building-blocks section that demonstrate how to configure and compare core retrieval components. The examples cover chunking strategies (fixed, recursive, semantic, document, markdown, code, and agentic), search types (vector, keyword, and hybrid), and reranking techniques including knowledge-level reranking with Cohere, Maximal Marginal Relevance (MMR) for diverse results, and recency boosting. The cookbooks also show how to apply metadata-based filtering (both static and agent-driven) and compare embedding providers like OpenAI and Ollama, with specific demonstrations for Qdrant, PgVector, and Elasticsearch backends.

_cookbook/07\_knowledge/02\_building\blocks · high confidence

Added a new 'Getting Started' guide in the knowledge cookbook that demonstrates four key capabilities: basic RAG with automatic context injection, agentic RAG where the agent decides when to search, loading content from various sources (local files, URLs, raw text, Wikipedia, and batch operations), and per-page website ingestion using SitemapReader to maintain page-level citations and efficient updates.

_cookbook/07\_knowledge/01\_getting\started · high confidence

This change introduces a new \utils\ package within the knowledge reader module, adding support for processing Excel spreadsheets (converting sheets to documents), transforming MDX components into plain Markdown for indexing, and providing robust URL canonicalization and SSRF protection. The spreadsheet utilities handle cell value stringification and workbook parsing, while the MDX module preserves code fences and unwraps unknown components. Additionally, new URL utilities enforce host allowlists via \allowed\_hosts\ to prevent Server-Side Request Forgery (SSRF) during web ingestion and ensure stable, deduplicated page names for the knowledge base.

libs/agno/agno/knowledge/reader/utils · high confidence

This change introduces a new metrics router (\/metrics\) that allows users to retrieve aggregated analytics for agent runs, sessions, workflows, and token usage. The API supports filtering by date range, specific users, and database IDs, and handles both synchronous and asynchronous database backends. It also includes endpoints to trigger and monitor background metrics refreshes, ensuring that metric data remains up-to-date without blocking the main application threads.

libs/agno/agno/os/routers/metrics · high confidence

The \cookbook/01\_demo\ location now provides a complete, runnable AgentOS demo featuring LocalWiki, GitWiki, and NotionWiki agents that ingest and manage content across local markdown, git repositories, and Notion databases, alongside a CodeSearch agent. The demo includes a FastAPI entrypoint, SQLite-backed session storage, and an integrated evaluation suite (\python -m evals\) that uses LLM-as-judge and reliability checks to verify agent behavior. HTML generation is now a built-in capability of the wiki agents via \FileGenerationTools\, and the setup is streamlined with a \generate\_requirements.sh\ script and clear environment-gated configuration for external backends.

_cookbook/01\demo · high confidence

This release adds support for several new model providers: Cloudflare AI Gateway, Inception Labs, Llmman, Neosantara, Synthorai, TokenLab, and TrustedRouter. It also introduces a fallback model system that allows agents to automatically switch to alternative models on specific errors like rate limits or context window overflows, and a new compression manager that can compress tool call results to save context space.

libs/agno/agno/models · high confidence

This change introduces a new \agno/utils/models\ package containing provider-specific message formatting utilities for Anthropic (Claude), Cohere, Llama, Mistral, OpenAI Responses, WatsonX, and AI Foundry, alongside a compatibility shim for \google-genai\ versions 2.9.0 and earlier. The \google-genai\ compatibility module (\\_genai\compat.py\) detects the installed SDK version and exposes stable \Delta\\ type aliases so that consumer code can handle streaming deltas without breaking when the library relocates types between \step\_delta\ and the top-level \interactions\ namespace. The provider modules standardize how messages, images, and tool results are serialized for each API, with specific handling for Claude's assistant prefill support, Mistral's tool call ID requirements, and OpenAI's response schema sanitization.

libs/agno/agno/utils/models · high confidence

Agents can now use dedicated toolkits to interact with several external AI services directly. The new AIMLAPITools provide image, video, speech, and transcription capabilities via the AI/ML API. GeminiTools adds image and video generation using Google's Imagen and Veo models (with video restricted to Vertex AI). GroqTools enables audio transcription, translation, and text-to-speech using Groq's Whisper and TTS models. AzureOpenAITools allows image generation via Azure OpenAI's DALL-E deployments. MorphTools provides a code-editing tool that applies changes to local files using Morph's Fast Apply API. NebiusTools offers text-to-image generation via the Nebius Token Factory. Each toolkit is opt-in, allowing agents to be equipped with only the specific media or code capabilities they need.

libs/agno/agno/tools/models · high confidence

The \agno/knowledge/embedder\ directory has been restructured into a dedicated package, introducing a base \Embedder\ class and a suite of new provider-specific implementations. Users can now select from embedders for AWS Bedrock (Cohere v3/v4), Azure OpenAI, Cohere, FastEmbed, Fireworks, Google Gemini (including Vertex AI), Hugging Face, Jina, LangDB, and Mistral. The base module adds robust error handling via \EmbeddingError\, batch embedding support with padding for partial failures, and individual text embedding with failure aggregation to prevent ingestion crashes. Several providers include async support, rate-limit backoff (Cohere), and configurable output dimensions.

libs/agno/agno/knowledge/embedder · high confidence

The knowledge ingestion system has been restructured into a dedicated reader package, introducing a base Reader class and a ReaderFactory to standardize how documents are loaded and chunked. This change adds native support for a wider variety of file formats and sources, including ArXiv papers, Excel spreadsheets (via ExcelReader), and advanced document processing through the Docling integration. Existing readers like CSV, JSON, and DOCX have been refactored to align with this new architecture, ensuring consistent behavior across all ingestion paths.

libs/agno/agno/knowledge/reader · high confidence

The knowledge retrieval pipeline now includes a dedicated reranking layer to improve result relevance and diversity. Users can choose from several reranking strategies: algorithmic options like MMRReranker (for diversity) and RecencyReranker (for time-aware ranking), as well as provider integrations for Amazon Bedrock (supporting Amazon Rerank 1.0 and Cohere Rerank 3.5), Cohere, Infinity, and local SentenceTransformer models. This change introduces a new base Reranker interface and exports these implementations for use in the knowledge system.

libs/agno/agno/knowledge/reranker · high confidence

The cookbook now includes a new \12\_multimodal\ section demonstrating how to build agents that process and generate audio, images, and video. Examples include audio input/output and streaming with OpenAI's \gpt-audio\, image-to-text and image-to-audio workflows, and video captioning using \MoviePyVideoTools\. The directory also provides a test log verifying the examples and a \.gitignore\ to exclude media files.

_cookbook/02\_agents/12\multimodal · high confidence

The \cookbook/observability\ directory now provides ready-to-run examples for instrumenting Agno agents and teams with a wide range of observability backends. The collection includes root integrations for AgentOps, Arize Phoenix (with project routing and local setup), Atla, Confident AI, Langfuse (via OpenInference and OpenLIT), LangSmith, Langtrace, LangWatch, Latitude, Logfire, Maxim (including multi-agent teams), MLflow (via autolog and OpenInference), Opik, The Context Company, Traceloop, and Weave. It also demonstrates Agno's built-in database tracing via \trace\_to\_database.py\ and includes subdirectories for multi-agent team and workflow tracing examples.

cookbook/observability · high confidence

Added a new \cookbook/09\_evals/performance\ directory containing benchmarks to measure agent and team instantiation costs, response latency, and memory growth under various conditions (e.g., with database logging, memory updates, or storage-backed history). The suite also includes a \comparison/\ subdirectory with instantiation benchmarks for external frameworks including AutoGen, CrewAI, LangGraph, OpenAI Agents SDK, PydanticAI, and Smolagents.

_cookbook/09\evals/performance · high confidence

The \cookbook/07\_knowledge/03\_production\ directory now includes a set of story-driven examples for deploying knowledge systems. These cover multi-source RAG ingestion, full content lifecycle management (insert, skip-if-exists, remove, and tracking via a contents database), and multi-tenant data isolation using \isolate\_vector\_search\. It also demonstrates serving agents via AgentOS and robust error-handling patterns for ingestion. Additionally, a new example introduces \allowed\_hosts\ on URL-fetching readers (WebsiteReader, FirecrawlReader, DoclingReader, LLMsTxtReader, WebSearchReader) to restrict outbound requests and prevent Server-Side Request Forgery (SSRF) attacks.

_cookbook/07\_knowledge/03\production · high confidence

The cookbook now includes new examples for reasoning agents and provider-specific models. In the agents section, examples demonstrate DeepSeek-backed reasoning with OpenAI models for tasks like historical analysis, coding guidance, financial reporting, and logical puzzles. Provider-specific examples are added for Anthropic (Claude with extended thinking), Azure AI Foundry (DeepSeek reasoning), Azure OpenAI (GPT-4.1 reasoning, o3-mini with tools), DeepSeek (ethical dilemmas, itinerary planning), Gemini (thinking budget), Groq (model combinations, speed comparisons), and Ollama (local reasoning).

_cookbook/10\reasoning/models · high confidence

The cookbook now includes a new 'reasoning tools' section with examples demonstrating how to use reasoning capabilities across multiple providers. The examples cover Azure OpenAI, OpenAI, Anthropic Claude, Google Gemini, Cerebras, Groq, IBM Watsonx, Meta Llama, Ollama, and Vercel. Each example shows how to integrate reasoning tools with agents, including features like step-by-step thinking, analysis, and few-shot prompting. The cookbook also includes examples for knowledge tools, memory tools, and workflow tools, demonstrating how to combine reasoning with external data sources and multi-agent workflows.

_cookbook/10\reasoning/tools · high confidence

Added two new examples in the reasoning cookbooks demonstrating multi-agent team orchestration: \knowledge\_tool\_team.py\ shows a team using a knowledge base with LanceDB and web search, while \reasoning\_finance\_team.py\ demonstrates a finance-focused team using reasoning tools and web search to analyze market data. Both examples utilize the \gpt-5.6-luna\ model for agents and include structured instructions for data presentation.

_cookbook/10\reasoning/teams · high confidence

The cookbook now includes a new \reliability\ section with examples demonstrating how to validate that agents and teams make expected tool calls. These examples cover single and multiple tool calls, asynchronous evaluation, database logging, and team delegation. The \ReliabilityEval\ class is used to check tool execution, including argument validation and subset matching for additional tool calls.

_cookbook/09\evals/reliability · high confidence

Users can now ingest knowledge from remote sources including AWS S3, Google Cloud Storage, Azure Blob Storage, GitHub repositories, and Microsoft SharePoint. This change introduces a new \agno.knowledge.loaders\ module containing \S3Loader\, \GCSLoader\, \AzureBlobLoader\, \GitHubLoader\, and \SharePointLoader\, along with a shared \BaseLoader\ for common utilities. The loaders support both synchronous and asynchronous ingestion, handle provider-specific authentication (such as SAS tokens for Azure and App tokens for GitHub), and automatically manage metadata merging and content hashing for the knowledge base.

libs/agno/agno/knowledge/loaders · high confidence

Users can now ingest knowledge from remote cloud storage and code repositories by configuring dedicated sources. The new \agno.knowledge.remote\_content\ module introduces configuration classes (\S3Config\, \GcsConfig\, \AzureBlobConfig\, \GitHubConfig\, \SharePointConfig\) and corresponding content types (\S3Content\, \GCSContent\, \AzureBlobContent\, \GitHubContent\, \SharePointContent\). This enables loading files from AWS S3 buckets, Google Cloud Storage buckets, Azure Blob Storage containers (supporting both Service Principal and SAS token authentication), GitHub repositories (supporting Personal Access Tokens and GitHub App authentication), and SharePoint sites. The implementation includes utilities for listing files with pagination and handling specific authentication flows for each provider.

_libs/agno/agno/knowledge/remote\content · high confidence

The \agno/run\ package introduces a comprehensive runtime layer for managing agent, team, and workflow executions. It defines a detailed event stream (\RunEvent\) covering the full lifecycle from start to completion, including intermediate states like tool calls, reasoning steps, and hooks. The module adds structured data models for run inputs (\RunInput\) and requirements (\RunRequirement\), enabling Human-in-the-Loop (HITL) flows such as confirmations, user input, and external execution pauses. It also implements robust cancellation management (\cancel.py\) with support for team-run cascades, atomic status persistence (\status\_persist.py\) to prevent race conditions, and concurrency limiting for background runs to control resource usage.

libs/agno/agno/run · high confidence

The session router now exposes comprehensive REST endpoints for managing sessions, including listing, retrieving, creating, updating, and deleting sessions. This implementation supports filtering by session type (agent, team, workflow), component ID, user ID, and name, along with pagination and sorting options. It also handles media storage cleanup when sessions are deleted and integrates with authentication and user-scoping middleware to ensure data isolation.

libs/agno/agno/os/routers/session · high confidence

The \02\_agents/05\_state\_and\_session\ directory now includes a comprehensive set of examples for managing agent session state and history, covering basic and advanced state patterns, multi-user isolation, manual state updates, state change events, dynamic state via tool hooks, chat history management, session persistence with SQLite and PostgreSQL, limiting context to the last N messages, searching past sessions, and generating session summaries. Additionally, the \02\_agents/13\_reasoning\ directory introduces examples for explicit multi-step reasoning, demonstrating how to configure a separate reasoning model (such as o3-mini) and display full reasoning traces.

_cookbook/02\_agents/05\_state\_and\session · high confidence

The cookbook/06\_storage directory now includes comprehensive examples for persistent session storage using PostgreSQL, session summarization with configurable limits (last\_n\_runs and conversation\_limit), and media offload to local filesystem, S3, and Google Cloud Storage. Users can now see how to configure LocalMediaStorage, S3MediaStorage, and GCSMediaStorage for both agent attachments and generated files, including multi-turn media reuse, workflow integration, and safe deletion with the delete\_media flag. The examples also demonstrate multi-user session handling and custom table selection for SQLite.

_cookbook/06\storage · high confidence

The library now exposes a dedicated set of Pydantic schemas in \agno/api/schemas\ to structure telemetry data sent to the API. These schemas define the payload for creating runs across different entities: \AgentRunCreate\, \TeamRunCreate\, \WorkflowRunCreate\, \EvalRunCreate\, and \OSLaunch\. Each schema automatically includes the SDK version via a cached helper and, where applicable, a specific event type (agent, team, workflow, or eval) to distinguish the telemetry source. This change also includes a rename of the previous \phi/api/schemas/response.py\ to the new \agno\ package location.

libs/agno/agno/api/schemas · high confidence

The \agno/tools\ package now exposes a \hook\ decorator (imported from \agno.hooks\) that allows individual agent or team hooks to be marked with \run\_in\_background=True\, enabling per-hook control over background execution when running with AgentOS. Additionally, the \agno/tools\ location introduces several new toolkits: \AdanosTools\ for retrieving stock and crypto market sentiment, \AdvisorTools\ for allowing agents to ask user-defined advisor models for feedback, \AgentOSTools\ for providing a read-only operations view of the AgentOS platform, \AgentQLTools\ for scraping websites using AgentQL, and \AirflowTools\ for saving and reading Airflow DAG files with path safety checks.

libs/agno/agno/tools · high confidence

The \agno/utils\ package has been introduced to centralize helper logic for the agent and team run lifecycle. This includes \agent.py\, which provides functions to manage async and sync thread tasks for memory and learning extraction during runs, and \events.py\, which contains factories for creating typed run events (such as start, completed, and paused events) for both agents and teams. Additional utilities in this location handle callable factory resolution with caching (\callables.py\), bounded worker execution with capacity limits (\bounded.py\), and strict-load divergence checks for registry copies (\copies.py\).

libs/agno/agno/utils · high confidence

The vector database integration cookbook now includes dedicated examples for Qdrant, local databases (ChromaDB and LanceDB), managed services (Pinecone), PostgreSQL (PgVector), and ScyllaDB. These new scripts demonstrate how to configure the Knowledge object with various vector stores, supporting basic vector search, hybrid search, and reranking capabilities to help users integrate their preferred database infrastructure.

_cookbook/07\_knowledge/05\_integrations/vector\dbs · high confidence

Added runnable cookbook examples in cookbook/04\_workflows/01\_basic\_workflows demonstrating three workflow composition patterns: sequence of steps (including nested steps, file inputs, and session metrics), custom step executors using functions and classes with sync/async/streaming support, and function-based workflows that replace explicit step lists with custom execution functions. All examples use the gpt-5.6-luna model and include README and test-log scaffolding.

_cookbook/04\workflows · high confidence

Added a new set of cookbook examples in \cookbook/93\_components/workflows\ demonstrating how to save and load workflows containing advanced step types (Condition, Loop, Router, Parallel, and custom executors) using the \Registry\ for restoring functions and agents. The collection also includes specific examples for Human-in-the-Loop (HITL) configurations, showing how to persist and restore step-level confirmation prompts and structured user input schemas across save/load cycles.

_cookbook/93\components/workflows · high confidence

The xAI provider is now available, introducing two new model classes: \xAI\ for standard chat completions and \xAIResponses\ for the Responses API. The \xAI\ class supports live search via \search\_parameters\ and parses URL citations from responses. The \xAIResponses\ class adds support for SuperGrok OAuth authentication (device-code sign-in with token caching and refresh) alongside traditional API key access, and enables encrypted reasoning content replay. Both classes default to the \grok-4-1-fast-non-reasoning-latest\ model.

libs/agno/agno/models/xai · high confidence

The AgentOS cookbook has been restructured into a new set of lessons (01\_getting\_started, 02\_databases, 03\_python\_client) that demonstrate core capabilities such as mounting agents, teams, and workflows; configuring database backends (SQLite, Postgres, SurrealDB) and external media storage (S3, GCS); and using the Python client for discovery, runs, sessions, knowledge, and evaluations. Each lesson includes a README, a live test log verifying the examples, and the corresponding Python scripts.

_cookbook/05\_agent\os · high confidence

The Docker and AWS application templates for Django, FastAPI, Jupyter, Qdrant, Streamlit, MySQL, Postgres, Redis, Airflow, and Superset have been removed from the codebase. This change eliminates the ability to provision these specific services via the \phi/docker\ and \phi/aws/app\ modules, requiring users to manage these infrastructure components through alternative means.

phi/docker · high confidence

The \phi/k8s\ module has removed the built-in Kubernetes application definitions for Airflow, FastAPI, Jupyter, Postgres, PgVector, Redis, Streamlit, Superset, and Traefik. This includes the deletion of the base \K8sApp\ class and all associated component implementations (such as web servers, schedulers, and workers), meaning users can no longer deploy these specific applications via the \phi.k8s.app\ package.

phi/k8s · high confidence

The \phi/agent\ module has been completely removed, deleting the base \Agent\ class and all specialized agent implementations (including \AirflowAgent\, \ArxivAgent\, \DuckDbAgent\, \FileAgent\, \GoogleAgent\, \PhiAgent\, \PubMedAgent\, \PythonAgent\, \ShellAgent\, \WebsiteAgent\, and \WikipediaAgent\). Additionally, the CLI-driven \PhiAI\ conversation interface and its supporting API client modules (\phi/ai/operator.py\, \phi/ai/phi\_ai.py\, \phi/api/ai.py\, \phi/api/api.py\, \phi/api/conversation.py\, \phi/api/llm.py\) have been deleted, indicating a significant architectural shift away from the previous agent and CLI chat architecture.

phi · high confidence

The \agno.agent\ package has been reorganized from a single monolithic file into a set of specialized modules (\\_cli\, \\_default\_tools\, \\_hooks\, \\_init\, \\_managers\, \\_messages\, \\_response\, \\run\). This change improves code maintainability and separation of concerns by isolating CLI printing logic, default tool creation, pre/post hook execution, agent initialization, background memory management, message formatting, response processing, and the core run loop into their own files, while the \\\init\\_.py\ now serves as a clean public API surface.

libs/agno/agno/agent · high confidence

The \agno.team\ package has been refactored from a single monolithic file into a set of specialized internal modules (\\_cli\, \\_default\_tools\, \\_hooks\, \\_init\, \\_managers\, \\_messages\, \\_response\, \\run\). This change improves code organization and maintainability without altering the public API, as the \\\init\\_.py\ file continues to export the same \Team\, \RemoteTeam\, \Task\, and event classes for user consumption.

libs/agno/agno/team · high confidence

The \agno.tools.file\ and \agno.tools.knowledge\ modules have been refactored into sub-packages (\file\, \file/file\, \file/generation\, \knowledge\, \knowledge/management\) to improve organization and performance. This change introduces PEP 562-style lazy loading for these toolkits, meaning optional dependencies like \reportlab\ (for PDF generation) and \python-docx\ (for DOCX generation) are no longer imported at startup; they are only loaded when the specific generation tools are actually accessed. For users, this reduces startup overhead and prevents import errors if optional libraries are missing, while the functional behavior of file reading/writing and knowledge search/management remains unchanged.

libs/agno/agno/tools/file, libs/agno/agno/tools/knowledge · high confidence

The FileSystem cookbook has been renumbered and restructured into five distinct sections: Getting Started, Durable Records, Working State, Namespaces, and Operations. A key behavioral change is that \fs.tools()\ no longer automatically injects instructions into the system prompt; users must now explicitly pass \fs.instructions()\ (or \fs.instructions(read\_only=True)\ for read-only access) in the agent's instructions list. This ensures that file system conventions and constraints are clearly defined by the developer. The cookbook now includes examples for per-user isolation via namespaces, custom factory functions for dynamic namespace resolution, shared read-only namespaces, and operational scripts for inspecting and recovering from quota limits.

_cookbook/13\filesystem · high confidence

This change adds a new \MigrationManager\ class and a suite of versioned migration scripts (v2.0.0 through v3.0.0) to the \agno/db/migrations\ package, along with a comprehensive v3.0 migration guide. The v3.0 migration normalizes session runs by moving them from a single JSON blob in the \agno\_sessions\ table into a dedicated \agno\_runs\ table (one row per run), which eliminates write amplification and unbounded row sizes for long-lived sessions. The migration is non-destructive, preserving the legacy \runs\ column as a safety net until manually cleaned up, and supports lazy migration where active sessions self-migrate on their first save. Additionally, the v3.0 migration adds \user\_id\ columns and indexes to tables like \evals\, \components\, \knowledge\, \schedules\, \schedule\_runs\, and \metrics\ to support per-user isolation, and re-keys entity memory learnings to their owner's key. The package also includes migrations for v2.3.0 (adding \created\_at\/\feedback\ to memories, JSONB conversion for Postgres) and v2.5.0 (adding primary key constraints on \session\_id\ for SQL backends).

libs/agno/agno/db/migrations · high confidence

A new base interface class has been added to define the contract for all agent, team, and workflow interfaces. This change introduces support for custom route prefixes, allowing interfaces to mount their endpoints under specific paths. It also adds a \get\_scope\_mappings\ method to the base class, enabling interfaces to define Role-Based Access Control (RBAC) requirements for their routes. Interfaces that handle their own authentication (like Slack or Telegram) can now explicitly opt out of the global auth middleware via the \authenticates\_own\_requests\ flag, while others must provide scope mappings to ensure their routes are properly authorization-gated.

libs/agno/agno/os/interfaces · high confidence

The MCP integration has been updated to support the newer Streamable HTTP transport alongside the existing SSE transport, allowing users to connect to MCP servers using the more modern protocol. This change introduces new configuration classes, \SSEClientParams\ and \StreamableHTTPClientParams\, which expose granular control over connection settings such as \timeout\, \sse\_read\_timeout\, and \headers\ for authentication. The implementation relies on the \fastmcp\ library (v4.x) and the \mcp\ SDK (v2.x), ensuring compatibility with the latest MCP standards while maintaining backward compatibility for SSE-based connections.

libs/agno/agno/tools/mcp · high confidence

The SQLite database adapter has been rewritten from scratch to use SQLAlchemy, introducing a new \AsyncSqliteDb\ class for asynchronous operations alongside the synchronous \SqliteDb\. This change brings improved schema management, automatic foreign key enforcement, and Write-Ahead Logging (WAL) mode for better concurrency. Users benefit from more robust session handling, support for larger tables via optimized migration scripts, and consistent behavior across sync and async contexts.

libs/agno/agno/db/sqlite · high confidence

This change introduces a new, dedicated router module for workflows (located at \libs/agno/agno/os/routers/workflows/\), replacing or refactoring the previous inline route definitions. It adds a \WorkflowResponse\ schema that enriches workflow metadata with \is\_component\, \current\_version\, and \stage\ fields, and ensures that GET endpoints correctly resolve and return nested agents, teams, and conditional \else\_steps\ in the response. It also standardizes WebSocket event streaming by introducing a tail-pump mechanism that forwards events from the event stream to connected sockets, supporting reconnection and ensuring consistent wire formats for both durable and non-durable runs.

libs/agno/agno/os/routers/workflows · high confidence

The cookbook now includes a new \09\_evals\ directory with runnable examples for accuracy, agent-as-judge, performance, and reliability evaluations, accompanied by a test log verifying execution against the \agno 3.0.0a2\ runtime. In \91\_tools\, numerous new tool integrations are demonstrated, including Adanos market sentiment, AgentQL scraping, Airflow DAG management, Antigravity sandbox agents, Apify web actors, and ArXiv paper search. Several existing tool examples were updated or added, such as \FileGenerationTools\ with code file generation, \FileTools\ with \exclude\_patterns\ and directory-scoped listing, and \TavilyTools\ with advanced search parameters. The entry also reflects behavioral fixes applied to the cookbook examples: \Smallest AI\ audio tools now use Gemini to support audio input, and \async\ generator tools with Pydantic arguments now correctly receive model instances instead of raw dictionaries.

_cookbook/91\tools · high confidence

Users upgrading from Agno v2 to v3 now have dedicated migration tools to handle database schema changes, specifically the introduction of per-user RAG isolation. The \MigrationManager\ class allows programmatic upgrades to specific versions, while new scripts in \v2\_to\_v3/\ enable manual migration of vector databases (PgVector, SingleStore, Milvus, LanceDB, ClickHouse, SurrealDB, Redis, Couchbase, and Cassandra) to include the required \user\_id\ fields and shared-sentinel backfills. Additionally, legacy v1-to-v2 migration scripts remain available for users on older versions.

libs/agno/migrations · high confidence

The PineconeDB vector database implementation now checks the installed version of the \pinecone\ Python package at startup. If version 6.x or higher is detected, the system raises a warning recommending users downgrade to v5.4.2 and then halts execution with a \RuntimeError\. This prevents compatibility issues with the newer Pinecone SDK until support is added.

libs/agno/agno/vectordb/pineconedb · high confidence

The quickstart cookbook has been completely restructured into a capability ladder, now using Gemini 3.6 Flash as the default model for all examples. The guide now covers a comprehensive set of agent features including tools, structured output, conversation storage, user memory, state management, searchable knowledge, shared learning, guardrails, human-in-the-loop approval, multi-agent teams, and sequential workflows. It also introduces a new section for running the complete system in AgentOS, providing a unified runtime and chat interface for inspecting sessions, traces, and knowledge.

_cookbook/00\quickstart · high confidence

The repository has migrated from the Phidata framework to Agno, replacing the old \scripts/\ suite with a new set of setup and maintenance scripts. Legacy scripts for Phidata installation, release, and upgrade have been removed. New scripts now provide dedicated environments for development (\dev\_setup\), demos (\demo\_setup\), performance benchmarks (\perf\_setup\), and testing (\test\_setup\), all using \uv\ and Python 3.12. Additionally, \format.sh\ and \validate.sh\ have been rewritten to run \ruff\ and \mypy\ specifically for the \agno\, \agnoctl\, \agno\_infra\, and \cookbook\ directories, ensuring code quality for the new Agno libraries.

scripts · high confidence

The project has officially rebranded from Phidata to Agno, reflected in the updated README, LICENSE, and CONTRIBUTING documentation. To support AI-assisted development, the repository now includes a comprehensive \.cursorrules\ file defining coding patterns (such as agent reuse and structured outputs) and a \CLAUDE.md\ file outlining repository structure and workflow instructions, with \AGENTS.md\ symlinked to it. The legacy \setup.py\ file has been removed, and \.gitignore\ has been expanded to exclude new virtual environments, AI-specific directories (\.claude\, \.cursor\), and private symlinked assets.

(repo-wide) · high confidence

The Google toolkits (Gmail, Calendar, Drive, Sheets, BigQuery, Maps, Slides) now share a centralized authentication system via the new \AuthConfig\ and \GoogleAuth\ classes. This allows credentials and OAuth tokens to be shared across multiple Google services, with optional encrypted token storage in a database. A new \google\_authenticate\ decorator handles automatic credential resolution and service initialization, while the toolkit module uses lazy loading to improve import performance.

libs/agno/agno/tools/google · high confidence

The vector database module now includes a new base \VectorDb\ class that standardizes similarity filtering via a \similarity\_threshold\ parameter and deprecates setting rerankers directly on the database in favor of passing them to the Knowledge layer. The update also introduces a \Distance\ enum for metric types (cosine, l2, max\_inner\_product), a \SearchType\ enum for vector/keyword/hybrid searches, and a \score\ module with utilities to normalize and convert between distance metrics and similarity scores.

libs/agno/agno/vectordb · high confidence

Added IBM Watson X integration tests with rate-limit protection; Added integration and unit tests for xAI OAuth, agent/team offloading, and media storage; Added integration test suite for Agno workflows; Added integration test suite for agent sessions, storage, and AgentOS; Added integration tests for AWS Bedrock models; Added integration tests for AgentOS A2A and AG-UI interfaces; Added integration tests for AgentOS authorization, A2A/AGUI security, and core workflows; Added integration tests for AsyncMongoDb; Added integration tests for ClickHouse trace storage; Added integration tests for Cohere model support; Added integration tests for DeepSeek and SambaNova models; Added integration tests for Human-in-the-Loop agent flows; Added integration tests for LM Studio model support; Added integration tests for Memory and Session Summary managers; Added integration tests for Valkey, LanceDB, and Couchbase vector databases; Added integration tests for agentic knowledge filtering; Added integration tests for code execution, tool context injection, and media generation; Added integration tests for team human-in-the-loop flows; Added integration tests for the Mistral model provider; Added integration tests for the Postgres database adapter; Added integration tests for the Vercel model; Added integration tests for the new CometAPI model provider; Added rate-limit protection for Meta model integration tests; Added test fixtures for knowledge filtering and JSON ingestion; Added test package initialization for Agno; Added tests for LlamaOpenAI message formatting and compression forwarding; Added tests for PIIDetectionGuardrail custom pattern handling; Added unit tests for AG-UI interface components; Added unit tests for AIMLAPI model defaults and attribution headers; Added unit tests for AWS Bedrock and Claude client authentication, streaming, and concurrency; Added unit tests for AgentOS component and Slack routers; Added unit tests for AgentOS core behaviors; Added unit tests for Anthropic model message formatting and behavior; Added unit tests for AntigravityAgent and external agent persistence; Added unit tests for Azure OpenAI Responses and Azure AI Foundry Claude models; Added unit tests for DeepSeek model configuration and thinking mode behavior; Added unit tests for Discord client and Memori integration; Added unit tests for Google Gemini models; Added unit tests for LiteLLM model metrics, client persistence, and structured output handling; Added unit tests for OS interfaces (A2A, AG-UI, Slack, WhatsApp); Added unit tests for OpenAI model behavior and integration; Added unit tests for OpenRouter and Ollama Responses API features; Added unit tests for Perplexity streaming metrics collection; Added unit tests for Team background execution, streaming, and session caching; Added unit tests for agent run, configuration, and tooling; Added unit tests for compression, audio, Claude, encryption, functions, Gemini, JSON schema, and location utilities; Added unit tests for context providers and backends; Added unit tests for database layer components; Added unit tests for environments, evals, and utilities; Added unit tests for fallback models, advanced filtering, and Python 3.9 compatibility; Added unit tests for knowledge chunking strategies and URL ingestion behavior; Added unit tests for knowledge ingestion, embedding, and file reading; Added unit tests for knowledge readers; Added unit tests for memory manager identity, CRUD, async support, and optimization; Added unit tests for model provider request parameters and error handling; Added unit tests for multiple toolkits; Added unit tests for reasoning model detection and streaming; Added unit tests for run approval, concurrency, cancellation, and queue store logic; Added unit tests for telemetry across agents, teams, workflows, and evaluations; Added unit tests for the A2A client; Added unit tests for the Inception Labs model integration; Added unit tests for the Llmman model provider; Added unit tests for the Registry component and tool source palette logic; Added unit tests for the TrustedRouter model class; Added unit tests for the Xiaomi MiMo model provider; Added unit tests for the Y-API model provider; Added unit tests for the durable agent filesystem; Added unit tests for the learnings subsystem; Added unit tests for the scheduler subsystem; Added unit tests for the scoring module; Added unit tests for vector database adapters; Added unit tests for workflow execution, serialization, and human-in-the-loop behavior; Expanded integration test coverage for agent execution and persistence; Integration test coverage for SQLite database operations; Integration test suite for Anthropic Claude model; Integration test suite for Google Gemini models; Integration test suite for LiteLLM model support; Integration test suite for Team features; Integration test suite for embedders and rerankers; Integration tests added for SurrealDB storage backend; Integration tests for AsyncMySQLDb; Integration tests for AsyncPostgresDb database operations; Integration tests for DashScope models; Integration tests for DbFileSystem concurrency and semantics; Integration tests for LangDB model support; Integration tests for Meta Llama OpenAI model; Integration tests for OpenAI Responses API; Integration tests for OpenAI chat model capabilities; Integration tests for Portkey model provider; Integration tests for Valkey database support; Integration tests for Vertex AI Claude model; Integration tests for session history and sharing; Integration tests now skip on provider rate limits; New AgentOS system test infrastructure with multi-container Docker environment; New integration tests for database backends and job queues; New integration tests for knowledge ingestion and retrieval; Removal of test scaffolding files; System tests for AgentOS gateway and remote interfaces; Unit tests added for model provider toolkits; Unit tests added for the Skills module.

The repository has moved from a single \pyproject.toml\ (Phidata 2.0.59) to a multi-package structure under \libs/\, introducing \agno\ (3.0.11), \agnoctl\ (0.2.1), and \agno-infra\ (1.1.1) with their own dependency definitions. The old root \requirements.txt\ was removed and replaced by generated \requirements.txt\ files for the \agno\ library, its system tests, and several cookbooks (quickstart, demo, learning, image\_search, gemini\_3, mcp\_toolbox\_demo). Key dependency updates visible in the new manifests include \httpx\ pinned to 0.28.1, \h11\ to 0.16.0, \pydantic\ to 2.13.4, and \mcp\ to 1.12.2/1.25.0/1.27.2 depending on the cookbook, alongside the addition of \agnoctl\>=0.2.0\ and \fastmcp\>=4.0.0\ for MCP support.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 49.

• Code Health 75
• Architecture 99
• Maturity 59
• Readiness 35
• Security 62
• Domain Modelling 100
• Accessibility 53

• 300 commits — 143 feature/other, 157 fixes

• libs/agno — 215 commits
• cookbook/91_tools — 15 commits
• cookbook/90_models — 11 commits
• (root) — 10 commits
• cookbook/05_agent_os — 9 commits
• cookbook/data_labeling — 7 commits
• cookbook/07_knowledge — 5 commits
• .github/workflows — 4 commits
• cookbook/03_teams — 4 commits
• libs/agnoctl — 3 commits
• cookbook/02_agents — 2 commits
• cookbook/10_reasoning — 2 commits
• cookbook/13_filesystem — 2 commits
• cookbook/environments — 2 commits
• cookbook/observability — 2 commits
• cookbook/00_quickstart — 1 commit
• cookbook/04_workflows — 1 commit
• cookbook/08_learning — 1 commit
• cookbook/11_memory — 1 commit
• cookbook/filesystem — 1 commit

• fix: [fix] AIMLAPI: repair broken integration, add revenue attribution headers (#9898)
• fix: [fix] Accept text streams in FieldLabeledCSVReader (#10020)
• fix: [fix] Accept text streams in TextReader (#10203)
• fix: [fix] Await async chunking in JSONReader (#10167)
• fix: [fix] Build GithubTools branch links from repository web URL (#10509)
• fix: [fix] Cache Pydantic version lookup during tool wrapping (#9210)
• fix: [fix] Clarify Adanos trending ranking (#9061)
• fix: [fix] Cohere: stop dropping zero-valued sampling params (#9300)
• fix: [fix] Continue sitemap discovery after invalid gzip data (#10213)
• fix: [fix] Correct duplicated word in V3 migration guide (#10315)
• fix: [fix] Escape CSV delimiters in DuckDbTools (#10415)
• fix: [fix] Forward Tavily extract options (#10403)
• fix: [fix] GithubTools.get_file_content: preserve valid non-ASCII UTF-8 text (#10480)
• fix: [fix] Honor explicit zero row limits in CsvTools (#10492)
• fix: [fix] Honor explicit zero tail in shell and workspace command tools (#10593)
• fix: [fix] Ignore unmatched closing braces when extracting JSON objects (#10421)
• fix: [fix] Nest Gemini tool-result media in function responses (#9647)
• fix: [fix] Paginate MCP tool discovery for ClientSession (#10012)
• fix: [fix] Preserve MCP AudioContent as audio artifacts (#10036)
• fix: [fix] Preserve empty Anthropic tool arguments (#8970)
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

agno-agi/agno was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.