Agno — The AI Toolchain

Agno v3.0.4

Sun, 30 Aug 2026 22:40:41 GMT

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

Agno v3.0.3

Sun, 30 Aug 2026 20:45:21 GMT

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

Agno v3.0.2

Sun, 30 Aug 2026 08:01:42 GMT

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

Agno v3.0.1

Wed, 26 Aug 2026 10:19:39 GMT

Agno v3.0.1 adds a `timeout` parameter to `PubmedTools`, exports `QueueConfig` from `agno.os`, and caches tool schemas across runs for faster large-toolkit agents. • Adds `timeout` parameter to `PubmedTools`, passed to both NCBI E-utilities requests so a stalled PubMed response cannot block a tool call indefinitely. • Exports `QueueConfig` from `agno.os`, making it importable directly from that module. • Tool schemas are now derived once and cached across runs, cutting per-run overhead for agents that carry large toolkits. • Session history is now loaded incrementally per turn, keeping response time flat as a conversation grows rather than scaling with its length.

Agno v3.0.0a5

Mon, 24 Aug 2026 11:40:21 GMT

Adds opt-in `self_dispatch` knob to the Studio dispatch guard in Agno v3.0.0a5. • Adds `self_dispatch` opt-in knob to the Studio dispatch guard, allowing agents to be explicitly configured to dispatch to themselves.

Agno v3.0.0a4

Sun, 23 Aug 2026 23:41:00 GMT

Agno v3.0.0a4 adds MiniMax video generation tools and switches all telemetry calls to fire-and-forget. • Adds MiniMax video generation tools, extending the 100+ integrations toolkit with AI video synthesis. • Makes all telemetry calls fire-and-forget, eliminating blocking waits on telemetry I/O during agent runs.

Agno v3.0.0a3

Fri, 21 Aug 2026 23:27:33 GMT

Agno v3.0.0a3 adds CodeMode, media offloading, SuperGrok OAuth, workflow registry, and MigrationRequiredError for stale schemas. • Adds `MigrationRequiredError` to surface stale database schema errors with an actionable migration path instead of a silent table failure. • Adds `CodeMode` for agents and teams, enabling result offloading and a `result_store` handle with kernel fixes and execution bounds (3.0 S1). • Adds media offloading from the database to local, S3, or GCS storage backends. • Adds SuperGrok OAuth device-code authentication for the xAI model. • Adds workflow registry and zero-config Studio integration for workflows. • Makes `LearningMachine` the sole Studio memory surface, consolidating memory management.

Agno v3.0.0a2

Thu, 20 Aug 2026 10:42:03 GMT

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

Agno v2.9.0

Thu, 13 Aug 2026 12:08:15 GMT

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

Agno v2.9.0

Thu, 13 Aug 2026 12:08:15 GMT

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

Agno v2.8.7

Wed, 05 Aug 2026 14:44:53 GMT

Agno v2.8.7 adds AdvisorTools, OpenRouteService toolkit, and overridable FileSystemTools names • Adds `AdvisorTools` class for querying advisor models for feedback on agent outputs. • Adds `OpenRouteService` toolkit for accurate geospatial routing. • Allows overriding the `FileSystemTools` toolkit name via the toolkit's name parameter. • Adds component-aware schedule tools and history parameters to `StudioTools`.

Agno v2.8.7

Wed, 05 Aug 2026 14:44:53 GMT

Agno v2.8.7 adds AdvisorTools, OpenRouteService toolkit, and component-aware StudioTools with history parameters. • Adds `OpenRouteService` toolkit for accurate geographic routing. • Adds component-aware schedule tools and history parameters to `StudioTools`. • Allows overriding the `FileSystemTools` toolkit name at instantiation time.

Agno v2.8.6

Thu, 30 Jul 2026 13:51:21 GMT

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

Agno v2.8.6

Thu, 30 Jul 2026 13:51:21 GMT

Agno v2.8.6 adds SmallestAI TTS tools, OpenSearch vector DB support, and a new AgentOS metrics-refresh status endpoint. • Adds `OpenSearch` vector database backend at `agno.vectordb.opensearch` with vector, keyword, and hybrid search in sync and async variants; installable via the `agno[opensearch]` extra. • Adds `GET /metrics/refresh/status` AgentOS endpoint reporting `idle`, `running`, `completed`, or `failed` states with `started_at`, `finished_at`, and `error` fields so clients can poll for completion. • Exposes the new metrics-refresh status endpoint on the Python client as AgentOSClient.get_metrics_refresh_status(). • Adds `?background=true` query parameter to `POST /metrics/refresh` to return HTTP 202 immediately and run the refresh as a single-flight background task per database.

Agno v2.8.5

Mon, 27 Jul 2026 08:52:32 GMT

Agno v2.8.5 adds AgentOSTools for platform observability and Moonshot thinking-mode toggle with file/video input support. • Adds `AgentOSTools` class, a read-only platform operations toolkit that reports on AgentOS usage, latency, failures, schedules, evals, components, and pending approvals. • Adds `use_thinking` parameter to the Moonshot integration to toggle thinking mode. • Adds file and video input support to the Moonshot integration. • Adds latency and error stats grouped by agent, team, workflow, or endpoint — plus tool and model call stats — to Traces, implemented for `PostgresDb` and `SqliteDb`. Breaking changes: • The Moonshot integration default model is changed to `kimi-k3`; any setup relying on the previous default model will now use `kimi-k3` without an explicit override.

Agno v2.8.5

Mon, 27 Jul 2026 08:52:32 GMT

Agno v2.8.5 adds AgentOSTools for platform observability, Moonshot thinking mode, and file/video input support. • Adds `AgentOSTools` class providing a read-only platform operations toolkit to report on AgentOS usage, latency, failures, schedules, evals, components, and pending approvals. • Adds `use_thinking` parameter to the Moonshot integration to toggle thinking mode. • Adds file and video input support to the Moonshot integration. • Adds latency and error stats grouped by agent, team, workflow, or endpoint — plus tool and model call stats — to Traces, implemented for `PostgresDb` and `SqliteDb`. • Changes the Moonshot default model to `kimi-k3`. Breaking changes: • The Moonshot integration now defaults to `kimi-k3` instead of the previous default model; any setup relying on the former default will silently switch models on upgrade.

Agno v2.8.4

Sun, 26 Jul 2026 17:21:12 GMT

Agno v2.8.4 adds TrustedRouter as an OpenAILike model class and revamps entity memory for the second brain. • Adds `TrustedRouter` as an `OpenAILike` model class, enabling use of TrustedRouter as a model backend. • Revamps entity memory for the second brain, enhancing how agent memory stores and retrieves entities.

Agno v2.8.4

Sun, 26 Jul 2026 17:21:12 GMT

Agno v2.8.4 adds TrustedRouter as an OpenAILike model class and revamps entity memory for the second brain. • Adds `TrustedRouter` as an `OpenAILike` model class, enabling use of TrustedRouter as a model provider within the Agno SDK. • Revamps entity memory for the second brain, improving how agents store and recall structured entity information across conversations.

Agno v2.8.2

Fri, 24 Jul 2026 14:10:50 GMT

Agno v2.8.2 adds FileSystem, a durable per-agent persistent filesystem with pluggable DB/local backends. • Adds `FileSystem`, a new durable agent filesystem primitive giving agents a private, persistent filesystem with pluggable DB or local backends and fail-closed per-user namespace isolation.

Agno v2.8.2

Fri, 24 Jul 2026 14:10:50 GMT

Agno v2.8.2 adds FileSystem, a durable per-agent private filesystem with pluggable DB/local backends and per-user namespace isolation. • Adds `FileSystem`, a new durable state primitive that gives agents a private, persistent filesystem with pluggable database or local backends and fail-closed per-user namespace isolation.

Agno v2.8.1

Thu, 23 Jul 2026 19:12:01 GMT

Agno v2.8.1 adds Marengo video embeddings, Slack peer-agent comms flag, and a loop-guard for Learning Stores. • Adds `respond_to_other_agents` flag to the Slack integration to enable peer-agent communication between Slack-connected agents. • Adds `extraction_tool_call_limit` to Learning Stores to cap runaway tool calls and prevent infinite loops. • Adds `stream_sub_agent_events` support across all Context Providers. • Adds Marengo video embeddings support to `TwelveLabsTools`. Breaking changes: • The `google_search` method in `ScavioTools` now targets the Scavio Google v2 API, changing parameter mapping to `gl`, `hl`, and `start` for localization and paging — existing integrations relying on the v1 API will break.

Agno v2.8.1

Thu, 23 Jul 2026 19:12:01 GMT

Agno v2.8.1 adds Marengo video embeddings, a Slack peer-agent flag, and loop-prevention limits for learning stores. • Adds `respond_to_other_agents` flag to the Slack integration to enable peer-agent communication between Slack-connected agents. • Adds `extraction_tool_call_limit` to Learning Stores to cap tool calls and prevent infinite extraction loops. • Adds `stream_sub_agent_events` support across all Context Providers. • Adds Marengo video embedding support to `TwelveLabsTools`. Breaking changes: • The `google_search` tool in `ScavioTools` now targets the Scavio Google v2 API, changing localization and paging behavior for any existing integrations.

Agno v2.8.0

Mon, 20 Jul 2026 15:43:29 GMT

Agno v2.8.0 adds a scorer framework, rollout environments for pass@k evaluation, and new Gmail/Adanos/file-generation tools. • Adds `agno.scorer` module with `CodeScorer` (wraps any callable returning `bool | float | Score`), `JudgeScorer` (LLM judge with numeric verdicts normalized via `(score - 1) / 9`), and `ToolCallScorer` (deterministic check of tool executions, rejecting refused, errored, or HITL-rejected calls) — all three ship sync and async variants. • Adds `agno.environments` with `Environment`, `Task`, and run_rollouts(env, k=8) to run each task K times in full isolation (fresh db/session/user, no memory/knowledge/learning writes, cache off), enabling pass@k evaluation with a live per-attempt grid and real pass-rate tracking. • Adds to_sft_jsonl(...) on the rollout environment to export passing attempts as conversational-SFT JSONL with a provenance sidecar. • Adds `save`, `load`, `diff`, and learning_zone() methods to the rollout environment for managing and comparing evaluation runs. • Adds `Case.scorer` field to plug any scorer into an eval `Case` alongside `Case.expected`; SuiteResult.to_dict() gains additive `score_value`, `score_passed`, and `score_reason` keys. • Adds `max_results_per_request` parameter and pagination support to Gmail Tools. • Adds optional Adanos market sentiment tools. • Adds code file generation capability to `FileGenerationTools`. Breaking changes: • `ReliabilityEval` now satisfies tool expectations only on a clean execution via `RunOutput.tools` (with `tool_call_error` not set), not on message-side requests — verdicts that previously passed may flip red after upgrading, with missing entries annotated '... (requested but refused/errored — execution matching, new in 2.8.0)'. Argument checks move to `ToolExecution.tool_args`. • Every `AgentAsJudgeEval` now fences judged output behind a per-call random nonce; a literal `` no longer escapes the block. Judge verdicts and token counts may shift after upgrading.

Agno v2.7.4

Fri, 17 Jul 2026 09:22:24 GMT

Agno v2.7.4 adds SuperserveTools, PlivoTools, The Context Company observability, and expanded Telegram/Tavily/Google toolkit methods. • Adds `SuperserveTools` class to run agent-generated code and manage files inside Superserve, a Firecracker-based sandbox platform designed for long-running agents. • Adds `PlivoTools` class to send SMS, make voice calls, and look up phone numbers via Plivo. • Adds `pin_message`, `get_chat`, `get_file`, and `react_with_emoji` methods to `TelegramTools`, plus `save_downloads` and `output_directory` options to save downloaded files to disk. • Adds domain, date range, topic, and country filter parameters to `TavilyTools` searches. • Adds observability integration to trace agent runs with The Context Company. • Enhances `agno create` with interactive starter template and project name prompts, four new starters (`Azure`, `Helm`, `Modal`, `Render`), and automatic `.env` seeding. • Enables `OxylabsTools` to return full page content as Markdown. • Workflows now accept `run_context` in Router selectors and Condition evaluators (deprecating `session_state`).

Agno v2.7.3

Tue, 14 Jul 2026 15:16:56 GMT

Agno v2.7.3 adds ValkeyDb storage and vector store, RedmineTools, TokenLab provider, and AG-UI human-in-the-loop support • Adds `ValkeyDb` as a fast in-memory database backend for agents, teams, and workflows. • Adds `ValkeyDB` vector store with both vector and keyword search capabilities. • Adds `RedmineTools` to manage issues, comments, and time logs against a Redmine project management instance. • Adds `TokenLab` as a new OpenAI-compatible model provider. • Extends AG-UI with human-in-the-loop confirmation, input, and feedback flows.

Agno v2.7.2

Thu, 09 Jul 2026 11:34:42 GMT

Agno v2.7.2 adds OAuth on the AgentOS MCP endpoint, AG-UI client tools, and multi-target agno connect enhancements. • Adds `mcp_auth` parameter to AgentOS(...) to configure OAuth support on the AgentOS MCP endpoint. • Renames `AgentOS` parameter `enable_mcp_server` to `mcp_server` and folds in `mcp_config`. • Adds `client_tools` support for AG-UI frontend tools. • Enhances `agno connect` with multi-target select, `disconnect`, restart hints, and identity-named entries. Breaking changes: • The `enable_mcp_server` parameter on `AgentOS` is renamed to `mcp_server`; existing code using `enable_mcp_server` will break.

Agno v2.7.0

Tue, 07 Jul 2026 11:06:36 GMT

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

Agno v2.6.22

Fri, 03 Jul 2026 15:23:41 GMT

Agno v2.6.22 adds TwelveLabsTools, SofyaTools, and SearchApiTools plus a base Toolkit timeout parameter. • Adds `TwelveLabsTools` class for video analysis and multimodal text embedding generation via the TwelveLabs API. • Adds `SofyaTools` class exposing search, extract, and research capabilities. • Adds `SearchApiTools` class with Google, News, Images, and YouTube search methods. • Adds `timeout` parameter to the base `Toolkit` class, wiring HTTP timeouts across tools and extending timeout support to additional toolkits.

Agno v2.6.21

Thu, 02 Jul 2026 12:57:04 GMT

LocalFileSystemTools gains file-read support and directory confinement controls via new flags. • Adds `enable_read_file` flag to `LocalFileSystemTools` to expose a read-file tool to agents. • Adds `restrict_to_base_dir` flag to `LocalFileSystemTools` to confine all file operations within `target_directory` by default; set `restrict_to_base_dir=False` to opt out.

Agno v2.6.20

Fri, 26 Jun 2026 14:04:43 GMT

