Skip to content
CAI
Software that uses CAICheck a score

agno-agi/agno

51.0

Adequate · 14 November 2026

654.6k

lines of production code

Python

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add AI/ML API integration with partner attribution headers

Introduces a new AI/ML API model integration that automatically attaches analytics and partner attribution headers (HTTP-Referer, X-Title, X-AIMLAPI-Partner-ID, X-AIMLAPI-Source) to all requests, enabling traffic attribution to the Agno partner without affecting routing, model selection, or billing.

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

Add Antigravity (Gemini Agents API) cookbook examples

Added a new cookbook section for integrating Google's Gemini Agents API (Antigravity) with Agno. This includes examples for using the \AntigravityAgent\ as an external agent, managing multi-turn sessions with SQLite persistence, pre-loading sandbox sources (inline, GCS, Git), downloading environment snapshots, and defining custom agents via local directories (\agent.yaml\ + \AGENTS.md\).

cookbook/frameworks/antigravity · high confidence

Add DeepInfra model support

Users can now use the DeepInfra model provider by importing the DeepInfra class from agno.models.deepinfra. This change exposes the DeepInfra implementation, which supports reasoning capabilities for OpenAILike deepseek models, making it available for use in agent configurations.

(repo-wide) · high confidence

Add DynamoDB storage backend for sessions, memory, and traces

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

Add Elasticsearch vector database integration

Users can now use Elasticsearch as a vector database backend for storing and searching embeddings. This new integration supports dense vector similarity search (cosine, l2\_norm, dot\_product, max\_inner\_product), keyword search, and hybrid search (using boost or RRF strategies). It includes both synchronous and asynchronous operations, bulk document management, advanced filtering, and per-user isolation via a user\_id field. The implementation requires the \elasticsearch\ Python package and expects the client major version to match the cluster version.

(repo-wide) · high confidence

