agno

Agno abstracts multiple LLM providers (OpenAI, Anthropic Claude, Google Gemini, Ollama) through a unified Model interface with provider-specific client lifecycle management, retry logic, and streaming response handling. Each provider integration implements standardized interfaces for tool calling, structured outputs, and streaming while preserving provider-specific capabilities like Gemini's parallel grounding or Claude's extended thinking.

Agno provides a @tool decorator and Function class that converts Python functions into LLM-callable tools with automatic schema generation, type validation, and execution controls. Tools are registered in an agent's function registry and invoked through provider-native function calling APIs (OpenAI functions, Anthropic tool_use, Gemini function calling) with built-in error handling, timeout controls, and human-in-the-loop approval gates.

Agno provides an Evaluation Framework for testing and validating agent behavior with built-in tracing that captures execution spans, tool calls, and decision points. The framework integrates with third-party observability platforms (LangSmith, Datadog, etc.) for centralized monitoring. Traces include full execution context, enabling debugging and performance analysis of agent systems.

Agno's media system enables agents to process and generate multimodal content (images, documents, audio) through a unified Message abstraction. Messages can include text, images, documents, and other media types, with automatic encoding/decoding for different providers. The framework handles media storage, retrieval, and provider-specific formatting (e.g., base64 for OpenAI, URLs for Anthropic).

Agno's Scheduling system enables agents to execute on defined schedules (cron-style, interval-based) through a registry-based approach. Scheduled agents are managed by the AgentOS runtime and execute in isolated sessions, with results stored and accessible via API. The framework handles schedule persistence, execution history, and failure recovery.

Agno's AgentOS runtime includes automatic database discovery that detects available databases and generates tool schemas for database operations. The framework introspects database schemas and creates tools for querying, inserting, and updating data without manual schema definition. Supports multiple database backends (PostgreSQL, MySQL, SQLite) with provider-specific optimizations.

Agno provides a Control Plane UI for managing deployed agents, monitoring execution, and viewing session history. The UI displays agent configurations, execution traces, message history, and performance metrics. It enables manual agent triggering, session inspection, and debugging without CLI or API access.

Agno's Team system coordinates multiple agents with distinct roles and responsibilities through a composition model where agents are added to a team with specific configurations. Teams manage agent communication, message routing, and execution order through a run context that tracks session state, message history, and execution events. The framework handles inter-agent message passing and coordination without requiring explicit message queue infrastructure.

Agno's Workflow system defines multi-step processes as sequences of WorkflowStep instances that execute in order with support for conditional branching, human approval gates, and step-level error handling. Each step can be an agent execution, tool invocation, or custom Python function, with execution context passed between steps. The framework provides event streaming for step execution progress and supports pausing workflows for human input before proceeding.

Agno's Knowledge system provides a Knowledge Base abstraction that integrates with vector databases (Chroma, Pinecone, Weaviate, etc.) for semantic search and retrieval-augmented generation. The framework includes a content processing pipeline that handles document ingestion, chunking, embedding, and storage, with support for multiple search strategies (semantic, keyword, hybrid). Agents can query knowledge bases through built-in tools, enabling context-aware reasoning over custom documents.

Agno's LearningMachine system provides persistent memory storage for agent interactions, enabling agents to learn from past experiences through a Learning Store abstraction. The framework tracks agent decisions, outcomes, and feedback, storing them in configurable backends (database, vector store) for later retrieval and analysis. Agents can query their learning history to improve decision-making, and the system supports experience replay patterns for continuous improvement.

Agno's AgentOS runtime serves agents as stateless, session-scoped REST APIs and WebSocket endpoints through FastAPI integration. Each session maintains isolated execution context, message history, and state without server-side persistence, enabling horizontal scaling. The runtime handles database auto-discovery, authentication, registry management, and provides built-in monitoring endpoints for observability.

Agno's event streaming system emits execution events (agent steps, tool calls, responses) as they occur, enabling real-time monitoring and client-side progress tracking. Events are structured with timestamps, execution context, and step-level details, and can be consumed via WebSocket connections or event listeners. The framework supports event filtering and selective streaming to reduce bandwidth for large-scale deployments.

Agno supports structured output generation where agents can return JSON responses conforming to user-defined schemas. The framework uses provider-native structured output APIs (OpenAI JSON mode, Anthropic structured outputs, Gemini schema validation) to ensure responses match the specified schema. Validation occurs at the model level, reducing post-processing overhead and enabling type-safe agent responses.

Agno integrates with the Model Context Protocol (MCP) standard, allowing agents to discover and invoke tools exposed by MCP servers. The framework handles MCP client lifecycle, tool schema discovery, and invocation routing, enabling agents to access external tool ecosystems without manual integration. MCP servers can be local or remote, and Agno manages connection pooling and error handling.