Agno v2.6.20 adds ClickHouse trace storage, Scavio search, LiteLLM structured outputs, and OpenAI web-search citations. • Enables `supports_native_structured_outputs` and `supports_json_schema_outputs` per-provider flags on LiteLLM to activate native structured outputs and JSON schema outputs. • Surfaces web-search citations on `response.citations` for `OpenAIChat` and `OpenAILike` providers. • Adds ClickHouseDB as a backend for high-volume trace ingest and OLAP scans. • Adds a new Scavio search toolkit integration. • Removes the hard cap on `quick_prompts` (previously limited to 3) per agent, team, or workflow in AgentOS. • Supports `FastAPI >= 0.137` so get_routes() lists every registered route.

Agno v2.6.19

Tue, 23 Jun 2026 13:54:00 GMT

Agno v2.6.19 adds tool-batch checkpointing with a unified `/continue` endpoint and a new `StudioTool` for dynamic agent/team/workflow composition. • Adds `StudioTool` toolkit for dynamic composition of agents, teams, and workflows at runtime. • Adds tool-batch-level checkpointing and a unified `/continue` endpoint supporting both regenerate and fork-a-run workflows, plus session forking support. • Extends `custom_patterns` on `PIIDetectionGuardrail` to accept raw regex strings in addition to compiled patterns. • ClickHouse and Pinecone vector DBs now expose their supported search types via get_supported_search_types().

Agno v2.6.15

Mon, 15 Jun 2026 17:56:05 GMT

Agno v2.6.15 adds identity-aware, scoped MCP tool registration via a single `MCPServerConfig` object • Adds `MCPServerConfig` to configure the AgentOS MCP server (`/mcp`): register custom tools (plain callables or Agno `@tool`/`Functions`), scope built-ins with `enable_builtin_tools=False`, filter with `include_tags`/`exclude_tags`, inject the authenticated caller's JWT subject via a declared `user_id` parameter (hidden from the client schema), gate calls with an `authorize` function, and enable DNS-rebinding protection via `allowed_hosts`/`allowed_origins` — all in data, no custom middleware classes required.

Agno v2.6.14

Fri, 12 Jun 2026 16:38:25 GMT

Agno v2.6.14 adds CRUD endpoints for learnings on AgentOS. • Adds create, read, update, and delete endpoints for learnings on AgentOS.

Agno v2.6.13

Wed, 10 Jun 2026 21:02:19 GMT

Agno v2.6.13 adds sub-agent event streaming, AgentOS registry auto-population, socket-based HITL workflows, and a Slack app manifest. • Sub-agent events from the context provider update tool now stream through to the parent run, enabling real-time observability of nested agent activity. • The AgentOS registry now auto-populates from agents, teams, and workflows, eliminating manual registration. • Adds socket support for human-in-the-loop (HITL) workflows, enabling interactive pause-and-resume over persistent socket connections. • Adds a Slack app manifest for the AgentOS interface, simplifying Slack app setup and deployment.

Agno v2.6.12

Fri, 05 Jun 2026 19:03:19 GMT

Agno v2.6.12 adds HTML file generation, AG-UI state events, and Tuning Engines as a new model provider • Adds Tuning Engines as a new model provider, expanding the range of backends agents can target. • Adds AG-UI state events support, enabling state change signaling within the AG-UI protocol. • Adds HTML file generation support with an example app, allowing agents to produce HTML file outputs. • Adds Latitude via OpenInference as an observability integration example. • Adds WorkOS example for role-based access control (RBAC). • Upgrades MiniMax default model to M3.

Agno v2.6.11

Tue, 02 Jun 2026 15:24:28 GMT

Agno v2.6.11 adds Task API and Monitor API tools for parallel web plus a new Manifest for AgentOS UI metadata. • Adds `Manifest` for per-entity AgentOS UI metadata configuration. • Adds Task API and Monitor API integration tools for parallel web workflows.

Agno v2.6.10

Tue, 02 Jun 2026 06:11:28 GMT

Agno v2.6.10 adds four new model providers, YouTools, DOCX generation, context-provider streaming, and a `files` field on `RunCompleted`. • Adds `files` field on the `RunCompleted` event, exposing generated files at run completion. • Adds `YouTools` class for You.com Search API integration. • Adds DOCX file generation support. • Adds `google-interactions` provider to the model string parser. • Adds knowledge and managers support in the agent registry. • Streams sub-agent events from context providers. • Persists cancelled runs properly for agents, teams, and workflows. • Adds Inception Labs model provider integration. • Adds Xiaomi MiMo model provider. • Adds MiniMax model provider (M2.7). • Adds Cloudflare AI Gateway model provider.

Agno v2.6.9

Thu, 21 May 2026 21:33:50 GMT

Agno v2.6.9 exposes full resolved approval records to post-hooks via `run_response.metadata["approval"]` • Adds `cookbook/07_knowledge/04_advanced/06_prefix_search.py` demonstrating the help-center typeahead use case for PgVector(prefix_match=True).

Agno v2.6.8

Tue, 19 May 2026 22:08:54 GMT

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

Agno v2.6.7

Fri, 15 May 2026 17:57:01 GMT

Agno v2.6.7 adds GeminiInteractions model, per-user AgentOS data isolation, and an `allowed_hosts` guard on URL-fetching knowledge readers. • Adds `GeminiInteractions` model class to leverage Google's stateful interactions API. • Adds `allowed_hosts` parameter to URL-fetching knowledge readers to restrict which hosts agents may fetch from. • Adds opt-in per-user data isolation layer for AgentOS authenticated endpoints.

Agno v2.6.6

Thu, 14 May 2026 07:34:15 GMT

Agno v2.6.6 adds Slack HITL multi-row approvals and a NotionDatabaseBackend for wiki context. • Adds `NotionDatabaseBackend` to the `WikiContextProvider`, enabling Notion databases as a knowledge source for agents. • Adds HITL multi-row approvals with all pause types to the Slack interface. • Warns on duplicate tool names when registering tools on an agent or team.

Agno v2.6.5

Wed, 06 May 2026 13:48:17 GMT

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

Agno v2.6.4

Tue, 28 Apr 2026 13:03:18 GMT

Agno v2.6.4 adds WikiContextProvider with filesystem, git, and web backends plus read/write control. • Adds `WikiContextProvider` class with filesystem and git backends, web ingestion support, and read/write flags for controlling access.

Agno v2.6.3

Tue, 28 Apr 2026 01:09:59 GMT

Agno v2.6.3 adds WorkspaceContextProvider for project-aware repo context and expands SlackContextProvider with opt-in workspace search. • Adds `WorkspaceContextProvider`, a project-aware context provider for repository roots backed by the read-only `Workspace` toolkit instead of generic `FileTools`; centralizes local filesystem exclude patterns so both `FileTools` and `Workspace` skip `.context`, `.venvs`, and other agent/dependency/build noise by default. • Adds `exclude_patterns` parameter to `FilesystemContextProvider` for explicit opt-out or customization of filesystem exclusions. • Adds opt-in `enable_workspace_search` parameter to `SlackContextProvider`; tools are now self-documenting via `SlackTools`, removing runtime agent switching. • Removes for_bot_read(), for_assistant_search(), and for_write() factory methods from `SlackContextProvider` in favor of explicit flags for direct construction. Breaking changes: • The for_bot_read(), for_assistant_search(), and for_write() factory methods have been removed from `SlackContextProvider`; callers must switch to explicit flags on construction.

Agno v2.6.2

Mon, 27 Apr 2026 14:24:18 GMT

Agno v2.6.2 adds a Workspace toolkit giving agents read/write/shell access to a local directory tree with HITL confirmation gates. • Adds `WorkspaceTools` toolkit exposing `read`, `list`, `search`, `write`, `edit`, `move`, `delete`, and `shell` operations scoped to a `root` directory tree, with destructive operations gated by Agno's built-in human-in-the-loop confirmation by default.

Agno v2.6.1

Fri, 24 Apr 2026 16:55:14 GMT

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

Agno v2.6.0

Thu, 23 Apr 2026 12:24:52 GMT

Agno v2.6.0 adds HITL for Teams and Workflows, runtime Factories, multi-framework AgentOS support, and a new Context Provider API. • Adds `AgentFactory`, `TeamFactory`, and `WorkflowFactory` for dynamically creating Agents, Teams, and Workflows at runtime, enabling multi-tenant use cases. • Adds `agno.context` — a first-party API for plugging external sources (filesystem, web, SQL database, Slack, Google Drive, MCP server) into an agent as a natural-language tool. • Adds an API layer for Team human-in-the-loop (HITL) with support in the `AgentOS` chat page, including Team Approvals. • Adds executor-level HITL support for Workflow steps (`WorkflowExecutor`) when a pause-tool flow is configured on an agent or team within a workflow step. • Adds reconnection and resume capability for Agent/Team runs using SSE in AgentOS, allowing interrupted sessions to continue from where they left off. • Adds multi-framework support (Beta) in AgentOS for `ClaudeAgentSDK`, `Langgraph`, and `DSPy` via a unified `AgentProtocol` backbone. Breaking changes: • The `/sessions` endpoint now returns all session types (agent, team, and workflow) by default instead of a filtered subset; existing callers that relied on a single type must add `?type=agent`, `?type=team`, or `?type=workflow` to their requests to restore the previous behaviour.

Agno v2.5.17

Wed, 15 Apr 2026 03:52:44 GMT

