Agno

Creates autonomous agents by binding a language model (OpenAI, Anthropic, Google Gemini, or custom providers) to an Agent class with declarative configuration. The framework handles model client lifecycle, retry logic, and streaming response processing through a unified Model interface that abstracts provider-specific APIs, enabling agents to switch models with minimal code changes.

Coordinates multiple specialized agents into teams where agents can delegate tasks to teammates through a Team class that manages agent registry, message routing, and execution context. The framework uses a delegation pattern where agents reference teammates by name and the Team runtime resolves function calls to the appropriate agent, enabling hierarchical task decomposition without explicit inter-agent communication code.

Enables agents to generate structured outputs (JSON, Pydantic models) with schema validation through a structured output mode that constrains model responses to a defined schema. The framework uses model-native structured output APIs (OpenAI's JSON mode, Anthropic's structured outputs, Google's schema validation) to ensure responses conform to the schema, with automatic parsing and validation error handling.

Integrates with Model Context Protocol (MCP) servers to expose external tools and resources as agent capabilities through a standardized protocol. The framework handles MCP client lifecycle, tool discovery, and execution, enabling agents to access tools from any MCP-compatible server (filesystem, web, databases) without custom integration code, with automatic schema translation and error handling.

Implements human-in-the-loop (HITL) workflows where agents can request human approval before executing sensitive operations (tool calls, decisions). The framework provides approval gates that pause agent execution, collect human feedback, and resume execution based on approval status, with support for approval routing, timeout handling, and audit logging of all approval decisions.

Automatically detects model provider capabilities (parallel tool calling, vision, structured outputs, etc.) and optimizes agent behavior accordingly. The framework queries provider APIs for feature support, adapts tool calling strategies (e.g., parallel for Gemini, sequential for Claude), and enables provider-specific optimizations (e.g., timeout handling for Gemini, vision for Claude) without requiring agent code changes.

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.

Enables agents to invoke external functions through a @tool decorator that generates OpenAI/Anthropic-compatible function schemas from Python function signatures and docstrings. The framework handles tool execution, parameter validation, error handling, and result injection back into the agent's context, supporting both synchronous and asynchronous tools with optional human-in-the-loop approval gates.

Integrates external knowledge sources into agents through a Knowledge class that manages document ingestion, chunking, embedding, and vector search. The framework supports multiple vector database backends (Pgvector, Pinecone, Weaviate, Qdrant) and implements agentic RAG where agents can search knowledge bases as a tool, with configurable search strategies (semantic, keyword, hybrid) and automatic content processing pipelines for PDFs, web content, and structured data.

Defines multi-step workflows as sequences of WorkflowStep objects that execute agents, tools, or custom logic with conditional branching, error handling, and context passing between steps. The framework manages step execution order, input/output mapping, and provides a Run object that tracks execution state, events, and outputs across the entire workflow, supporting both linear and branching execution patterns.

Manages agent memory within a session scope through a Memory class that stores conversation history, intermediate results, and learned facts. The framework supports multiple memory backends (in-memory, database) and implements automatic context window management where older messages are summarized or pruned to fit model token limits, with optional persistence to external storage for cross-session continuity.

Implements a LearningMachine system that captures agent interactions, outcomes, and feedback into a learning store for continuous improvement. The framework records execution traces, tool calls, and user feedback, enabling agents to learn from past experiences through retrieval-augmented prompting or fine-tuning signals, with support for multiple learning store backends (database, vector store) and evaluation metrics.

Provides real-time visibility into agent execution through an event streaming system that emits structured events (agent_start, tool_call, agent_response, etc.) during execution. The framework supports WebSocket streaming for live updates, event filtering, and integration with observability platforms, enabling clients to monitor agent progress, debug execution, and react to events in real-time without polling.

Provides a production-ready runtime (AgentOS) that exposes agents as stateless REST APIs with automatic session management, database auto-discovery, and built-in authentication. The framework handles request routing, session scoping, database connection pooling, and provides WebSocket endpoints for streaming, eliminating the need for custom API scaffolding while maintaining horizontal scalability through stateless design.

Supports multimodal agent interactions through a Media class that handles images, audio, documents, and structured data alongside text. The framework automatically encodes media for model APIs (base64 for images, file uploads for documents), manages media metadata, and enables agents to process and generate multimodal content, with support for vision models (Claude, Gemini, GPT-4V) and document understanding.