Add Gemini 3 progressive cookbook with multimodal and agentic examples

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 use the HyDE (Hypothetical Document Embeddings) query transformer to improve search relevance. This new component asks an LLM to generate a plausible answer passage for a given query, which is then used for retrieval instead of the original question. The transformer includes configuration options to set a custom model (defaulting to OpenAI's gpt-5.4), customize the generation prompt, limit the output length, and optionally include the original query in the search context. It handles failures gracefully by falling back to the original query if the LLM call fails.

_libs/agno/agno/knowledge/query\transformer · high confidence

Add IBM Watson X model integration

Users can now access the IBM Watson X model through the Agno library. The new \agno/models/ibm/\_\init\\_.py\ file exposes the \WatsonX\ class, allowing for direct instantiation and usage of this model provider within the framework.

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

Add LangChain vector database integration

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

Add LlamaCpp model integration

The LlamaCpp model provider is now available for use within the Agno library. Users can import and utilize the LlamaCpp class to interact with models supported by the llama-cpp-python backend.

_libs/agno/agno/models/llama\cpp · high confidence

Add MySQL and AsyncMySQL database backends

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

Add OpenAI Responses API support and new type definitions

Users can now utilize the OpenAI Responses API via the new \OpenAIResponses\ and \OpenResponses\ model classes. This change introduces specific type definitions for request parameters including \ReasoningEffort\, \ReasoningSummary\, \ServiceTier\, and \Verbosity\, enabling more granular control over model behavior and response formatting. The \\_\init\\_.py\ file has been updated to export these new classes and types, making them available for import.

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

Add OpenRouter Responses API support

Users can now interact with OpenRouter models using the OpenAI Responses API via the new \OpenRouterResponses\ class. This addition enables access to OpenRouter's unified interface for features like tools, reasoning, and streaming, while automatically handling fallback model routing and preventing empty reasoning blocks for non-reasoning models.

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

Add OpenSearch vector database support

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/opensearch · high confidence

Add OpenTelemetry-based tracing with database storage

Users can now enable automatic tracing for Agno agents, teams, and workflows using OpenTelemetry. The new \agno.tracing\ module provides a \setup\_tracing\ function that configures the tracer provider and instruments Agno components, while a custom \DatabaseSpanExporter\ writes the resulting trace and span data directly to the configured database (supporting both synchronous and asynchronous database backends).

libs/agno/agno/tracing · high confidence

Add Portkey model integration

The library now exposes the Portkey model provider, allowing users to interact with models routed through Portkey. This change introduces the \Portkey\ class and makes it available for import from \agno.models.portkey\.

(repo-wide) · high confidence

Add Redis as a supported Vector Database

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

Add Requesty model provider integration

A new Requesty model provider has been added to the library, exposing the Requesty class for use in applications. This allows users to interact with the Requesty API through the standard model interface.

libs/agno/agno/models/requesty · high confidence

Add Siliconflow model provider

Users can now access the Siliconflow model provider through the agno library. This change introduces the Siliconflow class, making it available for integration into applications requiring this specific model service.

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

Add SurrealDB as a Vector Database provider

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

Add SurrealDB database backend

Users can now persist sessions, runs, memories, metrics, evaluations, knowledge, and traces using SurrealDB. This new backend provides full read/write support for all core data types, including session serialization/deserialization, metric calculation, and trace storage, accessible via the \agno.db.surrealdb\ module.

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

Add Upstash Vector database integration

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

Add Valkey as a vector database backend

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

Add knowledge cookbook with RAG examples and test logs

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

Add reasoning support for Gemini, Anthropic, and VertexAI Claude models

The reasoning module now includes dedicated support for Gemini, Anthropic, and VertexAI Claude models. This enables users to leverage the reasoning capabilities of these providers within the Agno framework.

libs/agno/agno/reasoning · high confidence

Add support for N1N AI model provider

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

Add support for Ollama's OpenAI-compatible Responses API

Users can now interact with Ollama models using the OpenAI Responses API format via the new \OllamaResponses\ class. This feature requires Ollama v0.13.3 or later and leverages the \/v1/responses\ endpoint. The implementation is stateless, meaning it does not support conversation chaining or \previous\_response\_id\. It supports both local Ollama instances (defaulting to \http://localhost:11434\) and Ollama Cloud (via the \OLLAMA\_API\_KEY\ environment variable).

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

Added Vertex AI model support

The library now includes a new module for Google Cloud Vertex AI models, allowing users to integrate and interact with Vertex AI services. This change introduces the foundational structure for this integration within the models package.

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

Added cookbook helper and database launch scripts

The cookbook now includes a set of utility scripts to simplify development and testing. A new \scripts/\ directory provides \format.sh\ and \format.bat\ to run ruff formatting and import sorting, as well as \validate.sh\ and \validate.bat\ to check code quality with ruff and mypy. Additionally, convenience scripts (\run\\<db\>.sh\ and \run\\<db\>.bat\) are added to launch local Docker containers for supported databases, including Cassandra, ClickHouse, Couchbase, Elasticsearch, MongoDB, MySQL, OpenSearch, PgVector, Qdrant, Redis, SingleStore, SurrealDB, Valkey, and Weaviate.

cookbook/scripts · high confidence

Added development and release automation scripts for Agno

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

Added sample documents for knowledge cookbook testing

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

Added workflow HITL utility module for pause and resume logic

A new \agno.workflow.utils\ package has been introduced, containing a \hitl.py\ module that centralizes Human-in-the-Loop (HITL) execution utilities. This module provides functions to manage workflow pauses for user confirmation, input collection, and route selection, along with helpers to create corresponding pause events for streaming responses. It also includes logic to handle legacy HITL configuration keys, ensuring backward compatibility by dropping deprecated flat keys in favor of the unified \HumanReview\ dataclass structure.

libs/agno/agno/workflow/utils · high confidence

Admin-only API for durable job queue management

A new admin-only API surface at /queue has been added to expose the durable job queue for operational oversight. This allows administrators to list jobs with filtering by status, session, and user, retrieve individual job details, and requeue failed or cancelled jobs. The endpoints enforce strict admin scope requirements to protect cross-tenant data and execution budgets, returning a 503 error if the queue worker is not active on the current replica.

_libs/agno/agno/os/routers/job\queue · high confidence

Advanced knowledge cookbook: custom retrieval, chunking, graph RAG, and per-user isolation demos

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

Archive of knowledge processing and retrieval cookbooks

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

Async PostgreSQL database support

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

Attachment staging safety cookbook added

Added a new cookbook demonstrating attachment staging safety guarantees, including rollback on staging failure, workspace isolation for session replicas, cleanup of harness output, and refusal of symlinked upload directories.

_cookbook/frameworks/attachment\safety · high confidence

Cookbook example for dynamic MCP request headers

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

Cookbook examples for agent skills and team integration

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

Cookbook models directory restructured with new provider examples and documentation

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

Cookbook: Result Offloading for Large Tool Outputs

This location introduces a new cookbook demonstrating how to offload large tool results to prevent context bloat. The examples show enabling \offload\_tool\_results\ on an agent to replace large payloads with a small envelope, using \ResultStore\ to configure storage thresholds, previews, and TTLs, and retrieving data via \read\_result\ and \search\_result\ tools. It covers storing payloads in SQLite or PostgreSQL, writing them to local disk, and ensuring session deletion cascades to remove associated index rows and payloads.

_cookbook/02\_agents/22\_result\offloading · high confidence

Docker sandbox cookbook documentation and test logs

Added README.md and TEST\_LOG.md for the Docker sandbox provider, documenting the end-to-end usage of DockerSandbox including warm reuse via pause/resume, checkpoint storage in S3 and Postgres, runtime transport options (exec vs HTTP long-poll), security boundaries, and session recovery. The test log records the validation status of the associated cookbooks and unit/integration tests.

cookbook/frameworks/sandbox/docker · high confidence

Expanded context provider cookbook with new backends and multi-provider workflows

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

Expanded model provider support and fallback configuration

The model registry now includes new providers such as Cloudflare AI Gateway, FlexAI, Heabsy, Inception Labs, Llmman, MiniMax, Moonshot, Neosantara, Synthorai, TokenLab, TrustedRouter, Xiaomi MiMo, and Y-API, making them available for use in agents. Additionally, a new fallback mechanism allows agents to automatically switch to alternative models when the primary model encounters errors, rate limits, or context window exceedances, improving reliability during high-load or error-prone scenarios.

libs/agno/agno/models · high confidence

Expose Anthropic Claude model and SystemPromptBlock in agno.models.anthropic

The agno.models.anthropic package now explicitly exports the Claude model class and the SystemPromptBlock component, making them directly importable from this module. This change establishes the public API surface for interacting with Anthropic's Claude models within the Agno library.

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

Initial release of Agno Infra library

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

Initial support for ClickHouse as a vector database

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

Introduce A2A interface for exposing Agents, Teams, and Workflows

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

Introduce AgentOS as a standalone, configurable application framework

The AgentOS module is now available as a distinct, configurable application layer. This change introduces the \AgentOS\ class and a comprehensive configuration system (\AgentOSConfig\, \MCPConfig\, \AuthorizationConfig\, etc.) that allows users to define and manage agents, teams, and workflows as a unified service. It includes built-in support for MCP server configuration, OAuth and JWT authentication, WebSocket and SSE event streaming, and job queue coordination. The module also provides utilities for managing run checkpoints, session state, and background lifecycle tasks, effectively replacing the previous ad-hoc setup with a structured, extensible application entry point.

libs/agno/agno/os · high confidence

Introduce AntigravityAgent for Google Gemini Agents API

Added a new \AntigravityAgent\ class that acts as an adapter for Google's Gemini Agents API (Antigravity). This allows users to run full agent loops server-side in a sandboxed Linux environment, with state persistence across turns via environment IDs. The agent supports custom agent definitions, source seeding from local directories (YAML, skills, workspace), and environment snapshot downloads, integrating seamlessly with AgentOS endpoints or standalone usage.

libs/agno/agno/agents/antigravity · high confidence

Introduce Cassandra as a vector database backend

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

Introduce ChromaDB vector database integration with hybrid search and per-user scoping

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

Introduce ClaudeAgent for external agent integration

This change adds the \ClaudeAgent\ class and its supporting \AgnoSessionStore\ to the \agno.agents.claude\ module, enabling users to run Claude Code as an external agent within the Agno framework. The agent wraps the \claude-agent-sdk\ to provide features such as tool execution, permission modes, budget/turn limits, and transcript persistence via the Agno database, allowing Claude Code to be used either standalone or deployed via AgentOS.

libs/agno/agno/agents/claude · high confidence

Introduce CodeMode: persistent per-session Python kernel toolkit

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

Introduce Codex agent with configurable thread and turn options

Users can now interact with the Codex external agent via the new \CodexAgent\ class. This addition includes \ThreadOptions\ and \TurnOptions\ TypedDicts, allowing users to configure specific parameters for thread creation/resumption (such as \approval\_mode\, \sandbox\, and \model\) and individual turns (such as \effort\ and \output\_schema\), providing granular control over the agent's behavior and environment.

libs/agno/agno/agents/codex · high confidence

Introduce CodingTools cookbook with secure shell execution defaults

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

Introduce Company automation framework for Products, Routines, and Tasks

This change introduces a new Company automation framework, exposing \Product\, \Routine\, and \Source\ declarations and a \CompanyManager\ to orchestrate them. Users can now define Products with associated Routines (scheduled tasks) and Sources, which are bootstrapped into the system via a rehydration process that preserves existing data. The framework includes a dedicated \Company Manager\ agent to plan work, a decision log for tracking significant choices, and an automated execution engine that runs Tasks using sandboxed agents. It also features a refresh mechanism to archive old terminal work, propose project completions, and manage automation history retention. Also in this area: 13 commits (6 fixes) modifying libs/agno.

libs/agno/agno/company · medium confidence · unverified

Introduce Components API router for managing agent and team components

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

Introduce Firestore as a database backend

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/redis · high confidence

Introduce Firestore database backend

Added a new \FirestoreDb\ implementation for the \agno\ database layer, enabling users to store sessions, runs, memories, metrics, evaluations, knowledge, and traces in Google Cloud Firestore. The change includes the main driver class, schema definitions with required composite indexes, and utility functions for pagination, sorting, and metrics calculation.

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

Introduce Milvus vector database integration with hybrid search support

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

Introduce MongoDB Vector Database integration

Adds a new MongoDB vector database implementation, enabling users to store and search vector embeddings using MongoDB collections. The integration supports both synchronous and asynchronous operations, includes hybrid search capabilities with configurable vector and keyword weights, and provides compatibility with Azure Cosmos DB for MongoDB vCore. It also handles Atlas Search index creation automatically and exposes a \MongoVectorDb\ alias for convenience.

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

Introduce PgVector database integration with advanced search and indexing options

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

Introduce Skills system for loading and executing agent capabilities

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

Introduce Weaviate vector database integration with async support

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

Introduce agnoctl CLI for AgentOS onboarding and MCP client configuration

The new agnoctl library provides a CLI tool to streamline setting up AgentOS projects and connecting them to coding agents. The \agno create\ command scaffolds new projects from nine maintained starters (Docker, AWS, Azure, Fly, GCP, Helm, Modal, Railway, and Render) and handles initial environment setup. Additionally, the \agno connect\ command automates the configuration of MCP server entries for supported coding agents—including Claude Code, Claude Desktop, Codex, and Cursor—by discovering the AgentOS instance, minting service account tokens, and writing the necessary configuration files to the respective client environments.

libs/agnoctl · high confidence

Introduce agnoctl CLI for managing coding-agent MCP connections

The new agnoctl tool allows users to connect coding agents (such as Claude Code, Codex, and Cursor) to an AgentOS instance by automatically detecting the server, discovering its capabilities (including OAuth protection), and writing the necessary MCP server configuration to the agent's local config files. It handles secure, atomic writes to prevent data corruption or permission leaks, verifies the connection by listing available tools, and supports service account authentication.

agnoctl · high confidence

Introduce bounded, read-only page filesystem and search tools

A new read-only page filesystem and search capability is available for Knowledge sources, allowing agents to browse, read, and search published documentation pages using a safe, bounded command grammar (ls, tree, find, cat, head, tail, wc, rg/grep) and a dedicated page search tool. The implementation enforces strict resource limits (output size, pattern length, regex timeouts, and command budgets) to prevent resource exhaustion, and exposes these capabilities as tools for both chat and MCP transports, ensuring that no shell commands can be executed and that all access is read-only.

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

Introduce dedicated AgentOS agent router and response schema

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. Also in this area: 13 commits (6 fixes) modifying libs/agno; External agents now support run continuation, metrics, and non-retryable error handling; Conversation compaction with searchable archive and HyDE query transformation.

libs/agno/agno/os/routers/agents · medium confidence · unverified

Introduce durable, per-session job queue with concurrency and coordination controls

Background agent runs are now routed through a configurable job queue that supports durability, cross-container coordination via Redis, and strict per-session serialization (at most one live run per session). Users can configure concurrency limits, retry policies, timeouts, and retention, ensuring that background submissions are accepted immediately and executed reliably even across multiple replicas or after crashes.

_libs/agno/agno/job\queue · high confidence

Introduce durable, private filesystem for agent notes

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. Also in this area: External agents now support run continuation, metrics, and non-retryable error handling.

libs/agno/agno/fs · high confidence

Introduce external agent adapters and remote agent support

Adds new agent types to execute external frameworks and remote workloads: CodexAgent wraps the OpenAI Codex SDK for code-generation tasks, DSPyAgent adapts DSPy programs for structured reasoning, and RemoteAgent enables running agents hosted on a remote AgentOS instance or via the A2A protocol. These adapters integrate with the existing AgentOS runtime, allowing users to leverage specialized external tools and distributed agents alongside local models.

agno · high confidence

Introduce factory-based component construction with durable queue support

A new factory system in the \agno/factory\ module allows Agents, Teams, and Workflows to be constructed dynamically per request via a \BaseFactory\ class. This enables context-driven initialization using a \RequestContext\ that carries user, session, and validated input data. The system includes robust support for durable background queues: when a factory-backed component runs on a worker, the HTTP request is replaced by a \QueuedRequest\ object that prevents invalid attribute access, ensuring factories build components solely from stored context data. Additionally, factories can be published as MCP tools with customizable titles and behavior annotations.

libs/agno/agno/factory · high confidence

Introduce first-party ContextProvider API with built-in providers

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

Introduce memory optimization strategies with summarization support

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

Introduce meta-model package for Llama integrations

A new \agno/models/meta\ package has been added to centralize access to Llama-based models. It exposes the \Llama\ model directly and provides a \LlamaOpenAI\ wrapper that allows using Llama models via the OpenAI client interface, with a graceful fallback error if the \openai\ library is not installed.

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

Introduce pluggable run cancellation management with Redis support

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

Introduce result offloading to store large tool outputs in AgentFS

The \agno/offload\ module now offloads large tool results to AgentFS files instead of keeping them in the agent's message history. When a tool result exceeds the configured threshold, the full payload is written to storage and the transcript receives a short envelope with a preview and a \result\_id\. Agents can then use the new \read\_result\ and \search\_result\ tools to retrieve specific lines or search for patterns within these stored results, ensuring that large outputs do not consume excessive context window space while remaining fully accessible.

libs/agno/agno/offload · high confidence

Introduce scheduler subsystem for managing and executing scheduled tasks

Adds a new scheduler package (\agno/scheduler\) that provides a complete system for defining, managing, and executing scheduled tasks. This includes a \ScheduleManager\ for direct database-backed CRUD operations, a \SchedulePoller\ to periodically claim and run due schedules, and a \ScheduleExecutor\ to handle HTTP requests and background run polling. The package also provides CLI utilities (\SchedulerConsole\) for interactive inspection and management of schedules, along with cron expression validation and next-run computation helpers.

libs/agno/agno/scheduler · high confidence

Introduce structured evaluation framework with lazy-loaded modules and async database support

The eval package now provides a structured API for running and tracking evaluations, exposing classes for accuracy, agent-as-judge, performance, and reliability assessments via the \agno.eval\ namespace. To prevent circular imports with the core Agent module, the package uses lazy loading for specific evaluation implementations. Additionally, the framework now supports logging evaluation runs to both synchronous and asynchronous databases, including special handling for thread-affine in-memory SQLite databases to ensure data persistence during concurrent execution.

libs/agno/agno/eval · high confidence

Introduces new middleware components for JWT authentication, URL normalization, and MCP routing

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

Introduces public-facing admission middleware and route policies for AgentOS

Adds a new middleware layer and policy engine to the public surface of AgentOS, enforcing strict admission controls for external requests. This includes validating browser origins, limiting request body sizes and timeouts, sanitizing form inputs (including file uploads and message content), and restricting access to specific agents, teams, and workflows based on configured policies. The change ensures that public endpoints are securely bounded, preventing unauthorized access and resource exhaustion while supporting features like background runs and workflow inputs.

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

Introducing the Learning Machine for agent memory and context

Agents now have a unified system to learn from conversations and retain information across sessions. This update introduces the \LearningMachine\ module, which provides configurable storage for user profiles, unstructured user memories, session context, reusable knowledge, entity facts, and decision logs. Users can configure how and when this data is extracted (e.g., automatically after every response or via agent tools) and choose from various storage backends. A built-in migration tool is also provided to safely re-key existing entity memory data to prevent cross-user collisions in multi-user deployments.

libs/agno/agno/learn · high confidence

Introduction of In-Memory Database Backend

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

Introduction of LanceDB vector database integration

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

Introduction of LiteLLM model integration

Users can now utilize the LiteLLM model provider through the agno library. The new module exposes the LiteLLM class for general usage and conditionally exposes LiteLLMOpenAI, which requires the openai package to be installed separately.

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

Introduction of TuningEngines model class

A new \TuningEngines\ class is now available within the \agno.models.tuning\_engines\ module, exposing a dedicated interface for model tuning operations.

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

Introduction of the Memory Manager component

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

Knowledge module restructured with lazy loading and remote content support

The knowledge package has been reorganized to improve performance and extensibility. The \agno.knowledge\ module now uses lazy loading (PEP 562) to defer importing heavy dependencies like readers and cloud clients until they are actually accessed, reducing startup time. A new \KnowledgeProtocol\ defines a minimal interface for custom knowledge bases, allowing users to implement their own tools and context generation. Additionally, a \RemoteKnowledge\ base class has been introduced, enabling the \Knowledge\ class to load content directly from cloud storage providers including S3, GCS, SharePoint, GitHub, and Azure Blob Storage. Utility functions for metadata handling and chunking strategy resolution have also been added to support these features.

libs/agno/agno/knowledge · high confidence

MongoDB storage backend now supports async operations via PyMongo and Motor

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

New A2A client for remote agent communication

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

New AG-UI interface for exposing Agents and Teams

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

New Advisor Tools cookbook examples

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

New AgentOS API router structure with health, home, and database migration endpoints

The AgentOS API now exposes a structured set of routers for health checks, a root landing page, and database schema migrations. Users can verify service status via a customizable health endpoint that includes instantiation time, navigate to documentation or info endpoints via the new home route, and manage database schemas through dedicated endpoints to migrate all databases or specific ones to a target version, with support for skipping remote databases.

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

New AgentOS Knowledge Management API endpoints

This change introduces a new set of REST API endpoints for managing knowledge bases within AgentOS, located in the \agno/os/routers/knowledge\ module. The primary entry point is the \upload\_content\ endpoint, which allows users to upload files, text, or URLs to a knowledge base. These uploads are processed asynchronously in the background, supporting custom readers and chunking strategies (including chunk size and overlap configuration). The implementation handles both local and remote knowledge instances, ensuring that content ingestion works seamlessly whether the underlying knowledge store is local or remote.

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

New AgentOS Team management and execution API endpoints

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

New AgentOS cookbook lessons for getting started, databases, and the Python client

The AgentOS cookbook now includes three new structured lessons: 'Getting Started' demonstrates mounting an agent, team, workflow, and knowledge base on a single server and interacting via raw HTTP; 'Databases' covers default database inheritance, auto-provisioning, and external media storage backends including S3, GCS, Postgres, and SurrealDB; and 'Python Client' provides examples for the \AgentOSClient\ SDK, including configuration discovery, agent runs with typed streaming events, session and memory management, knowledge ingestion, evaluations, and Bearer authentication. Also in this area: 8 commits (1 fix) modifying cookbook.

_cookbook/05\_agent\_os, cookbook/05\_agent\_os/29\_manager, cookbook/05\_agent\_os/30\company · medium confidence · unverified

New AgentOSClient for remote agent interactions

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

New Claude Agent SDK cookbook with session, tool, and background execution examples

The cookbook/frameworks/claude-agent-sdk directory now includes a comprehensive set of examples demonstrating how to use the Claude Agent SDK with Agno. These examples cover basic runs, multi-turn session persistence with SQLite and PostgreSQL, tool usage (including custom MCP tools), media attachments, background execution with cancellation, retries, and conversation compaction. The README provides detailed setup instructions and configuration options, while individual scripts demonstrate specific features like streaming responses, AgentOS integration, and transcript mirroring for durable conversations.

cookbook/frameworks/claude-agent-sdk · high confidence

New ClickHouse traces database adapter and centralized MCP OAuth store

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

New Codex framework cookbook with agent examples

Added a new cookbook for the Codex external agent, providing runnable examples for basic execution, tool usage, session persistence, background lifecycle with cancellation, compaction, metrics, and retries. The examples demonstrate configuring the CodexAgent with sandbox and approval modes, authenticating via OPENAI\_API\_KEY, and serving the agent through AgentOS with local SQLite storage.

cookbook/frameworks/codex · high confidence

New Company domain API endpoints for tasks, projects, products, and playbooks

This change introduces a new set of REST API routes under the /company prefix, enabling users to manage company-wide resources including Tasks, Projects, Products, and Playbooks (Wiki and Decisions). The diff adds dedicated routers for CRUD operations on these entities, with specific execution logic for Tasks that supports sandboxed agent harnesses and secure admission locking via PostgreSQL advisory locks. Users can now create, read, update, delete, and transition Tasks, Projects, and Products, as well as manage company wikis and decision logs, all governed by scoped user authentication and database-backed persistence. Also in this area: 13 commits (6 fixes) modifying libs/agno.

libs/agno/agno/os/routers/company · medium confidence · unverified

New DSPy and LangGraph external agent adapters

Users can now integrate DSPy programs and LangGraph compiled graphs as external agents within the platform. The new DSPyAgent adapter wraps DSPy modules (such as Predict, ChainOfThought, and ReAct), supporting both non-streaming and token-level streaming execution, automatic LM caching bypass for streaming, and multi-turn conversation history. The LangGraphAgent adapter wraps compiled LangGraph graphs, enabling standard invocation, streaming with full visibility into tool calls and chat model events, and state management features like checkpoint history retrieval, state updates, and replay. Both adapters allow agents to be used standalone or registered with AgentOS.

libs/agno/agno/agents/dspy, libs/agno/agno/agents/langgraph · high confidence

New Discord integration with async media handling and user context

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

New Docling Tools cookbook example for document conversion

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

New Docling reader cookbook examples for advanced document processing

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

New Google Cloud Storage JSON database backend

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

New Google Workspace cookbooks for Gmail, Calendar, Drive, Slides, and Sheets

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

New Human-in-the-Loop cookbook examples for Conditions, Confirmations, and Decision Trees

Added a suite of interactive workflow examples in the Human-in-the-Loop cookbook that demonstrate how to pause execution for user input. These include Condition steps with configurable rejection behaviors (skip, else branch, cancel), error handling modes (skip, fail, pause), and step-level confirmations using both flag-based settings and the @pause decorator. The examples also cover streaming event handling (including StepContinuedEvent), async workflow support, and multi-component decision trees mixing Conditions and Loops.

_cookbook/04\_workflows/08\_human\_in\_the\loop · high confidence

New JSON file-based database implementation

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

New Knowledge management API router

This change introduces a new FastAPI router for managing knowledge bases within AgentOS. It provides endpoints for uploading content (files, text, URLs), configuring chunking strategies (size, overlap, readers), and performing vector searches. The router supports both local and remote knowledge instances, handles asynchronous background processing for uploads, and includes authentication and user-scoping middleware.

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

New LangGraph integration cookbooks for Agno

Added a set of example scripts in the LangGraph cookbook demonstrating how to integrate LangGraph agents with Agno. These examples cover basic standalone usage, serving agents via the AgentOS runtime, managing session persistence with a database, implementing tool-calling workflows, and advanced features like time-travel (replay and fork) using checkpoints.

cookbook/frameworks/langgraph · high confidence

New Learning Machine cookbook examples for user profile, memory, and entity memory

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

New MCP Toolbox Hotel Management Demo Cookbook

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

New MCP cookbook examples and documentation

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

New MCP cookbook examples for SSE and Streamable HTTP transports

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

New OS API endpoints for running and managing agent evaluations

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

New Parallel API cookbooks for search, task, and monitor workflows

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

New PostgreSQL database backend with connection pooling and schema management

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. Also in this area: 13 commits (6 fixes) modifying libs/agno; Persistent transcript storage for external agents; Conversation compaction with searchable archive and HyDE query transformation.

libs/agno/agno/db/postgres · medium confidence · unverified

New RAG integration cookbook examples added

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

New Registry API endpoints for managing agents, tools, and knowledge

A new FastAPI router has been added to expose the application's internal registry via HTTP endpoints. This allows users to query and inspect registered resources—including tools, knowledge bases, memory managers, and learning machines—through a standardized API. The implementation includes serialization helpers to convert these internal objects into structured JSON responses, enabling external systems or UI components to discover and interact with the configured agents and their capabilities.

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

New Schedule API router for managing cron-based automation

This change introduces a new REST API router for creating, listing, updating, and triggering scheduled tasks (cron jobs). It provides endpoints to manage schedule lifecycle with validation for cron expressions and timezones, enforces permission checks to ensure targets are not archived or draft-only, and supports scoped user ownership. The router also integrates with the Company system to stamp auto-acceptance for managed schedules and includes logic to defer activation for managed integrations.

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

New Slack interface for AgentOS

This change introduces a new Slack interface component within the AgentOS framework, allowing users to connect their Slack workspaces to Agno agents, teams, or workflows. The implementation includes a FastAPI router for handling Slack events and interactive messages, a Human-in-the-Loop (HITL) handler for managing approvals and user inputs directly in Slack, and a set of builders for creating Slack Block Kit UI elements. It also provides a standard app manifest for easy Slack app configuration and security utilities for verifying Slack request signatures. Users can now interact with their AI agents through Slack channels and DMs, with support for streaming responses, file handling, and multi-row approval workflows.

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

New Teams quickstart and modes cookbook examples

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

New Telegram interface for agents, teams, and workflows

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-based webhook router (\/telegram/webhook\) with secret token validation, support for streaming responses, and handling of various media types (photos, audio, video, documents). It also provides Markdown-to-Telegram-HTML formatting, session management, and configurable bot commands like /start, /help, and /new.

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

New Traces API for agent execution observability

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

New WhatsApp interface for agent and team interactions

Adds a new WhatsApp interface that allows agents, teams, and workflows to send and receive messages via the WhatsApp Graph API (v25.0). The implementation includes a FastAPI router for handling webhooks, helper functions for downloading and uploading media (images, video, audio, documents), and support for interactive message types like button and list replies. It also introduces optional phone number encryption for privacy and configurable media timeouts.

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

New Workspace toolkit with human-in-the-loop confirmation

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

New accuracy evaluation cookbook examples

Added a new set of cookbook examples in the accuracy evaluation directory that demonstrate various ways to assess model performance. These include basic synchronous and asynchronous evaluations, numeric comparison checks, team-based language routing, tool-using agent assessments, and evaluations with custom evaluator agents. The collection also provides examples for scoring pre-provided answers, logging results to PostgreSQL, and accumulating detailed token metrics from both the agent and the evaluator into a single run output.

_cookbook/09\evals/accuracy · high confidence

New advanced agent examples for cancellation, concurrency, and metrics

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

New agent evaluation and SFT export capabilities

The \agno.environments\ package introduces a new system for running agents against tasks multiple times to calculate pass rates and exporting the resulting passing attempts as a Supervised Fine-Tuning (SFT) dataset. Users can now execute rollouts via \run\_rollouts\ and \arun\_rollouts\, view live progress and static reports with pass/fail glyphs, and export valid SFT data to JSONL format using \to\_sft\_jsonl\ and \ato\_sft\_jsonl\. The module includes strict validation for the exported JSONL files to ensure they meet the format requirements for downstream training consumers.

libs/agno/agno/environments · high confidence

New agent quickstart and memory cookbook examples

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

New agent-as-judge evaluation cookbook with model updates

The agent-as-judge evaluation cookbook now includes examples for basic, batch, binary, custom evaluator, team, post-hook, guideline-based, and tool-using agent evaluations. The examples have been updated to use the GPT-5.6 Luna model for the primary agents and GPT-5.2 for the evaluator agents, and they demonstrate how to persist evaluation results to databases and track eval model metrics via post-hooks.

_cookbook/09\_evals/agent\_as\judge · high confidence

New approval management API with per-user data isolation

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

New background telemetry system for agent runs and OS launches

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

New callable tool factories and Literal type support in tools cookbook

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

New checkpointing and crash recovery cookbook

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

New chunking strategies: Agentic, Code, and Page-aware Markdown

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

New cloud integration cookbooks for AWS, Azure, GCP, SharePoint, and GitHub

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

New conditional branching workflow cookbook

Added a new cookbook section demonstrating various conditional branching patterns using the Router component. The examples cover topic-based routing between specialized agents (e.g., Hacker News vs. Web search), dynamic step selection via string names or step objects, nested choice sequences, and media generation pipelines that route between image and video workflows. The examples also showcase integrating Loop components for iterative refinement and using the \step\_choices\ parameter for flexible selector logic.

_cookbook/04\_workflows/05\_conditional\branching · high confidence

New context management cookbook examples for agent configuration

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

New cookbook demonstrates persisting and auto-discovering AgentOS components

A new cookbook at \cookbook/93\_components\ introduces 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 AgentOS's ability to automatically discover and populate a Registry with models, tools, and databases from defined agents and teams without explicit declaration, and showcases per-user component isolation where components are scoped to the JWT owner.

_cookbook/93\components · high confidence

New cookbook demonstrating cross-model tool call compatibility

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

New cookbook demos for agent regeneration, time-travel, and session forking

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

New cookbook examples for advanced tool management and configuration

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

New cookbook examples for agent dependency injection and dynamic tools

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

New cookbook examples for agent exception handling and workflow observability

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

New cookbook examples for agent input/output patterns and built-in follow-up suggestions

The \cookbook/02\_agents/02\_input\_output\ directory now includes a comprehensive set of examples demonstrating key agent interaction patterns. Users can learn how to guide responses with \expected\_output\, handle multimodal \input\_formats\, enforce \input\_schema\ validation, and produce structured data via \output\_model\ and \parser\_model\. The directory also covers capturing \response\_as\_variable\, automatically \save\_to\_file\, and streaming responses. Additionally, new examples (\followup\_suggestions.py\ and \followup\_suggestions\_streaming.py\) showcase the built-in follow-up suggestion feature, allowing agents to generate structured follow-up prompts after the main response, with support for both synchronous and streaming execution.

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

New cookbook examples for agent memory patterns and integrations

Added a new \cookbook/11\_memory\ section demonstrating how Agno agents persist and use user memories across runs, sessions, and multiple agents. The examples cover persistent memory updates, agentic memory management (create, update, delete), sharing memory between agents, custom memory manager configurations, multi-user multi-session chat (sequential and concurrent), and using MemoryTools with WebSearchTools. It also includes examples for the standalone MemoryManager API (CRUD, creation from text/messages, custom instructions, search, and DB tool control), memory optimization strategies (summarize), and integrations with external memory services like Mem0, Memori, Zep, and inspeximus. All examples use the \gpt-5.6-luna\ model (except where noted) and demonstrate memory persistence via PostgreSQL or SQLite.

_cookbook/11\memory · high confidence

New cookbook examples for multimodal AI tools

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

New cookbook examples for structured I/O, evals, hooks, and human-in-the-loop workflows

The cookbook now includes dedicated examples demonstrating how to use \input\_schema\ and \output\_schema\ for typed agent boundaries, run automated evaluations with \AgentAsJudgeEval\ and \ReliabilityEval\, apply pre- and post-hooks for input validation and output quality checks, and implement deterministic human-in-the-loop approval for side-effecting tools. These files serve as practical templates for building robust, verifiable, and controllable agent applications.

python · high confidence

New cookbook examples for tool decorator capabilities

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

New cookbook examples for tool hooks and message history access

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

New cookbook examples: Second Brain, Metrics Desk, and Team Brain

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

New cookbook for tracing multi-agent teams with Langfuse

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

New cookbooks for result offloading and finance tools

Added two new cookbook sections: \02\_agents/22\_result\_offloading\ demonstrates how to use the \offload\_tool\_results\ agent setting and \ResultStore\ to manage large tool outputs by storing payloads in the database or local disk and replacing them with envelopes in the transcript; and \91\_tools/finance\ provides examples for the \FinanceTools\ toolkit, showing how to use default and custom data providers, enable analyst-mode tools, and run finance queries asynchronously.

(repo-wide) · high confidence

New data labeling cookbook with 28 workflow examples

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

New database schemas for authorization, job queues, and Company lifecycle management

This release introduces the underlying database schema definitions for several new platform capabilities. A pluggable authorization tier is added, defining tables for policies, role groupings, user directories, and audit trails to support managed roles and access control. A durable job queue schema is introduced to manage background execution of agents, teams, and workflows with optimistic concurrency and retry logic. Additionally, schemas for Company management are defined, including validation and lifecycle rules for Projects and Tasks, configuration validation for data Sources, and a built-in OAuth server schema for MCP endpoint authentication.

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

New dedicated print-response utilities for Agents, Teams, and Workflows

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

New demo agents for code search and wiki management

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

New documentation organization and persistent workbench agents

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

New environment verification cookbooks with progressive examples and quickstart

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

New eval suite cookbooks with session, team, and multi-modal support

Added cookbook examples for running multiple evaluation cases as an aggregated suite, featuring CLI options for listing, tagging, and JSON reporting. The new suite\_session.py demonstrates passing session state and user IDs, continuing multi-turn conversations via setup/teardown hooks, and sending image inputs using the Message class. The suite\_team\_scoring.py example shows running a Team with numeric judge scoring and thresholding, while suite\_basic.py provides a standard single-agent evaluation pattern.

_cookbook/09\evals/suite · high confidence

New factory, hooks, and toolkit modules introduced

This change adds several new modules to the tools package: a factory system for context-driven component construction (BaseFactory, RequestContext), a hook decorator system for background execution, and new toolkits including Adanos (market sentiment), Advisor (multi-model feedback), AgentOS (read-only platform ops), AgentQL (web scraping), Airflow (DAG management), and Anakin (web scraping/automation). It also introduces local file utility helpers with default exclusion patterns for sensitive files.

libs/agno/agno/tools · high confidence

New fallback model cookbook examples

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

New guardrail system for input validation and safety

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

New guardrails cookbook for input/output safety and policy enforcement

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

New hook and human-in-the-loop cookbook examples

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

New human-in-the-loop approval cookbook with blocking and audit workflows

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

New integration cookbooks for Parallel, SurrealDB, and Discord

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

New knowledge building-block cookbooks for chunking, search, and reranking

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

New knowledge cookbook examples for RAG patterns and website ingestion

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

New knowledge reader implementations and infrastructure

The knowledge ingestion system now includes dedicated readers for ArXiv papers, CSV and Excel spreadsheets, Docling-based document processing, Word documents, JSON, Markdown, and PDFs. This change introduces the \Reader\ base class and \ReaderFactory\ for unified document ingestion, supporting both synchronous and asynchronous reading with configurable chunking strategies. Users can now ingest structured data from CSV/Excel, academic papers from ArXiv, and various document formats via Docling or native parsers, with specific handling for features like field-labeled CSV rows, Excel sheet filtering, and PDF text sanitization.

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

New knowledge reader utilities for spreadsheet parsing, MDX conversion, and URL handling

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

New local reliability fixture for AgentOS readiness verification

Added a local, two-process integration fixture under \cookbook/frameworks/reliability\ to verify AgentOS readiness against real Claude and Codex SDKs. The fixture uses Docker Compose to spin up dedicated Postgres and Redis services, runs isolated replicas with shared durable queues, and employs a shared SQLite ledger to track native SDK submissions and tool receipts. It supports a suite of reliability checks including background acknowledgements, SSE reconnects, live reconnects, event retention, session overlap, Redis outages, cancellation, idempotency, crash recovery, and concurrency. The entry also documents HTTP input validation rules for media fields and output schemas, which return HTTP 422 for malformed inputs.

cookbook/frameworks/reliability · high confidence

New loop execution cookbook examples with iterative accumulation

Added new workflow examples in the loop execution cookbook that demonstrate basic looping with end-condition evaluators, parallel step execution within loops, and iterative accumulation where loop iterations carry forward output from previous steps via the new \forward\_iteration\_output\ flag.

_cookbook/04\_workflows/03\_loop\execution · high confidence

New metrics API endpoints for monitoring system usage

This change introduces a new metrics router (\/metrics\) that allows users to retrieve aggregated system usage data, including agent runs, sessions, token consumption, and model-specific counts. The API supports filtering by date range, user ID, and database ID, and handles both synchronous and asynchronous database backends. It also includes endpoints to trigger and monitor background metrics refresh processes, ensuring that metric calculations do not block the main application workers.

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

New minimal AgentOS demo with multi-backend wiki agents and evals

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

New model utility modules and Google GenAI compatibility layer

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

New model-specific toolkits for image, audio, and code editing

Agents can now use dedicated toolkits to interact with external AI services for media generation and code modification. The new AIMLAPITools provide image, video, speech, and transcription capabilities via the AI/ML API. AzureOpenAITools adds DALL-E image generation for Azure OpenAI deployments. GroqTools enables audio transcription, translation, and text-to-speech using Groq's Whisper and TTS models. MorphTools allows agents to apply code edits to files using the Morph Fast Apply API. NebiusTools provides text-to-image generation via the Nebius Token Factory. These tools are registered in the libs/agno/agno/tools/models package and expose specific capabilities (image, video, speech, transcription, code editing) that agents can invoke.

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

New modular reranking system with multiple provider and algorithm support

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

New multimodal agent cookbook with audio, image, and video examples

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

New observability cookbook with examples for 20+ tracing platforms

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

New performance evaluation cookbooks for agents, teams, and third-party frameworks

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

New production knowledge cookbooks covering lifecycle, isolation, and SSRF hardening

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

New quickstart cookbook for Agno, Claude Code, Codex, LangGraph, and DSPy

Added a new quickstart guide in \cookbook/frameworks/00\_quickstart\ that demonstrates how to run agents built with Agno, the Claude Agent SDK (Claude Code), OpenAI Codex, LangGraph, and DSPy on AgentOS. The cookbook provides individual example scripts for each framework and a multi-framework example showing how to serve multiple agents through a single runtime, API, and UI. All examples use SQLite for session storage and are available in early alpha status.

_cookbook/frameworks/00\quickstart · high confidence

New reasoning cookbook examples for agents and provider-specific models

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

New reasoning tools cookbook examples added

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

New reasoning-oriented team orchestration cookbooks

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

New reliability evaluation cookbooks for tool-call validation

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

New remote content loaders for cloud storage and collaboration platforms

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

New remote content sources for S3, GCS, Azure Blob, GitHub, and SharePoint

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

New run lifecycle, cancellation, and approval persistence modules

The \agno/run\ package now includes dedicated modules for managing run state and human-in-the-loop (HITL) workflows. \background.py\ introduces support for detached background runs with resumable SSE transport and proper cleanup. \cancel.py\ provides a pluggable cancellation management system (with async support and team member run tracking) to handle run cancellations gracefully. \approval.py\ implements detailed logic for creating, stamping, and resolving approval records for required tool calls, ensuring correct pause types and tool context are persisted. \status\persist.py\ adds atomic run-status persistence with fallback mechanisms to prevent data loss during status transitions (e.g., RUNNING, CANCELLED, ERROR). \utils.py\ offers shared serialization helpers for run outputs and paused requirements. \\\init\\_.py\ exposes key types like \CancellationStage\, \RunContext\, \RunStatus\, and cancellation manager functions.

libs/agno/agno/run · high confidence

New scoring infrastructure with secure LLM judge and deterministic scorers

The \agno.scorer\ package introduces a new evaluation framework featuring three scorer types: \CodeScorer\ for custom callable logic, \ToolCallScorer\ for deterministic verification of tool executions, and \JudgeScorer\ for LLM-based evaluation. The \JudgeScorer\ includes a security improvement by wrapping untrusted model outputs in nonce-delimited fences within prompts to prevent instruction injection. Additionally, the package provides internal utilities for generating stable model identity fingerprints to ensure consistent evaluation environments.

libs/agno/agno/scorer · high confidence

New session management API endpoints

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

New session state and reasoning examples in the cookbook

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

New storage cookbooks for session management and media offload

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

New telemetry API schemas for agent, team, workflow, and eval runs

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

New typesafe hotel management demo cookbook

Added a new cookbook example demonstrating a typesafe hotel management agent. The demo uses Pydantic models for structured input and output schemas, integrates with an MCP toolbox for hotel and booking tools, and showcases agent configuration with specific instructions and debug settings.

mcp-toolbox-demo · high confidence

New utility module for agent run orchestration and event handling

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

New vector database integration examples added to the cookbook

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

New workflow cookbook examples for sequence, function, and step-based patterns

Added runnable cookbook examples under cookbook/04\_workflows/01\_basic\_workflows that demonstrate how to build workflows using sequences of steps, custom function executors (sync, async, and streaming), class-based executors, nested step compositions with conditions and parallel branches, file inputs, and session metrics. The examples also show how to use a single execution function in place of explicit step lists, and they are updated to use the gpt-5.6-luna model.

_cookbook/04\_workflows/06\_advanced\concepts · high confidence

New workflow orchestration module with agents, remote execution, and HITL support

The \libs/agno/agno/workflow\ package introduces a complete workflow orchestration system. Users can now define workflows using components like \Workflow\, \Step\, \Loop\, \Parallel\, \Condition\, and \Router\. A new \WorkflowAgent\ class allows an agent to decide whether to answer from history or execute a workflow. The module supports Human-In-The-Loop (HITL) via the \@pause\ decorator for confirmation and user input steps, and enables conditional branching using Common Expression Language (CEL) through \cel.py\. Additionally, \RemoteWorkflow\ allows executing workflows on a remote server via AgentOS or A2A protocols, and \WorkflowFactory\ supports per-request workflow construction.

libs/agno/agno/workflow · high confidence

New workflow serialization and HITL configuration cookbooks

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

Qdrant vector database integration with hybrid search and async support

The Qdrant vector database implementation is now available, providing support for vector, keyword, and hybrid search modes. Users can leverage hybrid search capabilities using the fastembed library for sparse vector encoding, with configurable fusion strategies. The implementation includes both synchronous and asynchronous client support, allowing for non-blocking operations in async environments. Additionally, the integration supports tenant-based filtering through user\_id payload indexing and allows for custom reranker configuration.

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

Sandboxed agent runtime with Docker and AgentCore support

This cookbook introduces a sandboxed agent execution environment that runs each agent turn in an isolated container (Docker) or microVM (Amazon Bedrock AgentCore). It includes a shared runtime Docker image, a \SandboxCoordinator\ for durable session management with PostgreSQL-backed checkpointing, and provider-specific implementations (\DockerSandbox\, \AgentCoreSandbox\). The feature supports repository workspaces, warm/cold turn reuse, and checkpoint restoration, with example scripts demonstrating session coordination, repository integration, and warm-turn behavior.

cookbook/frameworks/sandbox · high confidence

Tool call result compression to reduce context usage

Agents can now automatically compress verbose tool call results to save context space. The new \CompressionManager\ evaluates whether compression is needed based on token limits or a count of uncompressed tool results, then uses an LLM to distill the output to essential facts, entities, and identifiers while removing filler and formatting. This helps keep conversations within model context windows and reduces token costs.

libs/agno/agno/compression · high confidence

Removals

Removal of Docker and AWS application templates

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

Removal of Kubernetes application definitions

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

Removal of legacy Agent classes and CLI-based Phi AI conversation system

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

Architecture

Agent module restructured into modular sub-packages

The agent package has been reorganized from a single monolithic file into a set of specialized modules (e.g., \\_cli\, \\_default\_tools\, \\_hooks\, \\_init\, \\_managers\, \\_messages\, \\_response\, \\run\). This change improves code maintainability and separation of concerns by isolating CLI helpers, default tool definitions, hook execution logic, initialization routines, background task orchestration, message construction, response processing, and the core run loop into their own files, while the main \\\init\\_.py\ now serves as a clean public API surface.

libs/agno/agno/agent · high confidence

Team module restructured into modular internal components

The \agno/team\ package has been refactored from a monolithic structure into a set of specialized internal modules. The public API surface in \\_\init\\_.py\ now explicitly re-exports core classes like \Team\, \RemoteTeam\, \TeamFactory\, and \TeamMode\, along with granular run events (e.g., \ReasoningStepEvent\, \FollowupsCompletedEvent\) and session accessors. Implementation details have been split into dedicated files: \\_init.py\ handles configuration and initialization, \\_run.py\ manages the run lifecycle and cancellation, \\_messages.py\ handles prompt construction and member rostering, \\_response.py\ processes model outputs and parsing, \\_hooks.py\ manages pause/approval logic, \\_cli.py\ provides user-facing printing and REPL helpers, \\_default\_tools.py\ defines built-in team tools, \\_managers.py\ orchestrates background memory and learning tasks, and \\_session.py\ handles session persistence. This change improves code organization and maintainability without altering the public interface.

libs/agno/agno/team · high confidence

Behavioural changes

1 commit (0 fixes) modifying (repo-wide)

A change to existing behaviour in (repo-wide) — 1 commit, 46 files: “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)” (refs \#9153).

(repo-wide) · medium confidence · unverified

1 commit (0 fixes) modifying cookbook/04\_workflows/02\_conditional\_execution, cookbook/04\_workflows/04\_parallel\_execution

A change to existing behaviour in cookbook/04\_workflows/02\_conditional\_execution, cookbook/04\_workflows/04\_parallel\_execution — 1 commit, 10 files: “V2.5 phase5 rebase (\#6515)” (refs \#6515).

_cookbook/04\_workflows/02\_conditional\_execution, cookbook/04\_workflows/04\_parallel\execution · medium confidence · unverified

1 commit (0 fixes) modifying cookbook/05\_agent\_os/26\_authorization

A change to existing behaviour in cookbook/05\_agent\_os/26\_authorization — 1 commit, 18 files: “feat: v3.1 (\#10530)” (refs \#10530).

_cookbook/05\_agent\_os/26\authorization · medium confidence · unverified

1 commit (0 fixes) modifying cookbook/05\_agent\_os/28\_compaction, libs/agno/agno/compaction

A change to existing behaviour in cookbook/05\_agent\_os/28\_compaction, libs/agno/agno/compaction — 1 commit, 10 files: “feat: auto compaction with a searchable archive (\#9873)” (refs \#9873).

_cookbook/05\_agent\_os/28\compaction, libs/agno/agno/compaction · medium confidence · unverified

1 commit (0 fixes) modifying cookbook/05\_agent\_os/31\_session\_filters

A change to existing behaviour in cookbook/05\_agent\_os/31\_session\_filters — 1 commit, 4 files: “feat: add advanced session search and filter schema (\#11319)” (refs \#11319).

_cookbook/05\_agent\_os/31\_session\filters · medium confidence · unverified

1 commit (0 fixes) modifying libs/agno/agno/models/cometapi

A change to existing behaviour in libs/agno/agno/models/cometapi — 1 commit, 1 file: “\[feat\] Add CometAPI as a new model provider (\#4682)” (refs \#4682).

libs/agno/agno/models/cometapi · low confidence · unverified

10 commits (0 fixes) modifying cookbook/05\_agent\_os/14\_mcp

A change to existing behaviour in cookbook/05\_agent\_os/14\_mcp — 10 commits, 13 files: “feat: list the served tools on the MCP Server Card (\#9949)”; “feat: expose toolkits as MCP tools + hide framework params (\#9846)”; “feat: serve agents, teams, and workflows as MCP tools (\#9819)”; and 7 more (refs \#9949, \#9846, \#9819, \#10285, \#9930, …).

_cookbook/05\_agent\_os/14\mcp · medium confidence · unverified

12 commits (6 fixes) modifying libs/agno/agno/db/sql

A change to existing behaviour in libs/agno/agno/db/sql — 12 commits (6 fixs), 5 files: “fix: keep Company Routines linked, routed and owned consistently (\#11184)”; “fix: stabilize Company Task session ownership and recovery (\#11126)”; “feat: cascade Company archives and add grouped counts (\#11114)”; and 9 more (refs \#11184, \#11126, \#11114, \#11292, \#11118, …).

libs/agno/agno/db/sql · medium confidence · unverified

13 commits (6 fixes) modifying libs/agno

A change to existing behaviour in libs/agno — 13 commits (6 fixs), 89 files: “fix: metrics refresh follow-ups for MongoDB, Valkey and DynamoDB legacy runs (\#11574)”; “fix: stop publishing Company tools over MCP (\#11578)”; “feat: let Super Agent start accepted Company Tasks without blocking the conversation (\#11562)”; and 10 more (refs \#11574, \#11578, \#11562, \#11581, \#11586, …). Also in this area: Introduce OS Manager for building and operating AgentOS components.

libs/agno/agno/os/manager, libs/agno/tests/unit/guardrails, libs/agno/tests/unit/remote · medium confidence · unverified

14 commits (5 fixes) modifying libs/agno/agno/sandbox

A change to existing behaviour in libs/agno/agno/sandbox — 14 commits (5 fixs), 15 files: “feat: store and serve external agents as components (\#11268)”; “feat: configure repositories for sandboxed harness agents (\#11121)”; “feat: sandbox support (\#11028)”; and 11 more (refs \#11268, \#11121, \#11028, \#11131, \#11194, …).

libs/agno/agno/sandbox · medium confidence · unverified

17 commits (5 fixes) modifying cookbook/05\_agent\_os/27\_public\_pages

A change to existing behaviour in cookbook/05\_agent\_os/27\_public\_pages — 17 commits (5 fixs), 14 files: “feat: add guarded documentation source relocation API (\#10096)”; “feat: add AgentOS lifecycle support for Knowledge page synchronization (\#10098)”; “fix: preserve Control Plane access with public surfaces (\#10074)”; and 14 more (refs \#10096, \#10098, \#10074, \#10726, \#10869, …).

_cookbook/05\_agent\_os/27\_public\pages · medium confidence · unverified

2 commits (0 fixes) modifying cookbook/05\_agent\_os/05\_human\_in\_the\_loop, cookbook/05\_agent\_os/24\_showcase

A change to existing behaviour in cookbook/05\_agent\_os/05\_human\_in\_the\_loop, cookbook/05\_agent\_os/24\_showcase — 2 commits, 14 files: “feat: v3.0 (\#8210)”; “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)” (refs \#8210, \#9153).

_cookbook/05\_agent\_os/05\_human\_in\_the\_loop, cookbook/05\_agent\_os/24\showcase · medium confidence · unverified

2 commits (0 fixes) modifying cookbook/05\_agent\_os/13\_observability

A change to existing behaviour in cookbook/05\_agent\_os/13\_observability — 2 commits, 8 files: “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)”; “feat: metrics tables, background refresh and /os/metrics homepage routes on every database (\#10874)” (refs \#9153, \#10874).

_cookbook/05\_agent\_os/13\observability · medium confidence · unverified

2 commits (0 fixes) modifying cookbook/05\_agent\_os/15\_a2a, cookbook/05\_agent\_os/20\_remote

A change to existing behaviour in cookbook/05\_agent\_os/15\_a2a, cookbook/05\_agent\_os/20\_remote — 2 commits, 21 files: “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)”; “feat: move A2A to v1.0 with stored tasks, external agents and pause/continue \[SDK-647\] (\#10956)” (refs \#9153, \#10956).

_cookbook/05\_agent\_os/15\_a2a, cookbook/05\_agent\_os/20\remote · medium confidence · unverified

2 commits (1 fix) modifying cookbook/05\_agent\_os/21\_factories

A change to existing behaviour in cookbook/05\_agent\_os/21\_factories — 2 commits (1 fix), 8 files: “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)”; “fix: run factory-backed components on the durable queue (\#11045)” (refs \#9153, \#11045).

_cookbook/05\_agent\_os/21\factories · medium confidence · unverified

2 commits (1 fix) modifying cookbook/frameworks/harness\_teams

A change to existing behaviour in cookbook/frameworks/harness\_teams — 2 commits (1 fix), 16 files: “feat: let Claude Code and Codex agents be members of an Agno team (\#11241)”; “fix: move the AccuracyEval judge and examples off retired OpenAI models (\#11347)” (refs \#11241, \#11347).

_cookbook/frameworks/harness\teams · medium confidence · unverified

3 commits (0 fixes) modifying cookbook/05\_agent\_os/02\_databases

A change to existing behaviour in cookbook/05\_agent\_os/02\_databases — 3 commits, 8 files: “refactor: agno.tools.file and agno.tools.knowledge as packages (\#9861)”; “feat: v3.0 (\#8210)”; “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)” (refs \#9861, \#8210, \#9153).

_cookbook/05\_agent\_os/02\databases · medium confidence · unverified

3 commits (0 fixes) modifying cookbook/05\_agent\_os/12\_scheduler

A change to existing behaviour in cookbook/05\_agent\_os/12\_scheduler — 3 commits, 6 files: “feat: Company Task stages on create and move, Routine cancel, archive and delete (\#11312)”; “feat: v3.0 (\#8210)”; “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)” (refs \#11312, \#8210, \#9153).

_cookbook/05\_agent\_os/12\scheduler · medium confidence · unverified

3 commits (0 fixes) modifying cookbook/05\_agent\_os/22\_studio

A change to existing behaviour in cookbook/05\_agent\_os/22\_studio — 3 commits, 10 files: “feat: StudioRunnerTools - identity-aware dispatch toolkit for Studio components (\#9371)”; “feat: v3.0 (\#8210)”; “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)” (refs \#9371, \#8210, \#9153).

_cookbook/05\_agent\_os/22\studio · medium confidence · unverified

3 commits (0 fixes) modifying cookbook/05\_agent\_os/27\_filesystem

A change to existing behaviour in cookbook/05\_agent\_os/27\_filesystem — 3 commits, 13 files: “feat: continue ClaudeAgent runs from a step (\#10917)”; “feat: v3.1 (\#10530)”; “cookbook: add knowledge filesystem example and sync progress logs (\#10868)” (refs \#10917, \#10530, \#10868).

_cookbook/05\_agent\_os/27\filesystem · medium confidence · unverified

3 commits (0 fixes) modifying cookbook/05\_agent\_os/30\_company/12\_company\_details

A change to existing behaviour in cookbook/05\_agent\_os/30\_company/12\_company\_details — 3 commits, 4 files: “feat: add public manager IDs and company details (\#11502)”; “feat: Super Agent does the work itself with direct tools (\#11572)”; “feat: update company details from human chats (\#11569)” (refs \#11502, \#11572, \#11569).

_cookbook/05\_agent\_os/30\_company/12\_company\details · medium confidence · unverified

3 commits (1 fix) modifying cookbook

A change to existing behaviour in cookbook — 3 commits (1 fix), 13 files: “feat: deliver Company Task results with evidence and continue Tasks from a reply (\#11568)”; “fix: Company fixes before 3.2 (\#11592)”; “feat: Slack agent view, Bolt, Stop, external agents and Super Agent results (\#11599)” (refs \#11568, \#11592, \#11599). Also in this area: New AgentOS cookbook lessons for getting started, databases, and the Python client.

_cookbook/05\_agent\_os/17\slack · medium confidence · unverified

3 commits (1 fix) modifying cookbook/05\_agent\_os/chart\_responses

A change to existing behaviour in cookbook/05\_agent\_os/chart\_responses — 3 commits (1 fix), 5 files: “fix: stabilize Company Task session ownership and recovery (\#11126)”; “feat: add ChartTools toolkit for inline Agno OS charts (\#8295)”; “feat: show a headline number on ChartTools charts (\#11110)” (refs \#11126, \#8295, \#11110).

_cookbook/05\_agent\_os/chart\responses · medium confidence · unverified

4 commits (0 fixes) modifying cookbook/05\_agent\_os/04\_run\_lifecycle

A change to existing behaviour in cookbook/05\_agent\_os/04\_run\_lifecycle — 4 commits, 8 files: “feat: support .zip and .eml file uploads in AgentOS (\#9193)”; “feat: add cancellation\_stage to cancelled runs (\#10411)”; “\[cookbook\] Document AgentOS team run states (\#9768)”; and 1 more (refs \#9193, \#10411, \#9768, \#9153).

_cookbook/05\_agent\_os/04\_run\lifecycle · medium confidence · unverified

4 commits (0 fixes) modifying cookbook/05\_agent\_os/07\_security

A change to existing behaviour in cookbook/05\_agent\_os/07\_security — 4 commits, 14 files: “feat: add AuthorizationConfig.excluded\_route\_paths for custom public routes (\#9295)”; “feat: v3.0 (\#8210)”; “feat: v3.1 (\#10530)”; and 1 more (refs \#9295, \#8210, \#10530, \#9153).

_cookbook/05\_agent\_os/07\security · medium confidence · unverified

4 commits (1 fix) modifying cookbook/05\_agent\_os/03\_python\_client

A change to existing behaviour in cookbook/05\_agent\_os/03\_python\_client — 4 commits (1 fix), 13 files: “feat: add pagination to get session runs endpoint (\#8456)”; “fix: surface embedding failures during knowledge ingestion (\#9814)”; “feat: v3.0 (\#8210)”; and 1 more (refs \#8456, \#9814, \#8210, \#9153).

_cookbook/05\_agent\_os/03\_python\client · medium confidence · unverified

5 commits (0 fixes) modifying libs/agno/agno/agents

A change to existing behaviour in libs/agno/agno/agents — 5 commits, 6 files: “feat: store and serve external agents as components (\#11268)”; “feat: let published Studio components execute Company Tasks (\#11443)”; “feat: improve external agent APIs and framework cookbooks (\#10926)”; and 2 more (refs \#11268, \#11443, \#10926, \#11374, \#7503).

libs/agno/agno/agents · medium confidence · unverified

5 commits (1 fix) modifying cookbook/05\_agent\_os/16\_agui

A change to existing behaviour in cookbook/05\_agent\_os/16\_agui — 5 commits (1 fix), 25 files: “\[cookbook\] Add OpenUI client example for AgentOS AG-UI (\#9605)”; “feat: v3.0 (\#8210)”; “cookbook: rewrite the AgentOS cookbook (284 files -\> 132, 24 lessons) (\#9153)”; and 2 more (refs \#9605, \#8210, \#9153, \#9980, \#11347).

_cookbook/05\_agent\_os/16\agui · medium confidence · unverified

5 commits (1 fix) modifying libs/agno/agno

A change to existing behaviour in libs/agno/agno — 5 commits (1 fix), 6 files: “feat: add advanced filtering dsl (\#6671)”; “chore: add version”; “fix: Preserve complete Pydantic schema structure in Claude tool formatting (\#4400)”; and 2 more (refs \#6671, \#4400, \#1935, \#5223).

libs/agno/agno · medium confidence · unverified

6 commits (2 fixes) modifying libs/agno/agno/sandbox/docker

A change to existing behaviour in libs/agno/agno/sandbox/docker — 6 commits (2 fixs), 3 files: “feat: store and serve external agents as components (\#11268)”; “feat: sandbox support (\#11028)”; “feat: Release v3.2.0 (\#11399)”; and 3 more (refs \#11268, \#11028, \#11399, \#11187, \#11191, …).

libs/agno/agno/sandbox/docker · medium confidence · unverified

7 commits (1 fix) modifying cookbook/05\_agent\_os/background\_tasks

A change to existing behaviour in cookbook/05\_agent\_os/background\_tasks — 7 commits (1 fix), 6 files: “feat: v3.0 (\#8210)”; “feat: queue per session - at most one live run per session (head-of-line durable claims) (\#9587)”; “feat: export QueueConfig from agno.os (\#9776)”; and 4 more (refs \#8210, \#9587, \#9776, \#9153, \#6515, …).

_cookbook/05\_agent\_os/background\tasks · medium confidence · unverified

8 commits (2 fixes) modifying libs/agno/agno/os/authz

A change to existing behaviour in libs/agno/agno/os/authz — 8 commits (2 fixs), 13 files: “feat: decide Company work from chat and run accepted Tasks on Mini Agent (\#11581)”; “feat: add the AgentOS manager (\#11036)”; “fix: run post-hook guardrails and keep workflow metadata on a continued run (\#11585)”; and 5 more (refs \#11581, \#11036, \#11585, \#10530, \#11592, …).

libs/agno/agno/os/authz · medium confidence · unverified

8 commits (3 fixes) modifying libs/agno/agno/db/valkey

A change to existing behaviour in libs/agno/agno/db/valkey — 8 commits (3 fixs), 4 files: “fix: metrics refresh follow-ups for MongoDB, Valkey and DynamoDB legacy runs (\#11574)”; “fix: log metrics refresh no-op messages at debug level (\#11570)”; “feat: add advanced session search and filter schema (\#11319)”; and 5 more (refs \#11574, \#11570, \#11319, \#8210, \#9185, …).

libs/agno/agno/db/valkey · medium confidence · unverified

AWS model exports now handle optional Anthropic dependency

The AWS models module now exports the Claude class alongside AwsBedrock, but makes the underlying Anthropic library optional. If the \anthropic\ package is not installed, importing \Claude\ will raise a clear ImportError instructing users to install it, rather than failing at the module level. This allows users to import from the AWS models namespace without requiring all optional dependencies to be present.

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

Add explicit exports for LMStudio model

The LMStudio model is now explicitly exported from the \agno.models.lmstudio\ package via the \\_\init\\_.py\ file, allowing users to import \LMStudio\ directly from this module path.

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

Azure model providers now expose lazy-loading stubs for AI Foundry, OpenAI Chat, OpenAI Responses, and Claude

The Azure module now provides a unified entry point that imports four model providers—AzureAIFoundry, AzureOpenAI, AzureOpenAIResponses, and AzureFoundryClaude—using lazy imports. If the required SDKs (azure-ai-inference, openai, anthropic) are not installed, importing these classes raises a clear ImportError with installation instructions, allowing users to reference these providers without immediate dependency failures.

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

Database schema migrations for v2.3, v2.5, v2.5.6, and v3.0

This release introduces a suite of database migrations to support version upgrades. The v2.3 migration adds created\_at and feedback columns to the memories table and converts JSON storage to JSONB for PostgreSQL. The v2.5 migration enforces a primary key on session\_id for SQL backends, replacing the previous unique constraint. The v2.5.6 migration adds a run\_status column and index to the approvals table. Finally, the v3.0 migration normalizes session runs into a dedicated runs table to prevent unbounded session row growth, adds user\_id columns and indexes to tables such as evals, components, knowledge, schedules, and metrics for per-user isolation, and re-keys entity memory learnings to owner-specific keys.

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

Enhanced workflow response schema with component metadata and nested resolution

The workflow API responses now include \is\_component\, \current\_version\, and \stage\ fields to expose builder origin and lifecycle state. Additionally, the response structure has been updated to recursively resolve and include nested agent and team configurations within workflow steps, ensuring that complex workflows with conditional branches (\else\_steps\) and nested hierarchies are fully represented in the API output.

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

File tools refactored into a package with lazy imports and line-range validation

The file tooling has been reorganized into a structured package (\agno.tools.file\) containing \FileTools\ for read/write operations and \FileGenerationTools\ for creating artifacts like PDFs, DOCX, and CSVs. To improve startup performance, imports for optional dependencies (such as \reportlab\ and \python-docx\) are now lazy, meaning they are only loaded when the specific generation features are actually used. Additionally, the \replace\_file\_chunk\ tool now strictly validates line ranges, rejecting invalid inputs to prevent unexpected behavior.

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

FileSystem cookbook reorganized and instructions made explicit

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

Infrastructure module reorganization and base class updates

The infrastructure library has been reorganized under the \agno\_infra\ namespace, moving core components like AWS resources and Docker contexts from the \phi\ package to \agno\. The base resource class \PhiBase\ has been renamed to \InfraBase\ and updated to use \InfraSettings\ instead of \WorkspaceSettings\, introducing new fields for filtering resources by group, environment, and infrastructure, as well as explicit wait controls for resource lifecycle operations. Additionally, new public entry points have been added for \Document\ and \Embedder\ classes in the knowledge module.

agno-infra, libs/agno/agno/knowledge/document, libs/agno/agno/knowledge/embedder · high confidence

Introduce MigrationManager and v3.0 schema migration for normalized run storage

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

Introduces base interface abstraction with RBAC scope mapping and custom prefix support

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

Lazy loading of GeminiInteractions and new utility support for Google's Interactions API

The Google model module now supports the new GeminiInteractions class, which is lazily imported to prevent forcing the google-genai\>=2.0.0 dependency for standard Gemini usage. Additionally, new utility functions and constants have been added to handle media conversion (URLs, bytes, filepaths) for the Interactions API and to manage malformed function call errors with specific retry guidance.

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

MCP tools now support Streamable HTTP transport and configurable connection parameters

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

New SQLite database backend with async support

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

New evals cookbook and expanded tool examples with behavioral fixes

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

New migration scripts and manager for upgrading to Agno v3

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. Also in this area: 5 commits (3 fixes) fixing libs/agno.

libs/agno/migrations · medium confidence · unverified

PineconeDB integration now warns against and blocks Pinecone v6.x

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

Quickstart overhauled for Gemini 3.6 Flash and AgentOS integration

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

Replaced legacy Phidata scripts with Agno setup, validation, and formatting tooling

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

Repository rebrands from Phidata to Agno with new developer guidelines

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

Reserved internal component IDs prevent user conflicts

The registry now enforces a set of reserved IDs for framework-owned components (such as the OS Manager, Platform Builder, and Company Manager), ensuring that users cannot accidentally or intentionally claim these internal identifiers. This change introduces logic to detect when a user attempts to register a component with a reserved ID and provides a clear error message guiding them to choose a different ID, thereby protecting the integrity of built-in system managers.

libs/agno/agno/registry · high confidence

Standardized model package exports in Agno

The Agno library now explicitly defines public exports for its model providers (Cohere, DeepSeek, Fireworks, Groq, HuggingFace, InternLM, Mistral, Nvidia, Sambanova, and Together) via dedicated \_\init\\_.py files. This change ensures that importing these models from their respective sub-packages is stable and predictable, aligning with the library's transition to the Agno namespace.

(repo-wide) · high confidence

Unified authentication and lazy loading for Google toolkits

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

Unified service layer for session reads and run lifecycle operations

A new shared service layer in \agno.os.services\ centralizes session read and run-lifecycle logic (continue, cancel) previously duplicated across REST and MCP interfaces. This ensures consistent behavior for both surfaces, including strict ownership verification for runs, safe handling of paused run continuations (blocking remote components and managing job-queue tickets to prevent race conditions), and unified session pagination and run classification. Also in this area: 5 commits (3 fixes) fixing libs/agno; 13 commits (6 fixes) modifying libs/agno.

libs/agno/agno/os/services · medium confidence · unverified

Vector database base class and search utilities introduced

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

Fixes

5 commits (3 fixes) fixing libs/agno

A fix in libs/agno — 5 commits (3 fixs), 12 files: “\[fix\] Make ExaTools pass the Exa options it accepts, and add the missing ones (\#9914)”; “fix: Correct the v1 to v2 migration paths and add the v2 to v3 migrations to the migrations README (\#9344)”; “test: retry the metrics refresh until it runs in the Claude and Codex metrics tests (\#11652)”; and 2 more (refs \#9914, \#9344, \#11652, \#11617, \#9568). Also in this area: 13 commits (6 fixes) modifying libs/agno.

libs/agno/agno/os/interfaces/github · medium confidence · unverified

Test coverage

17 commits adding/updating tests in libs/agno/tests/integration/sandbox; 2 commits adding/updating tests in libs/agno/tests/unit/tracing; 4 commits adding/updating tests in libs/agno/tests/unit/compaction; Added IBM Watson X integration tests with rate-limit protection; Added integration and unit tests for media offloading, telemetry, and OAuth; 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 HuggingFace model support; 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 Mistral model capabilities; 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 external agent session management and transcript storage; Added integration tests for team human-in-the-loop flows; Added integration tests for the Cohere model; Added integration tests for the Groq model provider; Added integration tests for the Postgres database adapter; 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 the cookbook pattern checker; 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 core behaviors; Added unit tests for AgentOS routers; Added unit tests for Anthropic model message formatting and behavior; 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 external agent adapters and queue infrastructure; 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 offload configuration and result store behavior; 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 sandbox subsystems; 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 TuningEngines model provider; 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; 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 Vercel V0 model; 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 Company database operations; 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; Unit tests added for the Skills module.

Dependencies

Replaced monolithic pyproject.toml with modular library manifests and cookbook requirements

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 48 → 51 (+2.6)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 62 → 58 (-4.2)
  • Architecture 94 → 94 (+0.8)
  • Maturity 62 → 68 (+6.0)
  • Readiness 36 → 40 (+4.3)
  • Security 72 → 72 (+0.7)
  • Domain Modelling 100 → 100 (+0.0)
  • Accessibility 53 → 56 (+3.4)
  • Performance 60 → 60 (+0.0)

Resolved (677)

  • A2AClient._build_message_request (cognitive 33) (libs/agno/agno/client/a2a/client.py)
  • A2AClient._build_message_request (cyclomatic 22) (libs/agno/agno/client/a2a/client.py)
  • A2AClient.stream_message (cognitive 16) (libs/agno/agno/client/a2a/client.py)
  • AsyncMongoDb._get_all_sessions_for_metrics_calculation (cognitive 18) (libs/agno/agno/db/mongo/async_mongo.py)
  • Critical CVE: [GHSA redacted] (cookbook/91_tools/mcp/mcp_toolbox_demo/uv.lock)
  • Duplicated block (10 lines × 2) (libs/agno/agno/db/postgres/async_postgres.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/db/postgres/async_postgres.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/db/postgres/postgres.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/db/sqlite/async_sqlite.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/os/routers/session/session.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/os/routers/traces/schemas.py)
  • Duplicated block (10 lines × 2) (libs/agno/agno/utils/callables.py)
  • Duplicated block (10 lines × 3) (libs/agno/agno/db/mysql/mysql.py)
  • Duplicated block (10 lines × 3) (libs/agno/agno/os/interfaces/a2a/router.py)
  • Duplicated block (10 lines × 4) (libs/agno/agno/db/postgres/async_postgres.py)
  • Duplicated block (10 lines × 4) (libs/agno/agno/db/postgres/async_postgres.py)
  • Duplicated block (10 lines × 5) (libs/agno/agno/db/mysql/mysql.py)
  • Duplicated block (105 lines × 2) (libs/agno/agno/agent/_run.py)
  • Duplicated block (105–109 lines × 2) (libs/agno/agno/db/redis/redis.py)
  • Duplicated block (10–11 lines × 2) (libs/agno/agno/db/mysql/async_mysql.py)
  • …and 657 more

New (2303)

  • 15_policy_source_to_done.main (cognitive 16) (cookbook/05_agent_os/30_company/15_policy_source_to_done.py)
  • A2AClient._build_message (cognitive 42) (libs/agno/agno/client/a2a/client.py)
  • A2AClient._build_message (cyclomatic 35) (libs/agno/agno/client/a2a/client.py)
  • A2AClient._parse_artifacts (cognitive 16) (libs/agno/agno/client/a2a/client.py)
  • A2AExecutor._continue_task (cognitive 23) (libs/agno/agno/os/interfaces/a2a/executor.py)
  • A2AExecutor._continue_task (cyclomatic 17) (libs/agno/agno/os/interfaces/a2a/executor.py)
  • A2AExecutor.execute (cognitive 31) (libs/agno/agno/os/interfaces/a2a/executor.py)
  • A2AExecutor.execute (cyclomatic 23) (libs/agno/agno/os/interfaces/a2a/executor.py)
  • A2ARequestContextBuilder.build (cognitive 21) (libs/agno/agno/os/interfaces/a2a/context.py)
  • A2ATaskStore.list (cognitive 27) (libs/agno/agno/os/interfaces/a2a/task_store.py)
  • A2ATaskStore.list (cyclomatic 20) (libs/agno/agno/os/interfaces/a2a/task_store.py)
  • A2ATaskStore.save (cognitive 20) (libs/agno/agno/os/interfaces/a2a/task_store.py)
  • AgentOS._add_built_in_routes (cyclomatic 23) (libs/agno/agno/os/app.py)
  • AntigravityAgent._arun_adapter_stream (cognitive 19) (libs/agno/agno/agents/antigravity/agent.py)
  • AntigravityAgent._extract_final_text (cognitive 17) (libs/agno/agno/agents/antigravity/agent.py)
  • AntigravityAgent._translate_sse_event (cognitive 38) (libs/agno/agno/agents/antigravity/agent.py)
  • AntigravityAgent._translate_sse_event (cyclomatic 30) (libs/agno/agno/agents/antigravity/agent.py)
  • AsyncBaseDb.search_sessions (cognitive 21) (libs/agno/agno/db/base.py)
  • AsyncCompanyManager.update_task (cognitive 17) (libs/agno/agno/company/manager.py)
  • AsyncMongoDb._calculate_date_metrics (cognitive 45) (libs/agno/agno/db/mongo/async_mongo.py)
  • …and 2283 more

Changes since last survey

  • 107 commits — 51 feature/other, 56 fixes

By area

  • libs/agno — 87 commits
  • (root) — 9 commits
  • cookbook/05_agent_os — 2 commits
  • cookbook/11_memory — 2 commits
  • cookbook/90_models — 2 commits
  • cookbook/91_tools — 2 commits
  • .github/workflows — 1 commit
  • cookbook/07_knowledge — 1 commit
  • cookbook/09_evals — 1 commit

Notable commits

  • fix: [fix] Apply the item cap in the Apify job search cookbook (#11400)
  • fix: [fix] Handle non-string and None stream names in FieldLabeledCSVReader (#11375) (#11397)
  • fix: [fix] Honor zero YouTube result limits in SearchAPI (#11370)
  • fix: [fix] Keep generation_config and generative_model_kwargs values in Gemini requests (#10162)
  • fix: [fix] Make ExaTools pass the Exa options it accepts, and add the missing ones (#9914)
  • fix: [fix] Migrate SmallestTools defaults before Lightning v3.1 retirement (#11479)
  • fix: [fix] Preserve HTML and nested bodies in Gmail list tools (#10359)
  • fix: [fix] Rank DuckDB full-text matches by descending relevance (#11362)
  • fix: [fix] Reject zero page size in field-labeled CSV reader (#10602)
  • fix: [fix] Remove silent token caps from routed providers (#10723)
  • fix: [fix] Restore RunStatus on Team and Workflow run deserialization (#11424)
  • fix: [fix] Restore SingleStore run upserts (#11508)
  • fix: [fix] Return no documents when the MMR reranker limit is zero (#10450)
  • fix: [fix] agno 3.x: never place a new run below the session's existing run_index (#9938)
  • fix: [fix] copy the reasoning block before writing derived params into it (#10310)
  • fix: fix(tools): respect zero max_results, apply modifier in search_news, and add error handling in WebSearchTools (#10806)
  • fix: fix: Company fixes before 3.2 (#11592)
  • fix: fix: Correct the v1 to v2 migration paths and add the v2 to v3 migrations to the migrations README (#9344)
  • fix: fix: Revert "chore: deal the Validation unit tests round-robin across 15 shards" (#11490)
  • fix: fix: accept the name argument in YouTubeReader.async_read (#11417)
  • …and 87 more

Architecture

  • Unchanged — 0 containers · 5 contexts · 0 edges

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 439da90695d16d469b3b1963913ab1ad6e6a9648 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.