Changelog_
AgentOS now more reliably discovers and registers MCP tools and databases during setup. The system also detects and rejects incompatible database instances that share the same identifiers, preventing subtle configuration errors before they reach production.
This improves startup reliability and reduces the risk of hard-to-debug failures caused by misconfigured environments. Teams get faster feedback and clearer boundaries when assembling complex AgentOS deployments.
Why this matters: As AgentOS environments grow, small configuration issues can create outsized operational risk. Stronger validation up front leads to more predictable deployments and lower maintenance overhead.
Agno’s LiteLLM model support now includes first-class metadata and additional fields. Teams can attach and propagate structured context alongside model calls, making it easier to track usage, apply policy, and integrate with downstream observability or governance workflows.
This change improves operational clarity without adding complexity. Metadata travels with requests in a consistent way, helping teams reason about cost allocation, environment context, or workload classification across agents and services.
Teams can now deterministically control whether an incoming run should override the session state already stored in the database.
Agno introduces an opt-in capability that allows AgentOS run endpoints to overwrite persisted session state when needed. This gives teams precise control over how state is handled across retries, replays, and external orchestrations—without relying on implicit database behavior.
Agno now allows AgentOS workflows to integrate with Slack, expanding where agents can operate and interact with users. Developers can orchestrate workflows inside Slack, reducing the need for separate interfaces or custom integrations.
Who this is for:
Teams using Slack as a primary collaboration or operational interface.
Learn more about Agno and Slack
All Agno database implementations now support bulk writes, enabling multiple Sessions and Memories to be persisted with one operation. This reduces overhead for high-volume workflows and improves performance for large-scale deployments.
Why this matters:
- Reduces API calls and integration complexity
- Improves performance for data-intensive workflows
- Supports scalable, production-ready agent deployments
Agno introduces the MCP Toolbox for Databases, a new toolkit that allows agents to interact with structured data in Google’s MCP ecosystem. This enables developers to build more sophisticated, database-driven workflows with reduced integration overhead.
Why this matters:
- Expands agent capabilities with direct database access
- Simplifies building and scaling data-intensive workflows
- Reduces development effort for integrating external data sources
Control costs and prevent runaway tool calls in reasoning agents
Agno now allows a tool_call_limit to be set for the default reasoning agent. Teams can prevent infinite or excessive tool calls, reducing compute costs and ensuring predictable workflow execution.
This capability improves governance, operational control, and reliability in production agent deployments.
Why this matters
- Limits runaway or costly tool executions
- Provides stronger operational control over agent behavior
- Supports predictable performance and cost management
Agno now supports an allow_partial_failure option in MultiMCPTools, letting workflows continue even if some tools fail. This ensures that critical outputs can still be generated and reduces the risk of total workflow failure.
By providing more predictable behavior in multi-tool workflows, this update improves reliability and operational confidence.
Why this matters:
- Prevents entire workflows from failing due to a single tool error
- Improves predictability and reliability in production
- Reduces the need for manual intervention in complex workflows
Agno now allows adding multiple text entries in a single call to Knowledge. Teams can populate knowledge bases faster, with fewer API calls and less orchestration overhead.
This change simplifies content workflows, accelerates onboarding, and improves operational efficiency in knowledge-heavy applications.
Why this matters:
- Reduces manual steps and API overhead
- Accelerates content ingestion and updates
- Improves workflow efficiency and reliability
Agno now exposes tool dependencies as built-in arguments, making it easier to configure and run custom tools within agent workflows. This removes the need for boilerplate wiring and ensures that tools have access to all necessary context.
By reducing manual configuration, this change improves operational simplicity, reliability, and maintainability of complex workflows.
Why this matters:
- Reduces setup time and integration complexity
- Ensures predictable tool execution in production workflows
- Improves workflow observability and control
Agno now supports CometAPI as a model provider, giving teams more flexibility in how they build and deploy agentic workflows. Developers can leverage CometAPI models alongside existing options, enabling new use cases for local, cloud, or hybrid model deployments.
This integration simplifies adoption, reduces the need for custom adapters, and broadens the range of agents that can be built and deployed in production environments.
Why this matters:
- Expands model support and deployment flexibility
- Reduces integration effort for new workflows
- Supports a wider variety of agent use cases without custom code
Agno now handles media routing more precisely when agents use tools that generate images or other media. When media is intended only for tools—and not for the model—it is now consistently excluded from model inputs.
This improves correctness and control, especially when working with non-multimodal models or tightly governed prompt flows. Teams can rely on clearer separation between tool outputs and model context, reducing risk and unexpected behavior.
Why this matters:
- More predictable and auditable model inputs
- Reduced risk of unintended data exposure
- Better control over agent behavior in production
AgentOS now works more reliably when embedded in custom applications. When teams provide their own app framework, Agno automatically ensures the AgentOS UI has the access it needs—without breaking existing cross-origin settings.
This removes a common integration hurdle and reduces the need for manual configuration when deploying AgentOS in real-world environments. Teams can embed AgentOS with greater confidence that the UI will function correctly out of the box.
Why this matters:
- Faster, simpler AgentOS integration
- Fewer deployment errors and support issues
- More predictable behavior in production environments
Agno now supports Llama CPP as a first-class model option, enabling teams to run agents on local or self-hosted LLMs. This expands deployment flexibility for organizations that need tighter control over cost, latency, data residency, or infrastructure.
With native Llama CPP support, teams can build and operate agentic systems without relying exclusively on hosted model providers. This makes Agno a stronger fit for on-prem, air-gapped, or cost-sensitive environments—without changing how agents are designed or managed.
Why this matters:
- Greater control over cost and infrastructure
- Support for privacy-sensitive or regulated deployments
- More options for production model strategy
Agno now handles Gemini schemas with nullable fields and complex definitions more reliably. This resolves issues that could previously cause structured outputs to fail or behave unpredictably.
The result is more consistent agent behavior when relying on structured responses—critical for workflows that depend on strict schemas, automation, or downstream processing.
Why this matters:
- Fewer runtime surprises in production agents
- More reliable structured data from Gemini models
- Greater confidence in schema-driven workflows
Who this is for:
Teams using Gemini models for automation, extraction, or schema-based agent workflows.
Search results for session history are now correctly scoped to the current user. This change improves correctness, privacy, and trust—ensuring users only see and interact with their own session data.
For teams operating shared environments, this update strengthens data isolation and reduces the risk of confusion or unintended access.
Why this matters:
- Improved data privacy and correctness
- More predictable user experience
- Stronger foundation for multi-user environments
File uploads in the AgentOS chat experience are now more reliable, restoring support for common formats such as PDFs. This ensures agents can consistently access and reason over user-provided documents during interactive sessions.
The fix removes a known source of friction in day-to-day usage and improves trust in chat-based workflows.
Why this matters:
- Fewer broken interactions during live agent use
- More predictable behavior for document-driven workflows
- Better end-user experience in AgentOS
Agno now persists the original workflow input alongside workflow run outputs. This gives teams full visibility into what triggered a run, making it easier to debug issues, audit behavior, and reason about outcomes over time.
Persisted inputs support stronger governance and post-hoc analysis, especially in regulated or high-stakes environments where understanding agent decisions is critical.
Why this matters:
- Better debugging and root-cause analysis
- Improved audit trails for production systems
- Stronger operational confidence and accountability
Who this is for:
Teams operating agents in production, especially in regulated or customer-facing environments.
Agno now supports file generation tools, enabling agents to produce structured file artifacts as part of normal execution. This unlocks new production use cases such as report generation, data exports, compliance artifacts, and downstream system handoffs—without custom glue code.
File outputs are treated as durable artifacts, making agent results easier to integrate into existing business processes and systems.
Why this matters:
- Enables new end-to-end workflows driven by agents
- Reduces integration and maintenance overhead
- Makes agent outputs immediately usable outside the platform
Who this is for:
Teams building agents for reporting, data pipelines, customer deliverables, or operational automation.
Learn more about Agno's file generation tools.
We’ve added a first-class Nexus Model abstraction, giving teams a cleaner and more consistent way to define, route, and manage models across agentic systems. This change simplifies how models are represented and used within Nexus, making advanced routing strategies easier to reason about and extend over time.
By formalizing the model layer, teams gain better control over how agents select and interact with models—without embedding logic across workflows. This improves long-term maintainability and reduces risk as systems scale or evolve.
Why this matters:
- Clearer system boundaries and mental model
- Easier to extend routing logic as requirements grow
- Stronger foundation for production-grade agent orchestration
Who this is for: Platform teams and architects building complex, multi-model agent systems.
Learn more about Agno and Nexus
AG-UI reliability has been improved to address issues such as duplicate events and multiple tool-calling inconsistencies. These updates make UI-driven workflows more stable and trustworthy when working with complex agent interactions.
Why this matters:
- Improves trust in UI-based workflow execution
- Reduces noise and confusion during debugging
- Supports more complex agent interactions with fewer surprises
Who this is for:
Teams relying on AG-UI for monitoring, demos, or operational visibility.
Agno now provides more accurate metric tracking for workflows using OpenAI Responses. This gives teams clearer visibility into usage, performance, and cost drivers when running agentic systems in production.
Why this matters:
- Improves observability and cost governance
- Supports more accurate monitoring and reporting
- Helps teams operate AI workloads more predictably
The v1 to v2 migration tooling has been updated to support metrics parsing and MongoDB migrations. This reduces manual work and uncertainty during upgrades, helping teams move to v2 with greater confidence.
Why this matters:
- Reduces upgrade risk for production systems
- Preserves operational data during migration
- Shortens time-to-value for teams adopting v2
Who this is for:
Teams upgrading existing Agno deployments from v1 to v2.
AgentOS now offers expanded support for custom FastAPI applications. When routes overlap, AgentOS routes are applied by default, with the option to disable this behavior. This enables teams to embed AgentOS into existing services without major refactoring.
Why this matters:
- Reduces integration effort with existing backend services
- Gives teams explicit control over routing behavior
- Supports incremental adoption of AgentOS in production systems
Who this is for:
Engineering teams integrating AgentOS into established APIs.
Learn more about custom FastAPI applications
Ag-UI and AgentOS now integrate more cleanly, resolving issues that could cause inconsistent behavior between the interface and the underlying system. This improves confidence when using Ag-UI to observe, test, or interact with agentic workflows.
Why this matters:
- Improves predictability of UI-driven workflows
- Reduces operational issues caused by integration gaps
- Supports smoother debugging and demonstration workflows
Who this is for:
Teams using Ag-UI to manage or showcase agentic systems.
AgentOS now includes a default / route, eliminating unexpected 404 errors when accessing the service root. This improvement makes AgentOS deployments more predictable and easier to operate, especially in production and shared environments.
Why this matters:
- Improves reliability and user experience out of the box
- Reduces confusion during setup, testing, and health checks
- Aligns AgentOS behavior with expectations for production services
Who this is for:
Platform and infrastructure teams running AgentOS as a service.
Agno now includes a Streamlit application for Vision AI, providing an interactive interface to experiment with vision models and integrate them into workflows quickly.
Why this matters:
- Accelerates prototyping and experimentation with Vision AI
- Provides a user-friendly interface for exploration and testing
- Supports faster iteration and deployment of vision-based workflows
All AgentOS evaluation workflows now support async tools through MCP, allowing parallel execution of tasks and faster throughput.
Why this matters:
- Reduces time-to-value for evaluation workflows
- Improves scalability for large or resource-intensive evaluations
- Enhances reliability and predictability of workflow runs
Who this is for:
Engineering and platform teams managing high-volume agentic evaluations in production.
Learn more about AgentOS evals
Agno introduces the SiliconFlow model class, enabling teams to integrate SiliconFlow models into their agentic workflows. This broadens the range of AI models available for automation and decision-making.
Why this matters:
- Supports new use cases and model types in production workflows
- Increases flexibility in AI-driven automation
- Signals continued platform expansion and strategic investment
Who this is for:
Platform teams and developers exploring advanced AI models for multi-agent systems.
Agno now supports TypedDict in addition to Pydantic for defining input schemas in agents, teams, and workflows. This allows developers to specify structured input with explicit key-value types, reducing errors and improving workflow predictability.
Why this matters:
- Provides stronger type guarantees for workflow inputs
- Simplifies validation and error handling
- Supports consistent behavior across complex multi-agent workflows
Who this is for:
Engineering teams building automated workflows with strict input requirements.
Learn more about input schemas as TypedDict
AgentOS no longer relies on the MCP dependency, making it easier to deploy and maintain across environments. Teams can now adopt AgentOS with fewer setup steps and reduced risk of version or dependency conflicts.
Why this matters:
- Reduces integration and maintenance overhead
- Simplifies scaling and upgrading AgentOS in production
- Improves predictability and operational reliability
Playground, AGUIApp, SlackApi, WhatsappApi, and FastAPIApp have been replaced or integrated into AgentOS. Migration consolidates capabilities into a single platform, reducing operational overhead.
Why this matters:
- Simplifies multi-agent workflow management
- Reduces maintenance and integration burden
- Ensures teams leverage the latest, supported platform features
Who this is for:
Engineering teams and platform owners transitioning from legacy apps to a unified AgentOS deployment.
Agno’s Cookbook documentation has been fully updated with more examples and structured guidance for building production-ready multi-agent workflows.
Why this matters:
- Accelerates onboarding and development
- Reduces trial-and-error when building complex workflows
- Improves time-to-value and developer confidence
Who this is for:
New and existing engineering teams looking to scale agentic systems efficiently.
Agno introduces new session convenience methods, providing streamlined access to runs, session summaries, and aggregated chat histories for easier workflow management and insights.
Why this matters:
- Reduces time spent querying and aggregating workflow data
- Supports faster decision-making and debugging
- Simplifies operational workflows for agentic systems
Who this is for:
Engineering and platform teams managing complex agentic systems with multiple session dependencies.
Learn more about session methods
Run outputs and events are now standardized, with additional metadata for enhanced tracking, reporting, and debugging. Teams can more easily integrate agentic systems with monitoring and governance tools.
Why this matters:
- Improves transparency and traceability across runs
- Supports operational monitoring and compliance needs
- Simplifies integration with observability platforms
Who this is for:
Platform owners, SREs, and teams focused on reliable, auditable agentic workflows.
Teams can now cancel agent, team, or workflow runs mid-execution while maintaining event integrity and state awareness. This feature improves operational control and reduces wasted compute.
Why this matters:
- Minimizes resource waste during long-running runs
- Reduces risk from unintended or failing workflows
- Ensures predictable behavior for automated processes
Who this is for:
Operations and engineering teams managing production workloads with complex or long-running agentic workflows.
Learn more about run cancellation
Agno now enables custom events in workflows, allowing teams to instrument workflows with domain-specific signals and outcomes.
Why this matters:
- Provides richer observability and actionable insights
- Supports business-specific monitoring and analytics
- Enhances operational control without additional infrastructure
Who this is for:
Engineering and analytics teams integrating agentic workflows with business-critical processes.
Learn more about custom events
Sessions, memories, evals, and metrics are now managed through a simplified, unified storage system, reducing the complexity of tracking agent runs and workflow performance.
Why this matters:
- Improves observability and traceability of agentic workflows
- Reduces effort to audit or debug runs
- Supports scalable, enterprise-grade deployments
Who this is for:
Platform owners and engineering teams needing robust session tracking and workflow insights.
Learn more about session storage
Agno’s unified knowledge system now supports multiple content types in a single structure. Teams can manage, access, and update knowledge consistently, enabling agents to deliver more accurate and contextually relevant results.
Why this matters:
- Centralizes content for easier governance
- Reduces risk of outdated or inconsistent data
- Improves agent performance and reliability
Who this is for:
Teams building complex agentic systems that rely on structured and unstructured knowledge.
Explore the unified knowledge system
Agno now supports fully stateless agents, teams, and workflows, simplifying session management and making scaling more predictable. This ensures consistent behavior across runs and environments while reducing operational overhead.
Why this matters:
- Eliminates state-related inconsistencies and runtime errors
- Simplifies infrastructure and monitoring
- Reduces maintenance effort for long-lived workflows
Who this is for:
Engineering teams managing large-scale agentic systems that require reliability and repeatability.
Learn more about stateless workflows
Agno introduces AgentOS, a production-ready API that consolidates agent, team, and workflow management into a single platform. Teams can now deploy, monitor, and scale multi-agent systems without juggling multiple apps or environments, reducing operational complexity and risk.
Why this matters:
- Streamlines orchestration of agents and workflows across environments
- Improves governance and observability with unified run and session tracking
- Reduces integration and maintenance overhead by replacing legacy apps
Who this is for:
Platform teams and engineering leaders building or scaling automated workflows.