Agno

Agno's Team class coordinates multiple specialized agents through a hierarchical orchestration layer that manages message routing, state synchronization, and execution order across agents. Teams use a registry-based agent discovery pattern where each agent maintains its own context and tools, with the Team runtime handling inter-agent communication via a message queue and shared session state. The framework supports both sequential and parallel agent execution patterns with automatic dependency resolution.

Agno's Knowledge class implements a retrieval-augmented generation system that combines vector database backends (Qdrant, Pinecone, LanceDB) with semantic search strategies and content processing pipelines. When an agent queries the knowledge base, the framework performs hybrid search (semantic + keyword), chunks documents using configurable strategies, and injects retrieved context into the agent's prompt with source attribution. The system supports remote content integration (URLs, PDFs, web scraping) with automatic chunking and embedding generation via the model's embedding API.

Agno supports structured output generation where agents return data conforming to a predefined JSON schema or Python dataclass. The framework passes the schema to the model's structured output API (OpenAI's JSON mode, Claude's tool_choice, Gemini's schema validation) and validates the response against the schema before returning to the agent. Type hints on dataclasses are automatically converted to JSON schemas compatible with each provider. Validation failures trigger automatic retries with corrected prompts.

Agno's evaluation framework provides tools for measuring agent performance against predefined test cases with metrics like accuracy, latency, token usage, and cost. Evaluators can be defined as Python functions that compare agent outputs against expected results or human judgments. The framework supports batch evaluation across multiple test cases and generates reports with aggregated metrics. Integration with observability platforms enables tracking evaluation metrics over time to detect performance regressions.

Agno's scheduling system enables agents to be executed on a schedule (cron-like expressions, intervals) without manual triggering. Scheduled tasks are persisted in the database and executed by a background scheduler. Each scheduled execution creates a new session with its own context and memory. The framework supports task dependencies (execute task B after task A completes) and conditional scheduling (execute only if previous execution succeeded). Execution history and logs are persisted for audit trails.

Agno's registry system provides a centralized catalog of agents, tools, and models that can be discovered and instantiated at runtime. Agents and tools can be registered with metadata (description, tags, version) and retrieved by name or tag. The registry supports dynamic configuration where agent parameters (model, tools, knowledge base) can be overridden at runtime without code changes. Registry entries can be persisted in a database or loaded from configuration files.

Provides an evaluation framework for assessing agent performance through custom metrics, execution tracing, and integration with observability platforms. The framework captures execution traces (inputs, outputs, tool calls, latencies), enables custom metric definitions, and exports traces to external observability systems (LangSmith, Datadog, etc.), enabling quantitative agent evaluation and performance monitoring.

Enables agents to schedule background tasks and periodic executions through a scheduling system that manages task queues, execution timing, and result persistence. The framework supports cron-like scheduling, one-time tasks, and task dependencies, with automatic retry logic and failure handling, enabling agents to perform long-running operations without blocking user requests.

Agno's tool system uses a @tool decorator pattern to register Python functions as callable tools, automatically generating JSON schemas compatible with OpenAI, Anthropic, and Google function-calling APIs. When an agent decides to use a tool, the framework validates the function signature, marshals arguments from the model's function-calling response, executes the function with timeout/retry controls, and injects the result back into the agent's context. The system supports both synchronous and asynchronous tool execution with built-in error handling and human-in-the-loop approval gates.

Agno's session management system maintains conversation history, agent state, and learned patterns within a session scope that persists across multiple agent runs. The framework uses a Session object that stores messages, tool execution history, and metadata in a configurable backend (in-memory, SQLite, PostgreSQL). The LearningMachine component analyzes agent behavior within sessions, extracts patterns from successful interactions, and stores them in a learning store for future retrieval. Memory is automatically injected into the agent's context window, with configurable retention policies (sliding window, summarization) to manage token usage.

Agno's Workflow system decomposes complex tasks into discrete steps (Agent steps, Tool steps, Conditional steps, Human approval steps) that execute sequentially or conditionally based on previous results. Each step has its own context, input/output schema, and execution controls. The framework supports human-in-the-loop (HITL) workflows where execution pauses at designated steps, waits for human approval or input, and resumes with the human's decision injected into the context. Workflows generate execution traces with step-level granularity, enabling debugging and audit trails.

Agno's message system supports multimodal content (text, images, audio, files) through a Media class that encapsulates different content types and their metadata. Messages can contain multiple media items with source attribution (URL, file path, base64 encoding). The framework handles media serialization/deserialization for different model providers (OpenAI Vision, Claude, Gemini) with automatic format conversion. Streaming responses are processed incrementally with event-based callbacks, enabling real-time response rendering without buffering the entire response.

Agno's Model class provides a unified interface for multiple LLM providers (OpenAI, Anthropic, Google Gemini, Ollama, custom providers) with provider-specific optimizations for function calling, structured outputs, and streaming. The framework abstracts away provider differences in API signatures, response formats, and capability support. Each provider implementation handles retry logic, timeout management, and client lifecycle (connection pooling, rate limiting). The system supports model switching at runtime without changing agent code.

Agno's event streaming system emits granular events during agent execution (agent_start, tool_call, tool_result, agent_response, error) that can be consumed via WebSocket, Server-Sent Events (SSE), or callback functions. Each event includes execution context (step ID, timestamp, duration, tokens used) and structured data (input, output, error details). The framework integrates with observability platforms (OpenTelemetry, custom tracing) to export spans and traces for distributed tracing and performance analysis. Event filtering allows consumers to subscribe to specific event types without receiving the full event stream.

Agno's AgentOS is a production runtime that wraps agents and teams in a stateless REST API with automatic endpoint generation, session management, and database auto-discovery. The runtime handles request routing, session persistence, authentication, and scaling without requiring manual API definition. It supports WebSocket connections for streaming responses and real-time event delivery. The framework auto-discovers database backends (PostgreSQL, SQLite) and configures session/knowledge base storage automatically. A Control Plane UI provides monitoring, session management, and agent configuration.

Agno integrates with the Model Context Protocol (MCP) standard, allowing agents to discover and use tools from MCP servers without custom integration code. The framework handles MCP client initialization, tool discovery, schema translation to the agent's function-calling format, and result marshaling. Agents can connect to multiple MCP servers simultaneously, with tool namespacing to prevent conflicts. The system supports both local MCP servers (stdio transport) and remote servers (HTTP/WebSocket).