Agno v2.5.17 adds per-request GitHub repo targeting and a toggle to disable Claude file citations. • Adds option to disable Claude file citations (PR #7511). • Allows `GitHubConfig` repo to be specified per request rather than only at configuration time (PR #7496).

Agno v2.5.16

Fri, 10 Apr 2026 19:45:55 GMT

Agno v2.5.16 adds LLMsTxtTools, SalesforceTools, Azure AI Foundry Claude, and OpenAI Responses background mode • Adds `LLMsTxtTools` and `LLMsTxtReader` classes for consuming the llms.txt standard, enabling agents to index LLM-friendly documentation from sites that expose a `/llms.txt` endpoint (e.g. `https://docs.agno.com/llms.txt`). • Adds `SalesforceTools` for integrating Salesforce CRM data and actions into agents. • Adds Azure AI Foundry Claude as a new model provider. • Adds background mode support for the OpenAI Responses API.

Agno v2.5.15

Thu, 09 Apr 2026 06:41:35 GMT

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

Agno v2.5.14

Thu, 02 Apr 2026 20:28:41 GMT

Agno v2.5.14 adds fallback model chains for Agents and Teams, SAS token auth for Azure Blob, and a Slack workspace search tool. • Adds `fallback_models` parameter to `Agent` and `Team` constructors, letting you specify an ordered list of backup models (e.g. `Claude`) that are tried automatically when the primary model fails. • Adds SAS token authentication support to `AzureBlobConfig` for Azure Blob Storage connections. • Adds a workspace search tool to `SlackTools`.

Agno v2.5.13

Wed, 01 Apr 2026 01:29:59 GMT

Agno v2.5.13 adds a /info metadata endpoint, richer /sessions list fields, Slack show_member_tool_calls param, and ReliabilityEval subset matching. • Adds `show_member_tool_calls` param to the Slack Interface, plus automatic card overflow rotation that starts a new message when text exceeds the threshold. • Enhances the AgentOS `/sessions` list API to return additional fields: `user_id`, `agent_id`, `team_id`, `workflow_id`, `session_summary`, `metrics`, `total_tokens`, and `metadata`. • Adds the AgentOS `/info` API endpoint — a lightweight, unauthenticated call that returns agent, team, and workflow counts as instance metadata. • Adds subset matching, argument validation, and missing tool call tracking to `ReliabilityEval`, with multi-round tool call collection support. • Implements dynamic batch splitting for large upsert/query operations in ChromaDB. • Propagates `chunk_size` to default chunking strategies in reader classes. • Enables channel summarization in the Slack interface.

Agno v2.5.12

Mon, 30 Mar 2026 22:36:29 GMT

Agno v2.5.12 adds Docling tool integration and a new SchedulerTools toolkit for agent-driven schedule management. • Adds `SchedulerTools` toolkit, enabling agents to programmatically manage schedules. • Adds `DoclingTool` integration with tests and cookbook example for document parsing and conversion within agents.

Agno v2.5.11

Thu, 26 Mar 2026 17:35:20 GMT

Agno v2.5.11 adds Google Slides toolkit, GoogleAuth, PerplexitySearch, cross-model tool call compatibility, and custom prompts for AgenticChunking. • Adds `GoogleAuth` toolkit and shared auth decorator to unify authentication across Google toolkits. • Adds `GoogleSlidesTools` toolkit for creating, editing, and managing Google Slides presentations. • Adds `PerplexitySearch` toolkit for integrating Perplexity-powered web search into agents. • Adds custom prompt support to `AgenticChunking`, allowing callers to control how chunks are split. • Adds cross-model tool call compatibility to support interchanging models within the same agent pattern. • Rewrites `GoogleDriveTools` with smart export and async support.

Agno v2.5.10

Tue, 17 Mar 2026 17:14:15 GMT

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

Agno v2.5.9

Tue, 10 Mar 2026 15:30:33 GMT

Agno v2.5.9 adds built-in followup suggestions, `datetime_format`, message history in tool hooks, and extended GoogleCalendarTools. • Adds `datetime_format` parameter to `Agent` and `Team` for custom `strftime` formatting of datetime context (e.g., ISO-8601, date-only, localized). • Exposes the current run's message history to tool pre/post hooks and agent-level `tool_hooks` via `run_context.messages`, with mutation safety. • Adds built-in followup suggestion support to `Agent` and `Team`. • Extends `GoogleCalendarTools` with new tools and service account authentication support.

Agno v2.5.8

Fri, 06 Mar 2026 15:08:31 GMT

Agno v2.5.8 adds GitlabTools, human-readable agent IDs, GmailTools service-account auth, and AgentOS env-var overrides. • Adds `AGENT_OS_HOST` and `AGENT_OS_PORT` environment variables as fallbacks to serve(), simplifying container and orchestrated deployments. • Adds `GitlabTools` with read-focused GitLab integrations, async support, and cleaner tool configuration. • Extends `GmailTools` with new tools and service account authentication. • Agents and teams now generate Docker-style human-readable IDs (e.g., `brave-falcon-7x3k`) instead of UUIDs, making debugging and monitoring more intuitive.

Agno v2.5.7

Wed, 04 Mar 2026 17:47:34 GMT

Agno v2.5.7 adds OpenAILikeEmbedder and a two-step session search pattern with configurable depth limits. • Adds `OpenAILikeEmbedder` class for providers with OpenAI-compatible embedding endpoints (e.g. LiteLLM proxy). • Adds a `search_past_sessions` + `read_past_session` two-step pattern so agents and teams can browse previous sessions, with `num_past_sessions_to_search` and `num_past_session_runs_in_search` to control search scope and preview depth. • Adds `num_runs` parameter to `read_past_session` so the model can fetch a subset of turns from long sessions instead of pulling full conversation history. • Session previews in `search_past_sessions` now show per-run user/assistant pairs instead of a single message.

Agno v2.5.6

Mon, 02 Mar 2026 20:20:20 GMT

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

Agno v2.5.5

Wed, 25 Feb 2026 17:26:40 GMT

Agno v2.5.5 adds real-time Slack streaming, per-bot credentials, and image generation to ModelsLabTools. • Adds `token` and `signing_secret` per `Slack` instance, enabling multiple independent bots to run on the same server. • Extends `ModelsLabTools` to support image generation (PNG/JPG) via ModelsLab's text-to-image API, completing the full ModelsLab media suite. • Slack interface now streams responses in real-time with live progress cards for tool calls, reasoning, and workflow steps.

Agno v2.5.4

Tue, 24 Feb 2026 20:16:27 GMT

Agno v2.5.4 adds workflow step-level HITL, PgVector similarity filtering, team task streaming, and richer per-component metrics. • Adds `similarity_threshold` parameter to `PgVector` to filter search results by a minimum similarity score. • Exposes `timelimit`, `region`, and `backend` parameters in `DuckDuckGoTools` for more controlled web searches. • Adds Human-in-the-Loop (HITL) support at the Step level in Workflows, enabling pauses for confirmation and user input during execution. • Adds streaming event support for `TeamMode.tasks`, enabling real-time event emission during autonomous task execution. • Redesigns the metrics system to provide per-model, per-component granular tracking across the full agent/team/workflow lifecycle.

Agno v2.5.3

Thu, 19 Feb 2026 20:59:36 GMT

Agno v2.5.3 adds remote S3 knowledge endpoints, PDF content sanitization, and OpenTelemetry extras. • Adds `sanitize_content` parameter to `BasePDFReader` (enabled by default) to normalize fragmented PDF text extraction — collapses word-per-line artifacts while preserving paragraph breaks; set `sanitize_content=False` to preserve structured content like code or tables. • Adds API endpoints for listing remote knowledge contents and enables uploading content in S3 buckets via AgentOS. • Adds `is_component`, `current_version`, and `stage` fields to list endpoints. • Adds OpenTelemetry and Agno instrumentation dependencies to the `os` extras.

Agno v2.5.1

Sun, 15 Feb 2026 21:36:02 GMT

Agno v2.5.1 adds CodingTools and UserFeedbackTools toolkits for agents. • Adds `CodingTools` toolkit for code-related operations in agents. • Adds `UserFeedbackTools` toolkit for collecting user feedback from within agents.

Agno v2.5.0

Thu, 12 Feb 2026 14:19:06 GMT

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

Agno v2.4.8

Tue, 03 Feb 2026 13:29:30 GMT

Agno v2.4.8 adds CEL expression support for serializable workflow steps, a Neosantara LLM provider, and a visual Studio editor for AgentOS. • Adds CEL (Common Expression Language) expression support as evaluators in `Condition`, `Loop`, and `Router` workflow steps, making steps fully serializable as strings. • Adds `step_choices` support in the `Router` step's selector function, enabling the router to return a group of steps as a single choice. • Adds `Neosantara` as a new model provider — an Indonesian LLM gateway with an OpenAI-compatible API. • Adds shebang parsing and Windows command building to `Skills` for cross-platform script execution. • Introduces Studio: a visual drag-and-drop editor in AgentOS for building Agents, Teams, and Workflows, with a Registry for managing tools, models, databases, and schemas. • `WebsiteReader` now defaults to `FixedSizeChunking` instead of Semantic chunking, removing the implicit dependency on an OpenAI API key.

Agno v2.4.7

Wed, 28 Jan 2026 23:52:22 GMT

Agno v2.4.7 adds `else_steps` for workflow conditions, a new `AwsBedrockReranker`, and HITL confirmation support for MCPTools. • Adds `else_steps` to workflow condition logic, enabling an alternative execution path instead of skipping when a condition is not met. • New `AwsBedrockReranker` class supporting Cohere Rerank 3.5 and Amazon Rerank 1.0. • Enables `MCPTools` to work with `requires_confirmation_tools`, adding human-in-the-loop confirmation support for MCP tool calls. • Extends `AwsBedrockEmbedder` to support Cohere v4 Embed.

Agno v2.4.5

Mon, 26 Jan 2026 23:17:29 GMT

Agno v2.4.5 adds Seltz Search toolkit and a new parameter to suppress knowledge search instructions in system prompts. • Adds `add_search_knowledge_instructions` parameter to `Agent` and `Team` classes to control whether knowledge search instructions are injected into the system prompt. • New `SeltzTools` toolkit integrating Seltz Search as a tool source for agents.

Agno v2.4.4

Mon, 26 Jan 2026 21:53:13 GMT

Agno v2.4.4 adds UnsplashTools image search, Moonshot model provider, and a new `external_execution_silent` tool decorator param. • Adds `external_execution_silent` parameter to the tool decorator to suppress placeholder strings from run response content during external tool execution. • Adds `UnsplashTools` toolkit for searching and retrieving royalty-free images via the Unsplash API. • Adds Moonshot (moonshot.ai) as a new model provider.

Agno v2.4.3

Fri, 23 Jan 2026 15:39:57 GMT

Agno v2.4.3 adds ExcelReader for .xls and .xlsx knowledge ingestion • Adds `ExcelReader` class for ingesting `.xls` and `.xlsx` files as knowledge sources

Agno v2.4.2

Thu, 22 Jan 2026 15:48:02 GMT

Agno v2.4.2 adds Azure Blob Storage knowledge support and OpenAI Responses API compatibility for Ollama and OpenRouter. • Adds Azure Blob Storage as a private file-loading source for Knowledge, alongside the existing SharePoint and GitHub integrations. • Adds support for the OpenAI Responses API specification for providers that implement it, including Ollama v0.13.3+ and OpenRouter (beta).

Agno v2.4.1

Wed, 21 Jan 2026 15:52:37 GMT

Agno v2.4.1 adds N1N model provider, Excel knowledge ingestion, and private GitHub/SharePoint file support. • Adds `collect_metrics_on_completion` flag to streaming runs, collecting metrics only from the final chunk rather than every streamed chunk. • Adds `tool_call_id` to `CustomEvent` objects yielded from tools, enabling trace events to be linked back to their originating tool calls. • Adds n1n.ai as a new OpenAI-compatible model provider. • Adds first-class Excel ingestion (`.xlsx`/`.xls`) to Knowledge, parsing workbooks per sheet into separate documents with sheet metadata by routing through the existing CSV reader. • Adds support for files in private GitHub and SharePoint repositories to be added to Knowledge, available in both the SDK and API.

Agno v2.4.0

Mon, 19 Jan 2026 13:07:04 GMT

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

Agno v2.3.26

Tue, 13 Jan 2026 07:16:43 GMT

Agno v2.3.26 adds per-request isolation for agents, teams, and workflows in shared FastAPI processes. • Improves request-level isolation for agents, teams, and workflows running in shared FastAPI processes, preventing state bleed between concurrent requests.

Agno v2.3.25

Mon, 12 Jan 2026 16:29:59 GMT

Agno v2.3.25 adds LearningMachine for per-interaction agent learning and an AST-based CodeChunking strategy. • Adds `LearningMachine`, a unified learning system that coordinates multiple learning types — each with its own storage backend and retrieval pattern — so agents can learn from every interaction. • Adds `CodeChunking` strategy that uses ASTs to split code into contextually relevant segments, complementing existing text-based chunkers.

Agno v2.3.24

Thu, 08 Jan 2026 12:24:49 GMT

Agno v2.3.24 adds proxy support for Crawl4aiTools, base-directory sandboxing for PythonTools and MLXTranscribeTools, and heading-level chunking for MarkdownChunker. • Adds `proxy_config` parameter to `Crawl4aiTools` for configuring proxy settings on the toolkit. • Adds `restrict_to_base_dir` parameter to `PythonTools` and `MLXTranscribeTools`; by default both tools now block operations outside their contextual base directory — pass `restrict_to_base_dir=False` to opt out. • Adds `split_on_headings` parameter to `MarkdownChunker` for fine-grained control over how chunks are separated. • MongoDB connection handshake now includes Agno version metadata, improving connection identification when multiple applications share a cluster. Breaking changes: • `PythonTools` and `MLXTranscribeTools` now disallow operating outside the base directory by default; existing code that relies on out-of-directory access will break unless `restrict_to_base_dir=False` is explicitly set.

Agno v2.3.23

Wed, 07 Jan 2026 15:09:25 GMT

Agno v2.3.23 adds async tool function support to Toolkit, automatically selected in async agent contexts. • Toolkit now supports async tool functions, automatically selected when the agent runs in an async context.

Agno v2.3.22

Tue, 06 Jan 2026 17:49:20 GMT

Agno v2.3.22 adds the Skills class, dynamic MCP headers, A2A remote agent support, and JWT audience validation. • Introduces the `Skills` class, enabling agents to be extended with capabilities defined by Anthropic's Agent Skill specification. • Adds `header_provider` function parameter to `MCPTools` instances, allowing dynamic header generation (e.g. rotating auth tokens or per-user IDs) on each MCP tool call. • Adds `audience` parameter to the `JWTMiddleware` constructor to set the expected audience when validating JWT tokens. • `MCPTools` now defaults to `StreamableHttp` as the transport when a URL is present for connecting to external MCP servers. • Adds `A2AClient` and support for the `a2a` protocol when using remote agents, enabling Google ADK agents to run as remote agents via AgentOS (beta). • Extends native reasoning support to OpenAI GPT-5.1 and 5.2, new Gemini 3, 3.5, and deepthink models, and new DeepSeek r1 and reasoner models.

Agno v2.3.21

Tue, 23 Dec 2025 13:31:13 GMT

Agno v2.3.21 brings AgentAsJudge evals to AgentOS with full run configuration and listing support. • AgentAsJudge evaluations are now fully supported on AgentOS: configure and trigger new runs, and view existing runs alongside other evals on the Evals page.

Agno v2.3.20

Mon, 22 Dec 2025 13:26:59 GMT

Agno v2.3.20 adds async run cancellation via set_cancellation_manager() and `reasoning_content` extraction for LiteLLM models. • Adds set_cancellation_manager() to allow custom cancellation managers, with async method support for run cancellation workflows. • Extracts `reasoning_content` from models that support it via the LiteLLM model wrapper.

Agno v2.3.18

Fri, 19 Dec 2025 18:50:20 GMT

Agno v2.3.18 adds Google OAuth2 credentials file support for direct VertexAI authentication. • Supports a Google OAuth2 credentials file for direct VertexAI authentication in the Google VertexAI integration.

Agno v2.3.17

Fri, 19 Dec 2025 15:49:28 GMT

Agno v2.3.17 adds RemoteAgent/Team/Workflow classes, AgentOSClient, and ChromaDB hybrid search with RRF fusion • Adds `RemoteAgent`, `RemoteTeam`, and `RemoteWorkflow` classes for proxying Agents, Teams, and Workflows running on a remote AgentOS instance. • Adds `AgentOSClient` class for connecting to and operating a remotely hosted AgentOS. • Adds hybrid search for local ChromaDB combining dense vector similarity (semantic) with full-text search (keyword/lexical) via RRF fusion. • Extends `SemanticChunking` to accept any Agno embedder (e.g. `AzureOpenAI`, `Mistral`), a model string, or a custom `chonkie` `BaseEmbeddings` implementation. • Extends the AgentOS client WebSocket implementation to automatically reconnect interrupted Workflow sessions via socket.

Agno v2.3.15

Thu, 18 Dec 2025 19:03:20 GMT

Agno v2.3.15 adds OpenRouter cost tracking in run metrics and a migrate-all-DBs endpoint via AgentOS. • Adds a `cost` field to run `Metrics` for OpenRouter-backed runs, enabling usage accounting across OpenRouter provider calls. • Adds an endpoint to migrate all databases at once via AgentOS.

Agno v2.3.14

Wed, 17 Dec 2025 21:44:38 GMT

Agno v2.3.14 adds reasoning streaming, new A2A endpoints, JSON schema structured outputs, and AgentOS reload controls. • Adds `reload_includes` and `reload_excludes` parameters to the `serve` function of AgentOS, letting you specify which files trigger an app reload. • Adds `search_parameters` to the `search` and `async_search` methods of the Milvus vector database class. • `output_schema` now accepts JSON schemas in provider-specific formats, passed directly to the model API without transformation, giving full control over structured output for OpenAI, Claude, and OpenAI-like providers. • Adds reasoning chunk streaming support when `reasoning_model` is provided. • Adds new A2A interface endpoints to retrieve the Agent Card for any Agent, Team, or Workflow, and updates run endpoints for Agents, Teams, and Workflows to match the updated A2A protocol. • Updates the default model ID for the Gemini Embedder class to `gemini-embedding-001`. • Error events are now always emitted during streaming runs, and runs containing errors are always persisted when relevant.

Agno v2.3.13

Mon, 15 Dec 2025 11:10:50 GMT

Agno v2.3.13 adds JWT-based Role-Based Access Control to AgentOS with per-endpoint and per-agent scope enforcement. • Adds `JWTMiddleware` class to AgentOS for JWT-based authorization, requiring signed JWT tokens with user permission scopes on all traffic — `verification_keys=[...]` is the new recommended way to supply keys over the deprecated `secret_key` parameter. • Supports per-endpoint authorization via configurable required scopes on each AgentOS endpoint. • Supports per-agent (and per-Team, per-Workflow) resource control via scopes like `agents:my-agent:read`, restricting which users can invoke `POST /agents/{id}/runs` or read from `GET /agents` and `GET /agents/{id}`. Breaking changes: • The `algorithm` default on `JWTMiddleware` changed from `HS256` to `RS256`; existing setups using the default with symmetric (HMAC) keys will fail to verify tokens on upgrade.

Agno v2.3.12

Fri, 12 Dec 2025 19:54:47 GMT

Agno v2.3.12 adds token-count-based context compression support across providers. • Adds token count based compression via the Compression Manager, enabling context window management across providers based on token limits. • Content hashing for knowledge ingestion now incorporates `name` and `description` fields for URLs, paths, and `file_data`, allowing multiple distinct content items from the same source to produce unique hashes. Breaking changes: • Existing knowledge content previously added with `name` or `description` fields will have different content hashes under v2.3.12, which may alter `skip_if_exists` and `upsert` behavior for that content.

Agno v2.3.11

Thu, 11 Dec 2025 17:11:59 GMT

Agno v2.3.11 adds OpenAI-specific fields to RunOutput and RunCompletedEvent for streaming and non-streaming access. • Adds new OpenAI-specific fields to `RunOutput` and `RunCompletedEvent` classes via `response_provider_data`, exposing provider data in both streaming and non-streaming cases.

Agno v2.3.10

Wed, 10 Dec 2025 21:37:46 GMT

Agno v2.3.10 adds ShopifyTools for store analytics and URL Context support for Gemini streaming. • Adds `ShopifyTools` toolkit to query Shopify store backends for sales analytics, customer insights, and related data. • Adds URL Context support for Gemini streaming requests.

Agno v2.3.9

Tue, 09 Dec 2025 16:28:19 GMT

Agno v2.3.9 adds AsyncMySQLDb, LLM-as-judge evals, run_id control, and OpenRouter reasoning support. • Adds `AsyncMySQLDb` class with support for the `asyncmy` driver, enabling fully async MySQL storage. • Adds `AgentAsJudgeEval` — an LLM-as-judge evaluation system that scores agent outputs against custom criteria using binary (pass/fail) or numeric (1–10) scoring, with support for standalone runs, post-hooks, background execution, and custom evaluator agents. • Adds `run_id` parameter to the `run` and `arun` methods on `Agent`, `Team`, and `Workflow` classes, allowing callers to supply a deterministic run ID instead of auto-generating one. • Adds `create_schema=False` parameter to database initializers (e.g. `PostgresDb`) to skip automatic schema creation for externally managed schemas. • Adds `introduction` parameter to `Agent` and `Team` to set the first assistant message in a conversation. • Adds `reasoning_content` field to DeepSeek messages, enabling thinking mode when tools are active. • Extends get_step_output() with recursive search so it finds steps nested inside `Parallel`, `Condition`, `Router`, `Loop`, and `Steps` groups. • Adds native sync support for all `add_content_` functions in Knowledge, replacing the previous `asyncio`-wrapping workaround. • Adds support for reasoning messages from OpenRouter.

Agno v2.3.8

Fri, 05 Dec 2025 15:28:11 GMT

Agno v2.3.8 adds model-level retry control via `retries=n` on the model object for provider rate-limit resilience. • Adds `retries=n` parameter at the model execution layer so rate-limit errors from model providers trigger retries directly on the model, independently of agent-level retries which continue to handle broader agent execution loop exceptions. Breaking changes: • `MemoriTools` has been removed; integrations using it must migrate to the updated Memori framework approach.

Agno v2.3.7

Thu, 04 Dec 2025 13:27:51 GMT

Agno v2.3.7 adds Amazon Redshift toolkit and revamps Human-in-the-Loop with a new RunRequirement class • Introduces the `RunRequirement` class to represent and resolve Human-in-the-Loop requirements; these objects appear in the Agent response or in the `RunPaused` event during streaming HITL flows. • Adds `yield_run_response` parameter to `continue_run` streaming methods, yielding a `RunOutput` object at the end of a continued run. • Adds Amazon Redshift toolkit for exploring Redshift databases and running queries. • Passes `run_context` into `get_relevant_documents_from_knowledge` so custom knowledge retrievers now have access to `dependencies`. • Enables Agno evals via AgentOS with Agents and Teams that use an asynchronous database class.

Agno v2.3.6

Wed, 03 Dec 2025 22:03:51 GMT

Agno v2.3.6 adds a Spotify toolkit for managing libraries from agent workflows. • Adds a Spotify toolkit enabling agents to manage a Spotify library programmatically.

Agno v2.3.5

Wed, 03 Dec 2025 14:28:35 GMT

Agno v2.3.5 adds OpenTelemetry-based native tracing and non-blocking background task hooks for agents and teams. • Introduces OpenTelemetry-based native tracing that automatically captures and stores agent runs, model calls, tool executions, and team operations in your Agno database. • Agent and Team pre- and post-hooks can now run as background tasks on AgentOS for fully non-blocking, concurrent execution — useful for notifications, logging, or evaluations not on the critical path. • Adds a debug-level environment variable for controlling Agno debug output. • Extends debug-level support to workflows. • Unifies model authentication errors across providers into a consistent error surface.

Agno v2.3.3

Thu, 27 Nov 2025 12:17:02 GMT

Agno v2.3.3 adds context compression, memory optimization, Gemini File Search, and runtime output schema overrides. • Adds `optimize_memories` and `aoptimize_memories` methods to `MemoryManager` for summarizing a user's memories outside of agent runs (beta). • Adds `output_schema` override support to run() and arun() on both `Agent` and `Team`, as well as AgentOS API endpoints, enabling per-call schema control at runtime. • Adds `api_key` support for AWS Bedrock authentication. • Adds `thinking_level` parameter support to `Gemini`. • Introduces Context Compression (beta): compresses tool call results in a running agent context to stay within context windows and avoid rate limits. • Adds Gemini File Search support, including document store create/list/get/delete, direct file upload with custom chunking configuration and metadata, document management with metadata filtering, citation extraction helpers, and full async/await support. See cookbooks: `cookbook/models/google/gemini/file_search_basic.py`, `cookbook/models/google/gemini/file_search_advanced.py`, `cookbook/models/google/gemini/file_search_rag_pipeline.py`. • Extends AWS Bedrock Claude compatibility with native Claude, adding support for thinking models and caching. • Extends VertexAI Claude compatibility with native Claude, adding support for thinking models and caching.

Agno v2.3.1

Fri, 21 Nov 2025 11:34:26 GMT

Agno v2.3.1 adds NanoBananaTools image generation, Claude structured output support, and MCPTools subclass registration in AgentOS. • Adds `NanoBananaTools` toolkit for generating images with Google's Nano Banana model. • Adds support for Anthropic's structured output functionality in Claude models, ensuring responses always conform to a given schema. • Enables custom toolkits that extend `MCPTools` or `MultiMCPTools` to be registered and used inside AgentOS.

Agno v2.3.0

Fri, 21 Nov 2025 09:44:52 GMT

Agno v2.3.0 adds MigrationManager, sound-effect generation, RedisCluster support, and overhauled session message/history APIs. • Introduces `MigrationManager` class to apply schema migrations for `sessions` and `memories` tables across PostgreSQL, SQLite, MySQL, and SingleStore backends. • Adds `get_messages` and `get_chat_history` methods to `AgentSession`, `TeamSession`, and `WorkflowSession` session classes, with full filtering capabilities. • Adds `get_session_messages` and `get_chat_history` methods to `Agent`, `Team`, and `Workflow` classes; adds `get_chat_history` to the `WorkflowStep` class. • Adds `show_member_responses` parameter to `Team.print_response` and `Team.aprint_response` to surface member-level outputs during streaming. • Adds `RedisCluster` support when configuring a `RedisDb` instance for agent database storage. • Adds sound-effect generation support to `ModelLabsTools` via `ModelsLab SFX`. • All model instances now share a global `httpx` client singleton with `http2` multiplexing enabled, improving resource use and instantiation speed. • Stateless knowledge-base filters now work correctly with AgentOS; using knowledge(...) filters requires setting `contents_db`. Breaking changes: • `delegate_task_to_all_members` parameter on `Team` is renamed to `delegate_to_all_members`; existing code using the old name will break. • `GoogleSearchTools` toolkit has been removed entirely; callers must switch to `DuckDuckGoTools`. • `stream_events` parameter has been removed from `print_response`, `aprint_response`, and CLI methods on `Agent`, `Team`, and `Workflow`. • `get_messages_for_session` has been removed from `Agent` and `Team`. • `get_messages_from_last_n_runs` has been removed from `Session`, `Agent`, and `Team`. • Using knowledge(...) with `knowledge_filters` now requires `contents_db` to be set; omitting it will break filtering. • The deprecated `AgentOS` parameters `os_id`, `fastapi_app`, `enable_mcp`, and `replace_routes` have been removed; use `id`, `base_app`, `enable_mcp_server`, and `on_route_conflict` respectively. • The default `Nebius` model endpoint changed from the AI Studio URL to `api.tokenfactory.nebius.com`; users targeting Nebius AI Studio must now explicitly pass that URL as `base_url`. • PostgreSQL `sessions` and `memories` tables require migration: `created_at` and `feedback` columns added to `memories`, and all JSON columns in `PostgresDb` converted to JSONB.

Agno v2.2.12

Fri, 14 Nov 2025 10:04:27 GMT

Agno v2.2.12 adds a metadata Filter DSL for Knowledge searches and a Slack mention-only reply mode • Adds `reply_to_mentions_only` parameter to the Slack interface, controlling whether agents respond to all channel messages or only direct mentions (now defaults to mentions-only). • Introduces a metadata-based Filter DSL for Knowledge searches supporting `EQ`, `IN`, `GT`, `LT`, `NOT`, `AND`, and `OR` expressions; PGVector-backed stores are supported in this release, with additional VectorDB support to follow. Breaking changes: • The Slack interface now defaults to replying only to mentions (`reply_to_mentions_only`); agents that previously answered all channel messages will silently stop doing so after upgrading unless `reply_to_mentions_only` is set to `False`.

Agno v2.2.11

Wed, 12 Nov 2025 12:34:07 GMT

Agno v2.2.11 adds ParallelTools for web search/extraction, Claude context editing, Anthropic beta access, and expanded Gmail label management. • Adds `ParallelTools` toolkit providing AI-optimized web search and content extraction via both direct API integration and MCP server support. • Enables all Anthropic API beta features on Agno Claude models via the `betas` parameter. • Adds `duration` field to top-level Workflow metrics, exposing total runtime of a complete Workflow run. • Extends the Gmail tool with label management: list custom labels, apply labels to emails, remove labels from emails, and delete custom labels.

Agno v2.2.10

Sat, 08 Nov 2025 03:55:57 GMT

Agno v2.2.10 adds `run_context` as the standard state-sharing parameter across Workflows and introduces `yield_run_output` for Agent/Team runs. • Adds `yield_run_output` flag on Agent/Team `run`/`arun` functions as the replacement for the to-be-deprecated `yield_run_response`. • Promotes `run_context` as the recommended parameter for reading and modifying state across all Workflow surfaces — Agents, Teams, tools, steps, and custom Python functions used in steps. • Improves event streaming from custom executor steps inside Workflows, including better handling of Agent/Team events emitted by a custom executor.

Agno v2.2.9

Fri, 07 Nov 2025 10:39:17 GMT

Agno v2.2.9 adds `strict_output` for schema-enforced model responses, AG-UI state mapping, and multi-table AgentOS support. • Adds `strict_output` parameter to all compatible models, guaranteeing generated responses adhere to the contextual `output_schema`; defaults to `True`. • Supports `knowledge_filters` parameter on AgentOS run endpoints. • Maps AG-UI request `state` data to `session_state` when running Agno Agents or Teams via the AG-UI integration. • Enables multiple Agno tables of the same type (e.g., multiple session tables) within the same database when using AgentOS. • Improves mapping of Agno `CustomEvent` events into AG-UI custom events with all relevant fields when streaming via the AG-UI interface. • Team members now automatically inherit the primary model from their parent team when no model is specified (secondary models `reasoning_model`, `parser_model`, and `output_model` are not inherited). • Renames preferred identifiers for Mongo and Redis vector DB implementations to `MongoVectorDb` and `RedisVectorDb`.

Agno v2.2.7

Wed, 05 Nov 2025 05:18:32 GMT

Agno v2.2.7 adds run_context access in tools/hooks, RedisVL vector DB support, vLLM embeddings, and MCP tool name prefixing. • Adds `tool_name_prefix` parameter to the `MCPTools` class to namespace all tool names for a given MCP server, preventing collisions when multiple MCP servers are in use. • Introduces `run_context` as an injectable parameter in tools, hooks, tool hooks, dependency functions, and instructions functions for unified access to run-level state. • Adds `RedisVL` as a supported VectorDB backend for Knowledge, enabling Redis-backed vector search. • Adds vLLM embedder support, allowing local or remote vLLM models to be used for embeddings in Knowledge pipelines.

Agno v2.2.6

Sat, 01 Nov 2025 01:14:39 GMT

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

Agno v2.2.5

Thu, 30 Oct 2025 15:32:25 GMT

Agno v2.2.5 preserves custom routers when reprovisioning AgentOS via lifespan functions. • Supports preservation and reprovisioning of all previously registered non-built-in routers when updating the AgentOS through a lifespan function.

Agno v2.2.4

Thu, 30 Oct 2025 14:35:02 GMT

Agno v2.2.4 adds `num_history_messages` for granular history control and AgentOS access in lifespan functions • Adds `num_history_messages` parameter to control how many messages are considered when retrieving agent history. • Enables access to the contextual `AgentOS` instance within FastAPI lifespan functions, allowing updates to the instance after initialization and first run. • Supports `Media` instances when providing run input as a dictionary (in addition to a list of `Message` objects).

Agno v2.2.3

Wed, 29 Oct 2025 03:32:32 GMT

Agno v2.2.3 adds AsyncMongoDb class for non-blocking MongoDB access in async agent flows. • Adds `AsyncMongoDb` class to support asynchronous MongoDB database operations in async agent and team workflows.

Agno v2.2.2

Wed, 29 Oct 2025 00:42:49 GMT

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

Agno v2.2.1

Thu, 23 Oct 2025 20:42:58 GMT

Agno v2.2.1 adds a PPTXReader class and `max_tool_calls_from_history` to control agent context size. • Adds `max_tool_calls_from_history` parameter to load a fixed number of tool calls from agent history, reducing token consumption and managing context size. • Adds `PPTXReader` class to support ingesting Microsoft PowerPoint (`.pptx`) files.

Agno v2.2.0

Wed, 22 Oct 2025 23:14:01 GMT

Agno v2.2.0 adds new Agent/Team events, `stream_events` flag, session state methods, and three new AgentOS session endpoints. • Adds `stream_events` flag to `Agent`, `Team`, `Workflow`, and all run methods to emit all events when streaming a response (previously tool-call events were always yielded; non-`RunContent` events are now gated behind this flag). • Adds `update_session_state` and `aupdate_session_state` methods on `Agent` and `Team` for direct, DB-persisted session state updates. • Adds `add_team_history_to_members` config on `Team` to share team-level request/response history with member agents. • Adds three new AgentOS session endpoints: `POST /sessions` (create a new empty session), `GET /sessions/{id}/runs/{id}` (get a run by ID), and `PATCH /sessions/{id}` (update an existing session). • Adds `PostHookStarted`, `PostHookCompleted`, `SessionSummaryCreationStarted`, `SessionSummaryCreationCompleted`, and `RunContentCompleted` events for both `Agent` and `Team`, enabling fine-grained UI streaming control. • Workflow `.arun` now returns an `AsyncIterator`, consistent with `Agent` and `Team`, enabling event-by-event async streaming. • Concurrent memory creation: automatic memory creation now starts in a background thread/task at the beginning of an `Agent`/`Team` run, reducing total run latency when memory generation is enabled. • Improves `get_run_output` and `get_last_run_output` on `Agent`/`Team` to support retrieval of runs from member agents after team execution. Breaking changes: • Workflow.arun(..., stream=True) now returns an `AsyncIterator`; callers must replace await workflow.arun(...) with async for event in workflow.arun(...). • All events except `RunContent` events are now gated behind `stream_events=True`; tool-call events that were previously always yielded will no longer appear unless `stream_events=True` is set. • `stream_intermediate_steps` is deprecated in favour of `stream_events`.

Agno v2.1.10

Tue, 21 Oct 2025 14:52:21 GMT

Agno v2.1.10 adds experimental Culture for collective agent learning, Gmail mark-as-read/unread tools, and standalone Knowledge on AgentOS. • Adds `mark-as-read` and `mark-as-unread` functions to the Gmail toolkit. • [Experimental] Introduces Culture, a shared space for agents to think, write, and build on each other's ideas, enabling collective learning across an agent group. • Enables Knowledge to be added and managed via any AgentOS interface without requiring it to be attached to an Agent or Team.

Agno v2.1.9

Mon, 20 Oct 2025 12:51:48 GMT

Agno v2.1.9 adds trackable message IDs and session_state propagation to Workflow Condition and Router steps. • Adds `id` field to the `Message` class, available on `RunOutput` message lists, enabling message tracking in storage. • Extends `session_state` access to `evaluator` and `selector` functions in `Condition` and `Router` Workflow Step classes.

Agno v2.1.8

Fri, 17 Oct 2025 15:12:05 GMT

Agno v2.1.8 adds class-based workflow executors, streaming post-hooks, Jira worklogs, and a renamed knowledge search endpoint. • Renames the knowledge search endpoint from `search_vectors` to `search_knowledge`. • Supports class-based executors in Workflows by defining a class that implements the `__call__` method. • Adds post-hook support on streaming flows. • Extends `JiraTools` toolkit to support creating worklogs. • Updates `GoogleCalenderTools` to notify attendees when creating, updating, or deleting calendar events. Breaking changes: • The knowledge search endpoint is renamed from `search_vectors` to `search_knowledge`; any client code calling `search_vectors` will break and must be updated.

Agno v2.1.6

Thu, 16 Oct 2025 18:34:10 GMT

Agno v2.1.6 adds SurrealDB support via new `SurrealDb` class and renames `store_tool_results` to `store_tool_messages` • Adds the `SurrealDb` class for complete SurrealDB integration with Agents, Teams, and Workflows. • Renames the `store_tool_results` flag to `store_tool_messages` for clarity; tool message pairs (tool result + the assistant message containing the corresponding tool call) are now removed together to maintain valid message sequences required by most model providers. Breaking changes: • The `store_tool_results` flag is renamed to `store_tool_messages`; any code or config referencing `store_tool_results` will break on upgrade.

Agno v2.1.5

Wed, 15 Oct 2025 16:53:00 GMT

Agno v2.1.5 adds async Postgres, knowledge search endpoints, workflow executor event filtering, and reasoning support for Gemini/Claude. • Adds `store_history_messages` and `store_tool_messages` flags to Agent and Team to control whether history and tool messages are persisted on run output. • Adds `stream_executor_events` to workflows for filtering events emitted by agents, teams, or custom functions — complementing the existing `stream_intermediate_events` (for workflow-level events like `WorkflowStarted`, `StepStarted`) and `stream_member_events` on Team. • Adds `access_log=True` parameter to serve() to re-enable AgentOS access logs, which are now off by default. • Adds async Postgres support across the library for non-blocking database operations. • Adds knowledge search endpoints to the AgentOS API, enabling vector database searches via the AgentOS API. • Adds service account authentication support to `GoogleSheetsTools`. • Adds native reasoning model support for Gemini 2.5+, Anthropic Claude, and VertexAI Claude when used as reasoning models with Agents. • Allows MCP server URLs without the conventional `/mcp` path segment when using `MCPToolbox`. Breaking changes: • AgentOS access logs are now disabled by default; existing setups relying on access logging must explicitly pass `access_log=True` to serve() to restore the previous behavior.

Agno v2.1.4

Fri, 10 Oct 2025 15:15:01 GMT

Agno v2.1.4 adds workflow history, a GoogleDriveTools class, AG-UI custom events, and tool post-hooks on failure. • Adds `GoogleDriveTools` class to give agents read and write access to Google Drive. • Adds workflow history support, enabling continuous conversational context across all or individual workflow steps. • Extends tool post-hooks to also execute when a tool run fails with an exception, enabling failure-specific cleanup or logging logic. • AG-UI integration now delivers Agno custom events to the AG-UI interface in the standard AG-UI custom event format. • Parallel step event streaming in workflows now yields events immediately as they are produced rather than collecting all events and yielding at the end.

Agno v2.1.3

Wed, 08 Oct 2025 17:52:13 GMT

Agno v2.1.3 adds Claude on Vertex AI, OpenRouter fallback models, and MCP server support for custom FastAPI apps • Enables AgentOS instances running a custom FastAPI base app to be exposed as MCP servers via the `enable_mcp_server` parameter. • Adds a new `Claude` model class for serving Claude models through Vertex AI. • Adds fallback model support to the `OpenRouter` class, allowing multiple models to be defined so that if the primary model fails a fallback is used automatically. • Agents, Teams, and Workflows exposed via an AgentOS MCP server can now use MCP tools themselves. • Updates `FileTools` toolkit to handle relative paths across all its methods.

Agno v2.1.2

Tue, 07 Oct 2025 15:53:42 GMT

Agno v2.1.2 adds an A2A interface for AgentOS and a field-labelled CSV reader for structured knowledge ingestion. • Adds `A2A` interface to AgentOS, enabling Agents, Teams, and Workflows to be exposed and run in Agent-to-Agent (A2A) compatible format. • Adds a field-labelled CSV reader that preserves field–value relationships when ingesting CSV knowledge data. • Supports passing `user_id` in the `forwarded_props` field when initiating an AG-UI run. • Extends AgentOS API routers to accept additional file types, including more audio formats. • Supports local binary paths (e.g. `./script`) as MCP server commands in `MCPTools` and `MultiMCPTools` classes.

Agno v2.1.1

Fri, 03 Oct 2025 19:48:05 GMT

Agno v2.1.1 adds a `prefix` option for AGUI, WhatsApp, and Slack interfaces to support multiple interfaces on one AgentOS instance. • Adds a `prefix` parameter to `AGUI`, `Whatsapp`, and `Slack` interfaces, enabling multiple interfaces to run on the same AgentOS instance with distinct route prefixes.

Agno v2.1.0

Wed, 01 Oct 2025 11:31:47 GMT

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

Agno v2.0.11

Fri, 26 Sep 2025 19:30:24 GMT

Agno v2.0.11 adds metadata fields to LiteLLM and improves AgentOS MCP tool and DB registration logic. • Adds `metadata` and additional fields to the `LiteLLM` model class, enabling richer model configuration and request context. • Improves AgentOS logic for finding and registering MCP tools when setting up an AgentOS instance. • Improves AgentOS logic for finding and registering DBs, now rejecting incompatible DB instances that share the same IDs.

Agno v2.0.10

Thu, 25 Sep 2025 21:35:25 GMT

Agno v2.0.10 adds `overwrite_db_session_state` flag to overwrite persisted session state in the database. • Adds `overwrite_db_session_state` flag to overwrite the session state persisted in the database, enabling clean session resets without manual DB intervention.

Agno v2.0.9

Wed, 24 Sep 2025 19:48:42 GMT

Agno v2.0.9 adds MCP Toolbox for Databases, Ollama Cloud support, bulk DB writes, and session_state in AgentOS run endpoints. • Adds `session_state` and `dependencies` parameters to AgentOS run endpoints, enabling callers to pass session context directly into agent runs. • New `MCP Toolbox` toolkit integrates Google's MCP Toolbox for Databases, giving agents structured access to database tools via the MCP protocol. • Ollama `Model` class now supports Ollama Cloud via an API key, enabling cloud-hosted Ollama model inference alongside local deployments. • All database implementations now support bulk writes, allowing multiple Sessions and Memories to be persisted in a single DB call. • Workflows can now be used in AgentOS together with the Slack interface. • New methods added to the Scrape Graph Toolkit. • Storage layer now raises critical errors on read/write failures rather than silently logging them, surfacing DB issues to callers. Breaking changes: • Storage errors that were previously logged silently are now raised as exceptions; code that relied on silent failure on DB read/write errors will now encounter raised exceptions.

Agno v2.0.8

Mon, 22 Sep 2025 18:09:52 GMT

Agno v2.0.8 adds CometAPI as a model provider, `allow_partial_failure` for MultiMCPTools, and `dependencies` access inside custom tools. • Adds `allow_partial_failure` flag to `MultiMCPTools` toolkit, letting multi-server MCP setups continue when individual servers fail. • Exposes `dependencies` as a built-in argument on custom tools, making injected dependencies directly accessible inside tool function bodies. • Adds CometAPI as a new model provider. • Supports multiple `text_contents` entries in add_contents() on Knowledge, enabling bulk text ingestion in a single call.

Agno v2.0.7

Thu, 18 Sep 2025 15:55:24 GMT

Agno v2.0.7 adds a `LlamaCpp` Model class for local Llama CPP inference and a `chat_history` field to `TeamSessionDetailSchema`. • Adds `LlamaCpp` Model class, enabling local Llama CPP model support as a first-class model backend. • Adds `chat_history` field to `TeamSessionDetailSchema`, exposing team session conversation history via the schema.

Agno v2.0.6

Thu, 18 Sep 2025 01:07:43 GMT

Agno v2.0.6 adds FileGenerationTools for PDF/CSV/JSON/TXT output and a new Nexus Router Model class. • Adds `FileGenerationTools` toolkit, enabling agents to generate file artifacts in PDF, CSV, JSON, and TXT formats. • Adds a `Model` class for the Nexus Router, exposing it as a first-class model provider. • Stores the main workflow input in `WorkflowRunOutput` and persists it to the database.

Agno v2.0.5

Wed, 17 Sep 2025 02:44:35 GMT

Agno v2.0.5 adds `replace_routes=False` for custom FastAPI integration, Discord user ID context, and DuckDuckGo `search_engine` param. • Adds `replace_routes=False` parameter to AgentOS custom FastAPI integration, letting existing routes take precedence over AgentOS routes instead of being overwritten by default. • Adds `userid` in context for Discord integration, making the caller's identity available to agents handling Discord events. • Updates DuckDuckGo tools with a new `search_engine` parameter for configurable search engine selection. • Extends the v1 → v2 migration script to support metrics parsing and MongoDB migrations. • Adds accurate token metric tracking for the OpenAI Responses API.

Agno v2.0.4

Fri, 12 Sep 2025 20:02:32 GMT

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

Agno v2.0.3

Wed, 10 Sep 2025 21:02:24 GMT

Agno v2.0.3 adds WorkflowTools, MemoryTools, Gemini TTS, and custom encoding support for reader classes. • Adds `WorkflowTools` class, usable as a tool for agents and teams to run workflows from within an agent, with reasoning support via think/analyze. • Adds `MemoryTools` class, usable as a tool for agents and teams to add, update, and delete memories, with reasoning support via think/analyze. • Adds `encoding` parameter support on the reader class, allowing custom text encoding to be passed when reading documents. • Adds support for additional `kwargs` on `AgentOS` API run endpoints, enabling extra arguments when running an agent, team, or workflow via AgentOS. • Adds Gemini Text to Speech (TTS) support.

Agno v1.8.2

Mon, 08 Sep 2025 19:29:13 GMT

Agno v1.8.2 adds `response_model` structured output support for AG-UI and Discord, plus `updated_at` on session responses. • Adds `response_model` support to AG-UI, enabling structured output from agents in AG-UI apps. • Adds `response_model` support to `DiscordClient`, enabling structured output from agents in Discord apps. • Adds `updated_at` field to `AgentSessionResponse` and `TeamSessionResponse`. • Extends JSON Schema constraint support for Gemini models.

Agno v1.8.1

Wed, 27 Aug 2025 16:27:17 GMT

Agno v1.8.1 adds Neo4j graph tools, OpenAI reasoning summaries, and timezone support for Teams. • Adds `Neo4jTools` class to explore and manipulate graphs in a Neo4j database from within agents. • Adds reasoning summary support to the `OpenAIResponses` class for OpenAI reasoning models. • Adds `timezone_identifier` field to `Team`, bringing it to parity with the existing `Agent` functionality. • Allows `OpenAIChat` to accept both `httpx.Client` and `httpx.AsyncClient` for custom HTTP client configuration.

Agno v1.8.0

Mon, 25 Aug 2025 13:01:56 GMT

Agno v1.8.0 adds MemoriTools, file inputs for Workflows, agentic crawling, and Vertex AI Search support. • Adds `MemoriTools` toolkit, enabling Agents and Teams to interact with GibsonAI's Memori memory service. • Adds `agentic_crawler` parameter to `ScrapeGraphTools` for agentic web crawling. • Adds `files=[]` parameter to `Workflow.run` and `Workflow.arun` for passing file inputs directly to workflow runs. • Adds Vertex AI Search support to the Gemini model integration. • Updates `DuckDuckGoTools` to work with the `ddgs` package (replaces `duckduckgo-search`). Breaking changes: • `DuckDuckGoTools` now requires the `ddgs` package instead of `duckduckgo-search`; users must install `ddgs` for DuckDuckGo search to function.

Agno v1.7.12

Wed, 20 Aug 2025 20:46:41 GMT

Agno v1.7.12 adds Team collaborate streaming, OpenAI verbosity control, Gemini URL context tool, Vertex AI embedder support, and DynamoDB throughput config. • Adds `verbosity` parameter to `OpenAIChat` and `OpenAIResponses` for controlling OpenAI output verbosity. • Allows specifying DynamoDB provisioned throughput when initializing `DynamoDbStorage`, enabling capacity control at construction time. • Adds Vertex AI support for `GeminiEmbedder`, enabling Gemini embeddings via the Vertex AI backend. • Adds streaming support for `Team` in `collaborate` mode, delivering incremental output for multi-agent collaborative workflows. • Adds support for the Gemini URL context tool, enabling Gemini models to fetch and reason over web URLs as context.

Agno v1.7.11

Thu, 14 Aug 2025 12:31:44 GMT

Agno v1.7.11 adds InMemoryStorage, TrafilaturaTools, DashScope/Qwen models, BrandfetchTools, and Bedrock File support. • Adds `InMemoryStorage` class for lightweight, optionally persistence-backed session storage, compatible with custom backends such as AWS S3 and Snowflake. • Adds `TrafilaturaTools` SDK for web scraping and text extraction using the Trafilatura library. • Adds `DashScope` integration class to run Qwen models natively. • Adds `BrandfetchTools` toolkit (sync and async) for agents to fetch brand information and assets via the Brandfetch API. • Adds `workers` parameter to the FastAPI app for controlling concurrency. • Adds `File` input support for compatible AWS Bedrock models. • Adds async hybrid search support for the Milvus vector database integration.

Agno v1.7.10

Tue, 12 Aug 2025 16:26:23 GMT

Agno v1.7.10 adds GPT-5 support, password-protected PDF ingestion, GitHub pagination, and a Team role parameter. • Adds `role` parameter to the `Team` class for defining a team's purpose and specialization. • Adds password-protected PDF support to `PDFKnowledgeBase` for ingesting secured documents into knowledge bases. • Supports GPT-5 via the `OpenAIResponses` class. • Adds pagination with metadata for GitHub Tools.

Agno v1.7.9

Thu, 07 Aug 2025 21:09:16 GMT

Agno v1.7.9 adds reranker support in PgVector hybrid search and page-number-aware PDF chunking • Adds `stream_intermediate_steps` support when using an output model, enabling streaming of intermediate agent steps alongside structured output. • Adds reranker support to PgVector hybrid search, allowing result re-ranking in vector+keyword search pipelines. • Adds page number handling to PDF Readers, including a flag to control whether pages are split during chunking.

Agno v1.7.8

Wed, 06 Aug 2025 20:10:16 GMT

Agno v1.7.8 adds `output_model` for Agents and Teams, OpenAI `service_tier` support, Gemini thinking, and Google toolkit enhancements. • Adds `output_model` parameter to `Agent` and `Team` classes, letting the final response be generated by a separate model rather than the primary `model`. • Adds `service_tier` field to `OpenAIChat` and `OpenAIResponses` to enable OpenAI Flex Processing. • Adds Gemini thinking output to responses via the Gemini integration. • Adds custom port support for the Google Sheets Toolkit authentication flow. • Enhances Google Calendar toolkit with unified authentication.

Agno v1.7.7

Thu, 31 Jul 2025 20:50:10 GMT

Agno v1.7.7 adds sync-friendly MCP integration, Morph code-edit tools, Claude interleaved thinking, and LiteLLM file/image inputs. • Revamps `MCPTools` and `MultiMCPTools` so both classes can be initialized and used without an async context manager, simplifying synchronous workflows. • Introduces `MorphTools` (Morph Fast Apply model) as a callable tool for intelligently merging code with update snippets at 98% accuracy and 4500+ tokens/second. • Adds support for Claude interleaved thinking — reasoning steps interspersed between other content blocks in `Claude` model responses. • Adds file and image input support to `LiteLLM` for multimodal understanding workflows. • Upgrades `ZepTools` compatibility to Zep v3.

Agno v1.7.6

Thu, 24 Jul 2025 14:35:51 GMT

Agno v1.7.6 adds Portkey models, BitbucketTools, JinaEmbedder, EvmTools, LinkupTools, RowChunking, and non-blocking Workflows 2.0 background execution. • Adds `BitbucketTools` class for interacting with Bitbucket Cloud repository APIs from an agent. • Adds `JinaEmbedder` class for using Jina-hosted embedding models. • Adds `EvmTools` class for executing transactions on EVM-compatible blockchains via the `web3` library. • Adds `LinkupTools` class for web search capabilities inside agents. • Adds `RowChunking` as a CSV-specific chunking strategy for document ingestion. • Adds Portkey hosted model support, enabling Portkey as a model provider. • Introduces background (non-blocking) execution for Workflows 2.0, with polling support for retrieving results. • Adds async execution support (`ainvoke`) for the AWS Bedrock model integration. • Adds new tools to the `Daytona` agent toolkit. • Adds AG-UI support for frontend tool calls and surfacing backend tool calls.

Agno v1.7.5

Thu, 17 Jul 2025 21:21:07 GMT

Agno v1.7.5 adds SurrealDB as a vector DB backend and `cache_session` control for memory management. • Adds `cache_session` attribute to agent/session configuration, allowing users to disable session caching for improved memory management. • Adds SurrealDB support as a vector database backend for knowledge bases. • Adds Workflows 2.0 support inside `FastAPIApp`, enabling the new workflow engine to run as a FastAPI application.

Agno v1.7.4

Wed, 16 Jul 2025 08:40:32 GMT

Agno v1.7.4 ships a redesigned step-based Workflows 2.0 (beta) and Pydantic model input support for Agent and Team. • Adds Workflows 2.0 (beta), a complete redesign of the workflow system using a step-based architecture that supports sequential, parallel, conditional, and loop-based execution, dynamic step routing, mixed components (agents, teams, and functions), and shared session state across steps. • Both `Agent` and `Team` now accept a Pydantic model as structured input on run() and print_response().

Agno v1.7.3

Tue, 15 Jul 2025 22:32:14 GMT

Agno v1.7.3 adds session_state on agent/team runs and GCSPDFKnowledgeBase for Google Cloud Storage PDFs. • Adds `GCSPDFKnowledgeBase` class to load and query PDFs stored on Google Cloud Storage as a knowledge base source. • Adds `session_state` parameter to agent and team run calls, allowing callers to pass initial session state at invocation time.

Agno v1.7.2

Thu, 10 Jul 2025 15:49:31 GMT

Agno v1.7.2 adds MySQLStorage backend, XAi live search, OpenAI deep research models, and memory growth tracking. • Adds `MySQLStorage` class as a session storage backend for agents, teams, and workflows. • Adds `memory_growth_tracking` attribute on `PerformanceEval` to enable debug logs for memory growth during performance evaluations. • Adds `agent` and `team` as optional parameters in tool hooks for greater flexibility. • Supports live search on the XAi model provider. • Supports `o4-mini-deep-research` and `o3-deep-research` OpenAI model identifiers.

Agno v1.7.1

Fri, 04 Jul 2025 08:11:55 GMT

Agno v1.7.1 adds debug_level to Agent/Team, Gemini thinking params, Valyu/Oxylabs toolkits, and new Serper tools. • Adds `debug_level` parameter (int `1` or `2`) to both `Agent` and `Team` classes for controlling logging verbosity, with `2` enabling more verbose model logs. • Adds `thinking_budget` and `include_thoughts` parameters to the `Gemini` model class for configuring Gemini thinking behavior. • Adds `parser_model` parameter support to `Team` for structured output via a dedicated parser model. • Adds `search_news`, `search_scholar`, and `scrape_webpage` tools to the Serper toolkit. • New `OxylabsTools` toolkit for web-scraping capabilities in agents. • New Valyu toolkit for deep search of academic sources.

Agno v1.7.0

Thu, 26 Jun 2025 18:26:25 GMT

Agno v1.7.0 adds add_tool(), streaming structured output, and a Linear teams tool • Adds add_tool(tool) convenience method to `Agent` and `Team` to append new tools after initialisation. • Streaming with `response_model` now stays in streaming mode: calling run(..., stream=True) or arun(..., stream=True) with a `response_model` set returns `Iterator[RunResponseEvent]` / `AsyncIterator[RunResponseEvent]` instead of switching off streaming; the structured output appears on `RunResponseContentEvent` and the final `RunResponseCompletedEvent`. • Adds a Linear tool to retrieve the list of teams (`get_team_details`). Breaking changes: • Calling run(..., stream=True) or arun(..., stream=True) on `Agent` or `Team` with a `response_model` set no longer returns a single `RunResponse` object — it now returns `Iterator[RunResponseEvent]` / `AsyncIterator[RunResponseEvent]`. Code that consumed the old single-object response must be updated to iterate over events instead.

Agno v1.6.4

Mon, 23 Jun 2025 21:16:56 GMT

Agno v1.6.4 adds Brightdata web scraping, OpenCV webcam capture, DiscordClient bot integration, and a FileTools search method. • Adds `search` method to `FileTools` for searching files within the toolkit. • Adds Brightdata Toolkit with multiple web-based tools including web scraping and data feed capabilities. • Adds OpenCV Video/Image Toolkit with tools for capturing images and video via webcam. • Adds `DiscordClient` app for connecting an agent or team to Discord as a Discord bot. Breaking changes: • `SerperApiTools` is renamed to `SerperTools`; any code importing or referencing `SerperApiTools` will break.

Agno v1.6.3

Wed, 18 Jun 2025 10:05:31 GMT

Agno v1.6.3 adds `store_events` to RunResponse, metadata filtering for CSV knowledge bases, and user control flows on the Playground. • Adds `store_events` parameter to `RunResponse`/`TeamRunResponse` to optionally persist all events that occurred during an agent or team run. • Adds metadata filtering support for `csv` and `csv_url` knowledge base types. • Adds user control flows support on the Agno Platform Playground. • Shows team member responses during team runs on the Agno Platform Playground. • Shows behind-the-scenes activity during agent and team runs on the Agno Platform Playground. Breaking changes: • Async knowledge-base function names (e.g. `asearch_knowledge_base`) are renamed to match their sync counterparts — any model function-calling configuration referencing the old `a`-prefixed names will stop working.

Agno v1.6.1

Fri, 13 Jun 2025 15:27:15 GMT

Agno v1.6.1 adds Nebius embeddings, Firestore memory/storage, async DocumentKnowledgeBase, and enum support in custom tools. • Adds `stream_member_events` to team configuration to optionally disable streaming of member events. • Adds `agent_name` to agent events and `team_name` to team events in event payloads; adds `team_session_id` to team-member events. • Adds `enum` parameter support in custom tools across all models. • Adds `async` support to `DocumentKnowledgeBase`. • Adds Nebius as a supported embedding model provider. • Adds Firestore as a memory and storage provider for agents.

Agno v1.6.0

Tue, 10 Jun 2025 19:15:04 GMT

Agno v1.6.0 overhauls streaming events for agents, teams, and workflows with granular typed events and member-event propagation. • Adds `RunResponseContent`, `RunError`, `RunCancelled`, `ToolCallStarted`, and `ToolCallCompleted` event types to agent streaming runs via agent.run(..., stream=True) or agent.arun(..., stream=True). • Adds `RunStarted`, `RunCompleted`, `ReasoningStarted`, `ReasoningStep`, `ReasoningCompleted`, `MemoryUpdateStarted`, and `MemoryUpdateCompleted` intermediate event types for agents when `stream_intermediate_steps=True`. • Adds `RunResponse.status` attribute indicating whether a run response is `RUNNING`, `PAUSED`, or `CANCELLED`. • Adds team-scoped streaming event types — `TeamRunResponseContent`, `TeamRunError`, `TeamRunCancelled`, `TeamToolCallStarted`, `TeamToolCallCompleted` — plus intermediate events (`TeamRunStarted`, `TeamRunCompleted`, `TeamReasoningStarted`, `TeamReasoningStep`, `TeamReasoningCompleted`, `TeamMemoryUpdateStarted`, `TeamMemoryUpdateCompleted`) when `stream_intermediate_steps=True`. • Teams now propagate and yield streaming events from individual team members as they execute, surfacing member-level activity in the top-level event stream. • Workflows now support `WorkflowRunResponseStartedEvent` and `WorkflowRunResponseCompletedEvent` events for structured run lifecycle signalling. Breaking changes: • `RunResponse` no longer has an `event` attribute; code reading `RunResponse.event` will break. • Streaming run events are reformulated — existing code consuming the old event shapes from agent.run(..., stream=True) or agent.arun(..., stream=True) must be updated to the new typed event types. • Team streaming events are reformulated with new `Team`-prefixed event types; existing code consuming team stream events must be updated. • Workflows must now yield `WorkflowRunResponseStartedEvent` and `WorkflowRunResponseCompletedEvent`; workflows that do not yield these events will be missing lifecycle signals.

Agno v1.5.10

Sat, 07 Jun 2025 04:29:24 GMT

Agno v1.5.10 adds Playground file upload, async evals, and an Exa Research tool integration. • Adds `research` tool to `ExaTools`, enabling deep research queries against Exa's research API directly from agents. • Adds async support to all evaluations, allowing evals to run non-blocking in async workflows. • Adds file upload support to the Agno Playground, routing PDF, CSV, DOCX, and other files directly to agents/teams or to an attached knowledge base.

Agno v1.5.9

Thu, 05 Jun 2025 19:40:13 GMT

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

Agno v1.5.8

Tue, 03 Jun 2025 13:56:14 GMT

Agno v1.5.8 adds SlackApp, VisualizationTools, BraveSearch toolkit, and reworks FastAPIApp/WhatsappAPI serving • Adds `SlackApp` class to build Slack-connected agents that respond to direct messages, group chats, and automatically create threads for replies. • Adds `VisualizationTools` toolkit (backed by `matplotlib`) giving agents the ability to generate graphs. • Adds `BraveSearch` toolkit so agents can search the web via the Brave Search API. • Adds `infer` as a parameter to `Mem0Tools`, exposing inference control in the memory toolkit. • Passes `knowledge_filters` through when `self.add_references=True` (traditional RAG path), keeping filter behavior consistent with Agentic RAG. • `FastAPIApp` now exposes a .serve() method on the instance, replacing the standalone `serve_fastapi_app` function, and the run endpoint moves from `/run` to `/runs`. • `WhatsappAPI` now exposes a .serve() method on the instance, replacing the standalone `serve_whatsapp_app` function. Breaking changes: • `FastAPIApp` no longer has a default `prefix`, and the run endpoint is renamed from `/run` to `/runs` — any client or integration hitting `/run` will break. • `serve_fastapi_app` is replaced by .serve() on the `FastAPIApp` instance — call sites using the standalone function will break. • `serve_whatsapp_app` is replaced by .serve() on the `WhatsappAPI` instance — call sites using the standalone function will break.

Agno v1.5.6

Thu, 29 May 2025 18:49:48 GMT

Agno v1.5.6 adds Team Evals, async Workflow support via `arun`, and an Anthropic MCP connector tool. • Adds `arun` method to Workflows, enabling async Python usage of the Workflow class. • Revamps `tool_call_limit` to enforce the limit across an entire agent run, not per-call. • Adds evaluation (Evals) support for Teams, extending the existing eval framework to multi-agent team configurations. • Adds `team_session_state` management on the `Team` class, propagating shared state to all members and sub-teams. • Improves performance of user memory updates and session summary generation by parallelising writes. Breaking changes: • Managing `team_session_state` now requires setting it on the `Team` object directly instead of via `session_state`; existing code using `session_state` for this purpose will no longer propagate team session state correctly.

Agno v1.5.5

Tue, 27 May 2025 10:29:48 GMT

Agno v1.5.5 adds Claude file upload, prompt caching, Qdrant hybrid search, Markdown knowledge bases, and AI/ML API integration. • Adds `search_previous_sessions_history` to enable a get_previous_session_messages(number_of_sessions: int) tool that lets agents retrieve and analyse messages from the last N sessions. • Adds `expire` key to Redis storage configuration to set TTL on Redis keys. • Adds `cache_creation_input_tokens` to agent session metrics for tracking Anthropic prompt-cache write statistics. • Supports direct file upload to Anthropic for use as agent input (Claude File Upload). • Enables Python code execution in a secure, sandboxed environment via the Claude 4 Code Execution Tool. • Adds prompt caching for Anthropic models, allowing resumption from specific prompt prefixes to reduce processing time and cost on repetitive tasks. • Adds support for Vercel v0 models. • Adds Qdrant hybrid search support. • Adds native `MarkdownKnowledgeBase` support for Markdown-based knowledge bases. • Integrates the AI/ML API platform, providing access to 300+ models including DeepSeek, Gemini, and ChatGPT at enterprise-grade rate limits. • Adds support for `Pydantic` and `dataclass` objects as direct inputs to agent tool functions.

Agno v1.5.4

Fri, 23 May 2025 15:37:12 GMT

Agno v1.5.4 adds Human-in-the-loop control flows, a Mem0 memory toolkit, and Firecrawl web search support. • Adds @tool(requires_confirmation=True) decorator to pause agent runs and require explicit user confirmation before a tool executes. • Adds @tool(requires_user_input=True) decorator to halt agent execution and prompt for user input before continuing. • Adds @tool(external_execution=True) decorator to signal that a tool function will be executed outside the agent context. • Adds UserControlFlowTools() — include it in an agent to enable dynamic, model-driven user-input pauses anywhere in a run. • Adds `agent.continue_run` and `agent.acontinue_run` methods to resume a paused agent run after user control flow requirements are satisfied. • Adds a `Mem0` toolkit for managing memories inside Mem0 from within an agent. • Adds Firecrawl web search support inside `FirecrawlTools`. • Adds MongoDB hybrid search support for vector store retrieval. • Adds an `auto_suggest` parameter to the Wikipedia toolkit's `summary` function.

Agno v1.5.3

Wed, 21 May 2025 15:09:47 GMT

Agno v1.5.3 improves accuracy evaluation methodology for more reliable agent-based assessment. • Updates the accuracy evaluation mechanism to use a more precise agent-based approach for measuring agent performance.

Agno v1.5.2

Tue, 20 May 2025 18:12:55 GMT

Agno v1.5.2 adds FastAPI/WhatsApp app wrappers, Couchbase vector DB, BigQuery tools, and async S3 readers • Adds `FastAPIApp` class — a convenience wrapper that spins up a FastAPI server exposing an `agent` or `team` with minimal boilerplate. • Adds `WhatsappAPIApp` class — implements the WhatsApp protocol so an Agno agent can run on WhatsApp, with image/audio/video input, image response generation, and reasoning support. • Adds `stop_after_tool_call_tools` and `show_result_tools` properties to the base `Toolkit` class, mirroring the per-tool behavior previously only available via the `@tool` decorator. • Enables `cosmos_compatibility=True` on the MongoDB vector DB class to add Azure Cosmos DB for MongoDB (vCore) as a supported vector store backend. • Adds Couchbase as a supported vector DB for knowledge bases. • Adds async support for `pdf` and `text` S3 readers. • Adds a Google BigQuery toolkit for querying BigQuery from agents. • Extends knowledge-base filters (manual and agentic) to work with Teams, not just individual agents. • 72% speed improvement to `WebsiteReader._extract_main_content`, unlocking faster large-scale web knowledge ingestion.

Agno v1.5.1

Fri, 16 May 2025 16:31:51 GMT

Agno v1.5.1 adds Nebius as a model provider, extends vector DB filter support to pgvector/Milvus/Weaviate/Chroma, and adds SSL to Redis storage. • Adds `ssl` parameter to the `Redis` storage class, enabling encrypted connections to Redis backends. • Adds Nebius (Nebius Studio) as a new model provider via an OpenAI-compatible interface. • Extends filtering support to additional vector databases: pgvector, Milvus, Weaviate, and Chroma.

Agno v.1.5.0

Tue, 13 May 2025 20:03:46 GMT

Agno v1.5.0 adds Azure OpenAI DALL-E image generation, OpenTelemetry auto-instrumentation, Milvus hybrid search, and streamable-HTTP MCP transport. • Adds `hybrid_search` support to the Milvus vector DB integration. • Adds streamable-HTTP transport support for MCP servers via `MCPTools`. • Adds an OpenInference auto-instrumentor for Agno agents, enabling tracing to any OpenTelemetry-compatible provider (Arize, Langfuse, Langsmith). • Adds Azure OpenAI image generation via DALL-E through Azure AI Foundry. • Adds ability to run accuracy evaluations with pre-generated answers; `agent`, `prompt`, and `expected_answer` are now accepted fields on the accuracy eval class. Breaking changes: • The performance evaluation class `PerfEval` is renamed to `PerformanceEval`; any code referencing `PerfEval` will break. • The accuracy evaluation class now requires three fields — `agent`, `prompt`, and `expected_answer` — that were not previously required; existing instantiations omitting these fields will break. • Duplicate information has been removed from streaming events when `stream=True` during concurrent agent runs; consumers that relied on that duplicated data in individual events will need to update their handling.

Agno v1.4.7

Tue, 13 May 2025 14:55:16 GMT

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

Agno v1.4.6

Sat, 10 May 2025 21:38:46 GMT

Agno v1.4.6 adds Cerebras model support, Claude web search, and metadata-filtered knowledge bases with agentic filter detection. • Adds `knowledge_filters` parameter to Agent(...) initialization and to agent.run(...) calls for explicit metadata-based document filtering in knowledge bases. • Adds `enable_agentic_knowledge_filters=True` on `Agent` to let the agent automatically detect and apply knowledge filters extracted from user queries. • Adds `metadata` parameter to `PDFKnowledgeBase` path entries and to knowledge_base.load_document(path=..., metadata=...) for attaching filterable metadata at ingest time. • Adds `current_user_id` and `current_session_id` as default variables in `session_data` for tools, making user and session context available inside tool execution. • Adds Cerebras as a model provider (both OpenAILike and SDK integrations). • Adds support for Claude's web search tool. • Knowledge Base metadata filtering (beta) supports `PDF`, `Text`, `DOCX`, `JSON`, and `PDF_URL` knowledge base types, and `Qdrant`, `LanceDB`, and `MongoDB` vector databases.

Agno v1.4.5

Tue, 06 May 2025 15:30:08 GMT

Agno v1.4.5 adds AWS Bedrock embeddings, Gemini video generation, and a revamped Apify integration. • Adds `AwsBedrockEmbedder` class for generating embeddings via AWS Bedrock, defaulting to the `cohere.embed-multilingual-v3` model. • Adds video generation capabilities to `GeminiTools`. • Revamps `ApifyTools` for full compatibility with Apify actors.

Agno v1.4.4

Sun, 04 May 2025 07:21:08 GMT

Agno v1.4.4 adds async retrievers, OpenAI File uploads, Gemini video URLs, and expanded Llama model capabilities. • The `retriever` parameter now accepts an `async` function, enabling async custom retrieval with `agent.arun` and `agent.aprint_response`. • Adds support for attaching `File` objects to prompts for agents using `OpenAIChat` models, including PDF and document uploads. • Adds Video(url=...) input support for Gemini models. • Expands Llama and LlamaOpenAI model classes with structured output and image input support.

Agno v1.4.3

Wed, 30 Apr 2025 13:23:06 GMT

Agno v1.4.3 adds native Llama API model classes, AWS session token support for Claude, and DynamoDB profile-based auth. • Adds native SDK and OpenAI-like model classes for the Llama API. • Adds AWS session token support for Claude, enabling use of credentials from assumed IAM roles. • Adds AWS profile-based authentication support for DynamoDB. • Adds reasoning model support for `o4-mini` (and anticipated `o4`) in the OpenAI reasoning model class.

Agno v1.4.2

Thu, 24 Apr 2025 21:26:30 GMT

Agno v1.4.2 adds MCP SSE transport, tool hooks, shared team session state, and new Cartesia, Gemini, and Groq tool integrations. • Adds MCP SSE transport support, enabling agents to connect to SSE MCP Servers alongside the existing transport options. • Adds tool hooks that wrap around all tool calls for both `Toolkits` and custom tools, enabling pre/post-call logic across every tool invocation. • Adds shared `Team Session State` — a single state dictionary accessible across a team leader and all team members via tools given to the leader or members. • Adds `CartesiaTool` for text-to-speech capabilities using Cartesia. • Adds a Gemini image tool for generating images using Gemini models. • Adds Groq audio tools for audio translation, transcription, and generation using Groq models. • Expands result sets returned by `PubmedTools`. • Allows custom tools to return any type — the return value is now handled and converted automatically before being passed to the model.

Agno v1.4.1

Wed, 23 Apr 2025 17:28:09 GMT

Agno v1.4.1 adds meeting notification sending and richer PubMed article data to its toolkits. • Adds option in the Google Calendar / meeting toolkit to send meeting notifications to attendees when creating or updating events. • Enhances `PubmedTools` with more comprehensive article data, returning additional metadata fields beyond basic citation info.

Agno v1.4.0

Wed, 23 Apr 2025 11:24:32 GMT

Agno v1.4.0 promotes Memory to GA, adds OpenAITools and ZepTools, and brings include/exclude tool filtering to all toolkits. • Adds `include_tools` and `exclude_tools` parameters to all toolkits, enabling selective enabling/disabling of individual tools inside larger toolkits. • Adds `OpenAITools` class to enable text-to-speech and image generation through OpenAI's APIs. • Adds `ZepTools` and `AsyncZepTools` classes to manage Agent memories via `zep-cloud`. • Promotes Agentic user Memory management from beta to generally available, with `enable_user_memories` and `enable_session_summaries` now set directly on the Agent or Team. • Adds reasoning model support (e.g. Deepseek-R1) via Azure AI Foundry. Breaking changes: • Agents now default to the new `Memory` class instead of the deprecated `AgentMemory`; `agent.memory.messages` is replaced by `run.messages for run in agent.memory.runs` (or agent.get_messages_for_session()). • `create_user_memories` is renamed to `enable_user_memories` and must now be set directly on the Agent or Team. • `create_session_summary` is renamed to `enable_session_summaries` and must now be set directly on the Agent or Team.

Agno v1.3.5

Mon, 21 Apr 2025 17:55:43 GMT

Agno v1.3.5 adds async support for five vector DBs, reasoning events on RunResponse, and Google Gemini cache support. • Populates `reasoning_content` on `RunResponse` for all reasoning types across stream/non-stream and async/non-async modes, with a unified JSON structure for `Reasoning events`. • Adds async support for ClickHouse, ChromaDB, Cassandra, PineconeDB, and Pgvector vector database backends. • Adds Google Gemini caching support: cache files and send cached content to Gemini models.

Agno v1.3.4

Sat, 19 Apr 2025 02:22:22 GMT

Agno v1.3.4 adds a web browser tool, proxy support for URL and PDF readers, and improved memory management. • Adds `proxy` parameter to the URL reader, enabling requests through a proxy when fetching remote content. • Adds `proxy` parameter to the PDF reader, enabling proxy-routed PDF retrieval. • Adds `client_params` argument support to `AzureOpenAIEmbedder`, allowing custom client parameters to be passed through. • Adds `mode` attribute to `Team` class data serialization, exposing team mode in serialized output. • Adds a new `webbrowser` tool for agents to interact with web browsers. • Improves memory management with updates to the Memory system for better session and memory handling. • Gives database session state preference over in-memory session state for more consistent agent state persistence.

Agno v1.3.3

Thu, 17 Apr 2025 19:44:46 GMT

Agno v1.3.3 adds Ollama and AzureOpenAI reasoning support, Gemini file upload, and expanded token metrics. • Adds audio, reasoning, and cached token counts to metrics where available across models. • Enables native reasoning model support for Ollama and AzureOpenAI providers. • Enables direct use of uploaded files with Gemini models.

Agno v.1.3.2

Wed, 16 Apr 2025 20:10:37 GMT

Agno v1.3.2 adds Redis as a Memory storage backend and new agent convenience methods for session and user memory retrieval. • Adds `add_member_tools_to_system_message` to team configuration, allowing the member tool names to be removed from the system message sent to the team leader for broader transfer-function compatibility. • Adds agent.get_session_summary() method to retrieve the previous session summary from an agent. • Adds agent.get_user_memories() method to retrieve the current user's memories from an agent. • Supports Redis as a storage provider for `Memory`, enabling persistent memory backed by Redis. • Supports additional instructions on `MemoryManager` and `SessionSummarizer` for customizing memory behavior. • Supports skipping SSL verification for Confluence connections when required.

Agno v1.3.0

Sun, 13 Apr 2025 00:48:44 GMT

Agno v1.3.0 revamps Memory with a new class, adds user/session params to agent.run(), and ships Redis session storage. • Adds `user_id` and `session_id` parameters to agent.run(), scoping memory access to a single user and session to enable multi-user, multi-session applications from one agent configuration. • Introduces a new `Memory` class (beta) supporting add, update, delete, and semantic search over user memories, with agent-driven memory management. • Adds Redis as a session storage provider.

Agno v1.2.16

Fri, 11 Apr 2025 11:45:34 GMT

Agno v1.2.16 adds knowledge bases with agentic RAG to Teams, mirroring existing Agent functionality. • Adds `knowledge`, `retriever`, and `search_knowledge` fields to `Team`, enabling knowledge bases and agentic RAG on teams (previously only available on `Agent`). • Improves Teams task forwarding reliability and makes the team leader more conversational, with new reasoning-with-teams examples.

Agno v1.2.14

Tue, 08 Apr 2025 15:43:16 GMT

Agno v1.2.14 adds expanded GithubTools, async MongoDB VectorDB support, and `stream_intermediate_resp` on `print_response`. • Adds `stream_intermediate_resp` parameter to `print_response` for streaming intermediate responses. • Expands `GithubTools` with many additional capabilities. • Adds async support for MongoDB as a vector database, enabling use in async knowledge bases. • Converts all utility scripts to be Windows-compatible.

Agno v1.2.12

Tue, 08 Apr 2025 00:47:19 GMT

Agno v1.2.12 adds ReasoningTools, timezone-aware agents, and Google Cloud JSON session storage • Adds `timezone_identifier` parameter to the `Agent` class to include the agent's timezone alongside the current date in its instructions. • Adds `ReasoningTools` class providing an advanced reasoning scratchpad for agents. • Adds JSON-based session storage on Google Cloud via a new Google Cloud Storage backend for memory/session state. • Extends `async`/`await` support to `URLKnowledgeBase`, `FireCrawlKnowledgeBase`, and `DocxKnowledgeBase` for non-blocking knowledge base operations. • Enables thinking support for the `@tool` decorator.

Agno v1.2.10

Sat, 05 Apr 2025 17:03:40 GMT

Agno v1.2.10 adds KnowledgeTools for agent-driven thinking, searching, and document analysis over a knowledge base. • Adds `KnowledgeTools` class enabling agents to think, search, and analyse documents within a knowledge base.

Agno v1.2.9

Sat, 05 Apr 2025 09:09:31 GMT

Agno v1.2.9 adds `MultiMCPTools` for connecting agents to multiple MCP servers in a single interface. • Adds `MultiMCPTools` class to connect agents to multiple MCP servers simultaneously, with a simplified interface that only accepts `command`. • Updates Gemini model support for structured outputs when tools are in use. Breaking changes: • The `MCPTools` interface now only allows `command` to be passed; any previously supported parameters beyond `command` will no longer be accepted.

Agno v1.2.8

Fri, 04 Apr 2025 16:24:09 GMT

Agno v1.2.8 adds `instructions` and `add_instructions` to `Toolkit` so tool usage guidance flows into the model system message. • Adds `instructions` and `add_instructions` fields to the `Toolkit` class, allowing per-toolkit usage instructions to be injected into the model's system message when `add_instructions=True`.

Agno v1.2.7

Wed, 02 Apr 2025 20:22:57 GMT

Agno v1.2.7 adds Gemini image generation, async knowledge base/vector DB support, and result caching on all toolkits. • Adds image generation via the `gemini-2.0-flash-exp-image-generation` model, enabling agents to produce images directly through Gemini. • Adds result caching to all Agno Toolkits and any custom functions decorated with `@tool`. • Adds `async`/`await` support to `LanceDb`, `Milvus`, and `Weaviate` vector DBs, enabling use in `agent.arun` and `agent.aprint_response`. • Adds `async`/`await` support to `JSONKnowledgeBase`, `PDFKnowledgeBase`, `PDFUrlKnowledgeBase`, `CSVKnowledgeBase`, `CSVUrlKnowledgeBase`, `ArxivKnowledgeBase`, `WebsiteKnowledgeBase`, `YoutubeKnowledgeBase`, and `TextKnowledgeBase`. • Enables knowledge_base.aload() for async knowledge base loading, substantially increasing ingestion speed in async contexts.

Agno v1.2.5

Thu, 27 Mar 2025 15:23:59 GMT

Agno v1.2.5 adds E2B sandbox code execution, MCP tool filtering, async @tool() decorator, and team-leader tool support. • Adds `tools` and `tool_call_limit` parameters to `Team`, allowing the team leader itself to be equipped with tools and act as an agent. • Expands `MCPTools` with include/exclude filtering so you can restrict which tools from an MCP server the model can access. • The @tool() decorator now supports async functions, including async pre- and post-hooks. • Adds `E2BTools` to run code inside an E2B Sandbox.

Agno v1.2.4

Tue, 25 Mar 2025 16:19:56 GMT

Agno v1.2.4 makes `tool_choice` configurable on Teams and adds Teams playground endpoints. • Adds `tool_choice` configuration support to Teams, enabling control over tool selection behavior at the team level. • Adds Teams playground endpoints for interacting with multi-agent teams via the playground interface.

Agno v1.2.2

Mon, 24 Mar 2025 21:48:26 GMT

Agno v1.2.2 adds tool call visibility for Teams. • Adds support for showing tool calls in Teams, making agent collaboration steps visible during multi-agent workflows.

Agno v1.2.0

Mon, 24 Mar 2025 15:10:28 GMT

Agno v1.2.0 adds Financial Datasets and Docker tool integrations, plus reasoning for Teams and simplified MCPTools creation. • Simplifies creation of `MCPTools` for connecting agents to external MCP servers. • Adds `FinancialDatasetsTools` for accessing data from financialdatasets.ai. • Adds Docker tools for managing local Docker environments from within an agent. • Enables reasoning support for Teams.

Agno v1.1.16

Fri, 21 Mar 2025 22:05:21 GMT

Agno v1.1.16 adds async Qdrant VectorDB support and a Claude Think Tool integration. • Adds async support for Qdrant VectorDB, enabling non-blocking vector database operations for improved performance and efficiency. • Introduces the Claude Think Tool, implementing Anthropic's 'think tool' pattern to give Claude agents an explicit reasoning step before responding.

Agno v1.1.15

Fri, 21 Mar 2025 13:56:19 GMT

Agno v1.1.15 adds function result caching for 9 tool classes and improves tool-call display in print_response. • Adds result caching to `DuckDuckGoTools`, `ExaTools`, `FirecrawlTools`, `GoogleSearchtools`, `HackernewsTools`, `NewspaperTools`, `Newspaper4kTools`, `Websitetools`, and `YFinanceTools` to speed up iteration, avoid rate limits, and reduce costs during agent testing. • Tool calls are now rendered in a separate panel from the response panel when using `print_response` and `aprint_response`, including when combined with `response_model`.

Agno v1.1.14

Thu, 20 Mar 2025 13:57:26 GMT

Agno v1.1.14 ships Teams 2.0 with three coordination modes, LiteLLM support, and a new `use_json_mode` parameter. • Adds `Team` class supporting three modes — `'collaborate'`, `'coordinate'`, and `'route'` — replacing the old Agent(team=[]) pattern with a dedicated first-class teams implementation. • Adds `use_json_mode: bool = False` parameter to `Agent` and `Team`; when combined with `response_model=YourModel`, forces JSON-mode output instead of the new default of native structured output — making `response_model` the only setting required for structured output. • Adds `debug_mode=True` on `Agent`/`Team` and team.print_response(...) to surface revamped debug logs for both agents and teams. • Adds LiteLLM support as a native model implementation and via the existing `OpenAILike` interface. • Enables `WebsiteTools` to update combined knowledgebases alongside standard knowledgebases. • Adds agentic shared context between team members and sharing of individual team member responses across the team. • Supports passing images, audio, and video to member agents in team workflows, and enables structured output returns from member agents in `'route'` mode. Breaking changes: • `Agent.structured_output` is replaced by `Agent.use_json_mode`; the old parameter is deprecated and will be removed in a future major version. • `Agent.team` is deprecated with the release of the new `Team` implementation and will be removed in a future major version; migrate to the `Team` class.

Agno v.1.1.13

Fri, 14 Mar 2025 14:01:07 GMT

Agno v1.1.13 adds OpenAI File Search, web/document citations, and Cohere Command A support • Adds support for OpenAI's built-in `File Search` tool in `OpenAIResponses`, automatically uploading `File` objects attached to agent prompts. • Adds extraction of URL citations from OpenAI's built-in `Web Search` tool responses via `OpenAIResponses`. • Adds extraction of document citations from Claude responses when `File` objects are attached to agent prompts via `Anthropic`. • Adds support and examples for Cohere's new flagship model `Command A`.

Agno v1.1.12

Thu, 13 Mar 2025 18:20:29 GMT

Agno v1.1.12 adds improved citation capture and storage with Gemini and Perplexity integration. • Improves support for capturing, displaying, and storing citations from models, with integration for Gemini and Perplexity.

Agno v1.1.11

Thu, 13 Mar 2025 11:56:13 GMT

Agno v1.1.11 adds OpenAI Responses API support with web search, an OpenWeather tool, and Reddit reply actions. • Adds a new model implementation for OpenAI's Responses API, including support for the built-in `websearch` tool. • Adds an OpenWeather API tool for retrieving real-time weather information. • Adds post reply and comment reply actions to the Reddit tool.

Agno v1.1.10

Wed, 12 Mar 2025 15:06:32 GMT

Agno v1.1.10 adds File prompts, LMStudio provider, AgentQL/Browserbase tools, a custom API tool, and Cohere vision support. • Introduces a new `File` type that can be added to prompts and passed to model providers (Gemini and Anthropic Claude supported). • Adds LMStudio as a model provider. • Adds an AgentQL toolkit for connecting agents to websites for scraping and interaction. • Adds a Browserbase tool for browser automation. • Adds a custom API tool that can call any arbitrary API endpoint. • Adds image understanding support for Cohere models (vision).

Agno v1.1.9

Thu, 06 Mar 2025 17:02:23 GMT

Agno v1.1.9 adds IBM WatsonX and DeepInfra model providers plus MCP tool support for agents. • Adds `MCPTools` class to integrate Model Context Protocol (MCP) servers with Agno agents. • Adds IBM WatsonX as a model provider via a new `WatsonX` integration. • Adds DeepInfra as a model provider, including reasoning support for OpenAI-compatible DeepSeek models. • Updates knowledgebase, vector DB, and reader interfaces with async support.

Agno v1.1.8

Mon, 03 Mar 2025 19:15:59 GMT

Agno v1.1.8 adds video file upload support in Playground for Gemini models and a `base_url` property for AzureOpenAI. • Adds `base_url` property to `AzureOpenAI` to support non-default Azure endpoint URLs. • Enables video file upload in the Playground UI, allowing compatible Gemini models to interpret uploaded video content.

Agno v1.1.7

Wed, 26 Feb 2025 15:06:18 GMT

Agno v1.1.7 adds audio file upload to the Playground for transcription and sentiment analysis. • Adds audio file upload support to the Playground, enabling models to perform transcription, sentiment analysis, and audio interpretation interactively.

Agno v1.1.6

Tue, 25 Feb 2025 01:26:24 GMT

Agno v1.1.6 adds support for Claude 3.7 Sonnet and extended thinking in messages. • Adds support for the Claude 3.7 Sonnet model, including extended thinking in messages.

Agno v1.1.5

Mon, 24 Feb 2025 15:54:14 GMT

Agno v1.1.5 adds audio responses, image understanding for XAI/Together.ai, Webex messaging, and Upstash vector DB support. • Adds audio response support (streaming and non-streaming) via `agent.run_response.response_audio`, using `OpenAIChat` with `id='gpt-4o-audio-preview'` and the `modalities` and `audio` parameters; audio data is available as `response_audio.base64_audio` and can be written to file with write_audio_to_file(). • Adds image understanding support for XAI and Together.ai model providers, enabling multimodal agents on those backends. • Adds a Webex integration tool for sending messages via Webex. • Adds Upstash as a supported vector database backend. • Adds Grounding and Search support for Gemini models to improve response accuracy and recency.

Agno v1.1.4

Mon, 17 Feb 2025 19:42:20 GMT

Agno v1.1.4 adds `get_emails_by_thread` and `send_email_reply` methods to GmailTools • Adds `get_emails_by_thread` and `send_email_reply` methods to `GmailTools`, enabling agents to read full email threads and reply inline. • Adds metadata support to `OpenAIChat`.

Agno v1.1.2

Sat, 15 Feb 2025 21:12:33 GMT

Agno v1.1.2 adds o3 model reasoning support and migrates GeminiEmbedder to Google's new genai SDK • Updates `GeminiEmbedder` to use Google's new `genai` SDK, dropping the `models/` prefix from model IDs (e.g. `'text-embedding-004'` instead of `'models/text-embedding-004'`). • Adds reasoning support for OpenAI's o3 models. Breaking changes: • `GeminiEmbedder` now requires model IDs without the `models/` prefix — callers passing `'models/text-embedding-004'` must change to `'text-embedding-004'`.

Agno v1.1.1

Fri, 14 Feb 2025 09:00:49 GMT

Agno v1.1.1 adds file/image uploads to Agent UI, MP3 support in ModelsLabTools, and custom Firecrawl API URLs. • Adds `MP3` to the `FileType` enum in `ModelsLabTools`, with API routing via `MODELS_LAB_URLS` and `MODELS_LAB_FETCH_URLS` dicts keyed by `MP3`, `MP4`, and `GIF` — enabling audio generation calls alongside existing video/GIF generation. • Adds support for a custom API URL parameter in the Firecrawl integration, letting users point the tool at self-hosted or alternate Firecrawl endpoints. • Agent UI now supports file and image uploads alongside prompts, accepting `.pdf`, `.csv`, `.txt`, `.docx`, `.json` (files) and `.png`, `.jpeg`, `.jpg`, `.webp` (images). Breaking changes: • The `ModelsLabTools` constructor in `/libs/agno/tools/models_labs.py` has changed: the `url` and `fetch_url` parameters have been removed. API URLs are now determined automatically from the `file_type` value. Any code passing `url` or `fetch_url` to `ModelsLabTools` will break on upgrade.

Agno v1.1.0

Wed, 12 Feb 2025 13:26:08 GMT

Agno v1.1.0 overhauls model support with Azure AI Foundry, full AWS Bedrock coverage, Google SDK Gemini, and exponential-backoff retries. • Enables optional exponential backoff retries on model failures (e.g. rate-limit errors) when `exponential_backoff` is set to `True` on an agent. • Expands AWS Bedrock support to all Bedrock models through a rewritten `AwsBedrock` implementation (note: `AwsBedrock` does not support async-await). • Switches the `Gemini` implementation to Google's `genai` SDK (v1.0.0), enabling better feature parity and easier future Gemini integrations. • Adds Exa Answers capability support via `ExaTools`. • Renames `GoogleSearch` to `GoogleSearchTools` for consistency across the toolset. • Extends async-await support to all models (excluding `AwsBedrock`) as part of the models refactor. • Improves metrics and visibility for all models in the Agent UI as part of the models overhaul. Breaking changes: • The `Gemini` implementation via the Vertex API is replaced by the Google SDK implementation — existing code using the Vertex-based `Gemini` class will need to migrate. • The `Gemini` implementation via the OpenAI client is replaced by the Google SDK implementation — existing code using the OpenAI-client-based `Gemini` class will need to migrate. • `OllamaHermes` has been removed; users must migrate to the `Ollama` implementation. • `GoogleSearch` is renamed to `GoogleSearchTools` — any code importing or referencing `GoogleSearch` by name will break.

Agno v1.0.8

Fri, 07 Feb 2025 19:51:45 GMT

Agno v1.0.8 adds Perplexity model support, a Todoist toolkit, JSON knowledge-base reader, Weaviate vector DB, Google Sheets tool, and custom retriever support. • Adds `Perplexity` as a model provider, enabling agents to use Perplexity AI models. • Adds a Todoist toolkit for managing tasks from within agents. • Adds a JSON file reader for loading JSON files into knowledge bases. • Adds `name_exists` function to the LanceDB vector store integration. • Adds async support for Mistral model provider. • Adds async support for Cohere model provider.

Agno v1.0.7

Wed, 05 Feb 2025 12:14:13 GMT

Agno v1.0.7 adds Google Sheets toolkit, Weaviate vector store, and async support for Mistral and Cohere • Mistral now supports async execution via agent.arun() and agent.aprint_response(). • Cohere now supports async execution via agent.arun() and agent.aprint_response(). • Adds a new Google Sheets toolkit for reading, creating, and updating Google Sheets. • Adds Weaviate as a supported vector store backend.

Agno v1.0.6

Tue, 04 Feb 2025 22:35:55 GMT

Agno v1.0.6 adds a Google Maps toolkit and a URL reader/knowledge base for document ingestion. • New Google Maps toolkit covering business discovery, directions, navigation, geocoding, and nearby-places lookup. • New URL reader and knowledge base that fetches any URL and stores its text contents in the document store.

Agno v1.0.5

Mon, 03 Feb 2025 16:04:18 GMT

Agno v1.0.5 adds Gmail tools, Mistral vision support, Claude async, and Exa `find_similar` • Adds `find_similar` method to `ExaTools` for similarity-based search. • Adds a Gmail toolkit with tools for mail search, sending mail, and related operations. • Enables async usage of Claude models via await agent.aprint_response() and await agent.arun(), including async tool calls. • Adds Mistral vision model support.

Agno v1.0.2

Fri, 31 Jan 2025 12:14:35 GMT

Agno v1.0.2 caches model clients for faster agent startup and renames TwitterTools to XTools with Twitter API v2 support. • Renames `TwitterTools` to `XTools` and updates capabilities to be compatible with Twitter API v2. • Caches model client instantiation across all models, improving Agno agent startup time. Breaking changes: • `TwitterTools` has been renamed to `XTools`; any code importing or referencing `TwitterTools` will break on upgrade.

Agno v1.0.1

Thu, 30 Jan 2025 22:57:03 GMT

Agno v1.0.1 enables response caching for Mistral models. • Enables caching support for Mistral models.

Agno v1.0.0

Thu, 30 Jan 2025 13:26:56 GMT

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