crewAIInc/crewAI

CrewAI is a framework for building and orchestrating multi-agent systems, enabling developers to define crews of specialized agents that collaborate to execute complex tasks. It provides a comprehensive toolset for agent communication, including Agent-to-Agent protocols and Model Context Protocol integration, alongside robust infrastructure for state checkpointing, memory management, and retrieval-augmented generation. The system supports a wide range of LLM providers and offers advanced workflow capabilities through a declarative flow DSL, human-in-the-loop feedback mechanisms, and structured project configuration.

86 changes.

The project underwent a major structural overhaul, migrating to a monorepo layout with PEP 621 manifests and the uv package manager to establish a stable v1.0 foundation. This period introduced core infrastructure for agent execution, including a new planning engine, pluggable memory and RAG backends, and native support for multiple LLM providers and the Model Context Protocol. Extensive testing and adapter layers were added to support these new subsystems, alongside features for flow persistence, A2A communication, and declarative project configuration.

28 changes.

This period focused on expanding the framework's core capabilities by introducing a centralized core library for authentication and distributed locking, alongside a standalone CLI package. Significant features were added to support agent interoperability through A2A protocols and multimodal file handling, while a new declarative DSL was implemented to simplify flow definition. The work also included hardening security with SSRF protections, enhancing observability via OpenTelemetry tracing, and stabilizing the skills system.

CrewAI now includes an A2UI (Agent to UI) extension that enables agents to generate rich, declarative user interfaces via JSON messages. This change adds the core A2A extension framework, along with specific support for A2UI protocol versions 0.8 and 0.9. It includes system prompt builders that instruct agents on how to emit A2UI messages (such as \beginRendering\, \surfaceUpdate\, and \dataModelUpdate\ for v0.8, and \createSurface\, \updateComponents\ for v0.9), along with the necessary JSON schemas, component catalogs (Text, Image, Icon, Button, etc.), and validation logic to ensure compliant UI generation.

lib/crewai/src/crewai/a2a/extensions · high confidence

Users can now intercept and modify LLM transport-level messages using the new \BaseInterceptor\ abstract base class. This feature introduces \on\_outbound\ and \on\_inbound\ hooks (with async variants) that allow custom logic to inspect or alter HTTP requests before they are sent and responses after they are received. The implementation includes Pydantic validation support for the interceptor base class and internal \HTTPTransport\/\AsyncHTTPTransport\ wrappers that automatically apply these hooks when an interceptor is provided to the LLM client.

lib/crewai/src/crewai/llms/hooks · high confidence

Users can now connect to OpenAI-compatible APIs (such as OpenRouter, DeepSeek, Ollama, vLLM, Cerebras, and Dashscope) using the new OpenAI-compatible provider module. This change introduces the \OpenAICompatibleCompletion\ class and related configuration structures, enabling seamless integration with any service that adheres to the OpenAI API format without requiring custom adapters.

_lib/crewai/src/crewai/llms/providers/openai\compatible · high confidence

Users can now connect CrewAI to Snowflake Cortex using the native Snowflake provider, which leverages the OpenAI-compatible Chat Completions API. This implementation handles Snowflake-specific authentication (via PAT, JWT, or token environment variables) and account URL resolution. It also includes specific logic for Claude-family models hosted on Snowflake, such as normalizing stringified tool calls and removing incomplete tool-use history to ensure compatibility with the Snowflake API.

lib/crewai/src/crewai/llms/providers/snowflake · high confidence

CrewAI Flows now support non-blocking human-in-the-loop workflows through a new async feedback system. This change introduces the \@human\_feedback\ decorator, allowing flows to pause and request user review via external integrations (such as Slack, Teams, or webhooks) or the default synchronous console. It also includes a \ConsoleProvider\ for local development, which handles both feedback requests and general user input prompts via \Flow.ask()\, emitting specific events for feedback requests and receipts to enable better observability during these interactive pauses.

_lib/crewai/src/crewai/flow/async\feedback · high confidence

The \crewai\_devtools\ package is introduced, providing a new command-line interface for development workflows. This includes automated version bumping, git branch management, and release automation. The tooling supports generating categorized release notes using AI prompts and handles enterprise release phases, including resilience improvements like resume hints on failure and cache busting for freshly published packages.

lib/devtools/src · high confidence

This release introduces the v1.0.0 version of the library, establishing the foundational structure for key subsystems. It adds a security module providing fingerprinting and configuration capabilities, a knowledge utility for extracting context from search results, and context management utilities leveraging OpenTelemetry baggage for tracking crew execution. Additionally, it initializes package structures for agent builders, LLM providers (including Anthropic and OpenAI), cache tools, and evaluators, setting the stage for future feature implementation within these areas.

(repo-wide) · high confidence

The \crewai.skills\ package now provides a standard for agent skills, enabling users to define capabilities via \SKILL.md\ files with YAML frontmatter. Skills are loaded progressively: initially at a metadata level (name, description), then promoted to instructions (full text) and resources (scripts, assets) only when needed, which helps manage context window usage. The system supports local filesystem discovery, inline skill definitions, and a registry-based repository (\@org/name\ references) with a global cache at \\~/.crewai/skills/\ for downloaded skills. A cache manager handles storage, versioning, and invalidation, while event bus integration emits lifecycle events for discovery, loading, and registry downloads.

lib/crewai/src/crewai/skills · high confidence

CrewAI now includes a new A2A communication module that enables agents to interact with remote agents via the A2A protocol. This addition introduces configuration classes for client, server, and general A2A settings, along with type definitions supporting multiple protocol versions (0.2.0 through 0.4.0) and transport types (JSONRPC, GRPC, HTTP+JSON). The module provides handlers for polling, streaming, and push notifications, allowing flexible integration with remote agents. Helper functions process task results, extract error messages, and manage task states, while templates provide structured messaging for agent availability and conversation progress. Event bus integration ensures that connection errors and response events are emitted for monitoring and debugging.

lib/crewai/src/crewai/a2a · high confidence

A new AgentTools manager class has been added to the crewai package, providing a unified way to access agent-specific capabilities. This change introduces two primary tools: DelegateWorkTool, which allows agents to assign tasks to coworkers, and AskQuestionTool, which enables agents to query their peers. The implementation includes a BaseAgentTool that handles agent name sanitization (normalizing whitespace and case) to ensure robust matching when locating available agents, and leverages the shared I18N\_DEFAULT singleton for consistent, localized error messages and descriptions.

_lib/crewai/src/crewai/tools/agent\tools · high confidence

CrewAI now includes a new module for Model Context Protocol (MCP) transports, providing concrete implementations for connecting to MCP servers via HTTP/Streamable HTTP, Server-Sent Events (SSE), and local Stdio processes. This adds the \HTTPTransport\, \SSETransport\, and \StdioTransport\ classes, along with a \BaseTransport\ interface and \TransportType\ enum, enabling CrewAI agents to interact with external MCP-compatible services. The Stdio transport specifically supports environment variable filtering via a configurable hook to prevent credential leakage.

lib/crewai/src/crewai/mcp/transports · high confidence

Added a new adapter module (\lib/crewai/src/crewai/agents/agent\_adapters/openai\_agents\) that integrates OpenAI Assistants with CrewAI. This includes an \OpenAIAgentAdapter\ to manage agent execution and tool configuration, an \OpenAIAgentToolAdapter\ to convert CrewAI tools into OpenAI-compatible function tools (enforcing strict JSON schemas), and an \OpenAIConverterAdapter\ to handle structured output requirements (JSON/Pydantic) by enhancing system prompts. The adapter relies on the external \agents\ library and provides protocols for type safety.

_lib/crewai/src/crewai/agents/agent\_adapters/langgraph, lib/crewai/src/crewai/agents/agent\_adapters/openai\agents · high confidence

The RAG tools now include a new internal module that standardizes how content sources are identified and processed. A \DataType\ enum and \DataTypes.from\_content\ helper automatically detect whether input is a local file, directory, or URL (including specific handling for GitHub, YouTube, and documentation sites) and map it to the appropriate loader and chunker. The \SourceContent\ class provides utilities to validate if a source is a URL or exists on disk, and generates stable source references using SHA-256 hashing for non-file content. Additionally, \sanitize\_metadata\_for\_chromadb\ ensures metadata passed to the vector store contains only compatible types (strings, integers, floats, booleans).

_lib/crewai-tools/src/crewai\tools/rag · high confidence

The \crewai-core\ package is introduced to provide shared primitives for both the \crewai\ framework and the \crewai-cli\ tool. This includes a new OAuth2 authentication system supporting providers like Auth0, Entra ID, Keycloak, Okta, and Workos, along with JWT validation utilities. A centralized lock store is added, defaulting to Redis or file-based locking with an overridable backend. The release also includes a generated platform application catalog, a Plus API client for enterprise features, and runtime environment detection for telemetry purposes.

lib/crewai-core/src · high confidence

The new crewai-files library provides utilities for handling multimodal inputs (images, PDFs, text, audio, and video) within CrewAI. It includes file type definitions, validation, and processing logic that automatically resizes, compresses, or chunks files to meet provider-specific constraints. The library also features formatters for converting resolved files into content blocks compatible with OpenAI (including the Responses API), Anthropic, Google Gemini, and AWS Bedrock, along with caching and cleanup mechanisms for uploaded files.

lib/crewai-files · high confidence

CrewAI now includes a dedicated telemetry module that collects anonymous usage data via OpenTelemetry spans sent to telemetry.crewai.com. This implementation ensures that only CrewAI-specific spans are exported by using a local TracerProvider rather than installing a global one, preventing telemetry from other libraries in the host process from being accidentally collected. The module handles graceful shutdown via signal handlers (SIGTERM, SIGINT, etc.) and registers attributes for crews, tasks, and agents, while explicitly excluding sensitive data like prompts or responses from the default collection.

lib/crewai/src/crewai/telemetry · high confidence

The state provider module now supports two concrete storage backends for saving and restoring agent runtime checkpoints: a JSON provider that writes individual files to the local filesystem, and a SQLite provider that stores checkpoints in a database using JSONB columns. Both providers implement synchronous and asynchronous checkpointing, pruning of old entries, and lineage tracking via parent IDs and branch labels. A utility function automatically detects the correct provider based on file magic bytes or path format, allowing seamless switching between storage types without changing the core checkpointing logic.

lib/crewai/src/crewai/state/provider · high confidence

CrewAI now automatically detects first-time executions and prompts users to enable tracing. When enabled, the system collects execution events and sends them to a backend, providing an ephemeral URL that opens in the browser to view detailed traces including agent decisions, task timelines, tool usage, and LLM calls. This feature respects user consent and can be disabled via code settings, environment variables, or CLI commands.

lib/crewai/src/crewai/events/listeners · high confidence

Added a new native provider for AWS Bedrock located in \lib/crewai/src/crewai/llms/providers/bedrock\, enabling users to interact with Bedrock models via the Converse API. This implementation includes support for structured outputs, tool calling, and streaming responses, along with utility functions in \providers/utils/common.py\ for robust tool schema extraction and validation. The provider handles inference configuration (including topK for Claude models) and integrates with the existing event and hook systems for observability.

lib/crewai/src/crewai/llms/providers/bedrock · high confidence

Users can now connect to Azure using the native Azure AI Inference SDK instead of the legacy Azure OpenAI client. This new provider supports both the standard Completions API and the newer Responses API, enabling features like structured outputs, streaming tool calls, and credential scopes configuration. It also introduces automatic fallback to DefaultAzureCredential when no API key is provided and adds support for LLM message interceptor hooks (with specific limitations noted for HTTP interceptors).

lib/crewai/src/crewai/llms/providers/azure · high confidence

Users can now interact with Google Gemini models (starting with gemini-2.0-flash-001) via a new native provider in \lib/crewai/src/crewai/llms/providers/gemini\. This implementation leverages the Google Gen AI Python SDK to support streaming, structured outputs, and tool calling, while automatically handling configuration for both standard API key authentication and Vertex AI environments.

lib/crewai/src/crewai/llms/providers/gemini · high confidence

Users can now persist CrewAI flow execution states to disk using a new \@persist\ decorator and a built-in \SQLiteFlowPersistence\ backend. This change adds a \persistence\ module exposing the decorator, a factory for registering custom persistence backends, and the SQLite implementation itself, allowing flows to save and resume state across sessions or process restarts.

lib/crewai/src/crewai/flow/persistence · high confidence

This change adds the core update-mechanism handlers in the \crewai.a2a.updates\ package, enabling agents to receive task progress via three strategies: polling (periodic status checks with timeout and max-poll limits), streaming (SSE-based event consumption with automatic resubscription on interruption), and push notifications (webhook-based delivery with a result store and timeout handling). Each handler sends messages, tracks task state transitions, emits detailed A2A-specific events to the CrewAI event bus, and returns structured results, giving users flexible ways to monitor and react to remote agent tasks.

lib/crewai/src/crewai/a2a/updates · high confidence

The flow runtime now includes new modules (\\_actions.py\ and \\_outputs.py\) that translate declarative \FlowDefinition\ steps into executable runtime objects. This enables flows to invoke specific agents, crews, tools, and inline code blocks defined in the flow structure, while also providing a centralized helper to aggregate and serialize method outputs for the user.

lib/crewai/src/crewai/flow/runtime · high confidence

Users can now automatically save and restore the execution state of crews, agents, and flows using a new checkpointing system. This feature introduces a \CheckpointConfig\ to enable automatic checkpointing, supports multiple storage backends via \JsonProvider\ and \SqliteProvider\, and includes a migration framework to handle state changes across crewAI versions. The system records lifecycle events and lineage, allowing users to resume execution from specific points or fork workflows.

lib/crewai/src/crewai/state · high confidence

Users can now define CrewAI projects using a structured approach: the new \CrewBase\ metaclass and a suite of decorators (\@crew\, \@agent\, \@task\, \@tool\, \@llm\, \@callback\, \@cache\_handler\, \@before\_kickoff\, \@after\_kickoff\, \@output\_json\, \@output\_pydantic\) allow declarative definition of crew components. The project also introduces \load\_crew\ and \load\_crew\_and\_kickoff\ functions to instantiate crews from JSON/JSONC or YAML configuration files, enabling configuration-driven crew assembly alongside inline Python definitions.

lib/crewai/src/crewai/project · high confidence

The RAG module has been restructured to support pluggable vector database backends, starting with ChromaDB and Qdrant. This change introduces a new configuration system that allows users to switch between providers via a discriminator field, and adds a comprehensive factory for embedding providers including OpenAI, Cohere, AWS Bedrock, HuggingFace, and others. The implementation includes a new \BaseClient\ protocol for vector store operations, cross-process locking for concurrent safety, and a custom module wrapper for RAG configuration management.

lib/crewai/src/crewai/rag · high confidence

The \lib/crewai-tools/src/crewai\_tools/rag/chunkers\ module now provides a suite of specialized text chunkers for Retrieval-Augmented Generation (RAG) pipelines. This includes a base implementation and specific chunkers for CSV, JSON, XML, plain text, DOCX, Markdown (MDX), and web content. Each chunker is pre-configured with format-aware separators (such as row boundaries for CSV or headers for MDX) and default chunk sizes to optimize how different document types are split for embedding.

_lib/crewai-tools/src/crewai\tools/rag/chunkers · high confidence

The agents/cache package now exposes a CacheHandler class, allowing users to access and utilize caching functionality for agent operations directly from this module.

lib/crewai/src/crewai/agents/cache · high confidence

CrewAI agents can now connect to Model Context Protocol (MCP) servers via HTTP, SSE, and stdio transports. This change introduces lazy loading of the MCP SDK to reduce cold start times by approximately 29%, and adds specific exception handling to report HTTP authentication failures (401/403) and other connection errors instead of generic cancellation errors. It also supports resolving tools from AMP slugs and handles cyclic JSON schemas during tool resolution.

lib/crewai/src/crewai/mcp · high confidence

CrewAI now includes native support for Model Context Protocol (MCP) tools via new \MCPNativeTool\ and \MCPToolWrapper\ classes, allowing agents to execute tools from MCP servers with safe, per-invocation client creation to prevent concurrent execution issues. Additionally, the tool execution framework now surfaces tool failures explicitly as \ToolFailure\ objects instead of silently reporting them as success, ensuring that errors from MCP servers (indicated by \isError: true\) or other tool executions are correctly identified and handled by the agent.

lib/crewai/src/crewai/tools · high confidence

The \crewai.a2a.auth\ module now provides a structured set of authentication classes (including API keys, Bearer tokens, HTTP Basic/Digest, and OAuth2 flows) and utilities for validating these credentials against an agent's security requirements. This change introduces a new public API for A2A agent communication security, while deprecating the previous flat \schemas.py\ module to guide users toward the new organized package structure.

lib/crewai/src/crewai/a2a/auth · high confidence

This change introduces a suite of new utility modules in the A2A (Agent-to-Agent) subsystem to support remote agent interactions. The \agent\_card\ module provides functions to fetch and cache agent capability information, including support for Jupyter environments and context variable propagation across thread boundaries. The \agent\_card\_signing\ module adds JWS (JSON Web Signature) capabilities to sign and verify agent cards for authenticity. The \delegation\ module enables synchronous and asynchronous task delegation to remote A2A agents, handling authentication, transport negotiation, and file inputs. Additionally, \task.py\ introduces server-side task management with cancellation support via Redis or memory caching, while \logging.py\ provides structured JSON logging utilities. These utilities collectively enhance the ability to discover, authenticate, delegate tasks to, and manage the lifecycle of remote agents within the CrewAI framework.

lib/crewai/src/crewai/a2a/utils · high confidence

Agents can now interact with Amazon Bedrock and S3 using newly added tools. The \BedrockInvokeAgentTool\ allows invoking managed Bedrock Agents, \BedrockKBRetrieverTool\ enables querying Bedrock Knowledge Bases, and the \create\_browser\_toolkit\ and \create\_code\_interpreter\_toolkit\ functions provide browser automation and secure code execution capabilities via Bedrock AgentCore. Additionally, \S3ReaderTool\ and \S3WriterTool\ allow agents to read from and write to Amazon S3 buckets directly.

_lib/crewai-tools/src/crewai\tools/tools · high confidence

This release introduces a pre-deploy validation system for CrewAI projects (lib/cli/src/crewai\_cli/deploy/validate.py) that checks for required project structure, lockfiles, and importability before deployment. It also adds OAuth2 device-flow authentication (lib/crewai-core/src/crewai\_core/auth/oauth2.py) for the CrewAI platform, a platform application catalog (lib/crewai-core/src/crewai\_core/platform\_apps.py) for discovering available integrations, and a shared printer utility (lib/crewai-core/src/crewai\_core/printer.py) for consistent console output. Additionally, it includes a new settings module (lib/crewai-core/src/crewai\_core/settings.py) for managing platform configuration and updates custom tool templates (lib/cli/src/crewai\_cli/templates/crew/tools/custom\_tool.py, lib/cli/src/crewai\_cli/templates/flow/tools/custom\_tool.py) to align with the latest BaseTool interface.

python · high confidence

The flow authoring experience now uses a dedicated DSL module (\crewai.flow.dsl\) to define flow structures via Python decorators. Users can now use \@start\, \@listen\, and \@router\ to declaratively specify execution paths, along with \and\\ and \or\\ condition combinators for complex logic. The \human\_feedback\ decorator is also available to mark methods requiring human input. This DSL extracts a \FlowDefinition\ from the Python class, separating the flow's structural definition from its runtime execution.

lib/crewai/src/crewai/flow/dsl · high confidence

The RAG loaders module now includes a comprehensive set of new loaders to ingest content from various sources. Users can load structured data from CSV, JSON, and XML files, as well as documents like PDFs, DOCX, and MDX. The module also supports loading content from directories, documentation sites, and webpages. Additionally, new loaders allow fetching data from MySQL and PostgreSQL databases, as well as extracting transcripts and metadata from YouTube videos and channels. A GitHub loader is also included to retrieve repository content, including READMEs, structure, and recent issues or pull requests.

_lib/crewai-tools/src/crewai\tools/rag/loaders · high confidence

The \crewai\_tools.adapters\ package now provides a unified adapter interface for connecting CrewAI tools to various backends. This includes a \CrewAIRagAdapter\ for CrewAI's native RAG system, a \RAGAdapter\ for legacy RAG configurations, and a \LanceDBAdapter\ for vector search with thread-safe locking. Additionally, new adapters enable integration with external services: \MCPServerAdapter\ wraps Model Context Protocol tools, while \ZapierActionsAdapter\ and \EnterpriseActionTool\ expose Zapier actions and CrewAI Plus enterprise actions as usable tools. A \ToolCollection\ utility is also introduced to manage these tools with dictionary-like name-based access.

_lib/crewai-tools/src/crewai\tools/adapters · high confidence

This change introduces new utility modules within the event system: \console\_formatter.py\ and \handlers.py\. The console formatter now supports displaying version update notifications (including yanked versions) and tracing status messages to the user, while also managing live streaming updates and suppressing output when appropriate. The handlers module provides utilities to safely invoke event listeners, automatically detecting whether they are synchronous or asynchronous and passing the correct number of arguments (source, event, and optional state) to ensure robust event processing.

lib/crewai/src/crewai/events/utils · high confidence

CrewAI introduces a new event infrastructure in the \crewai.events\ package that enables monitoring and extending agent behavior. The system uses lazy loading for event types to reduce cold-start overhead and supports both synchronous and asynchronous handlers. Handlers can declare dependencies on one another using a \Depends\ mechanism, which the event bus resolves into parallel execution levels to ensure correct ordering while maximizing concurrency.

lib/crewai/src/crewai/events · high confidence

CrewAI now uses an event-driven OpenTelemetry tracing system that records execution spans locally in an ephemeral buffer (up to 1,000 spans or 8 MiB) before uploading. Uploads require explicit user consent via a callback or prompt, and the system records the last successful run in \.crewai/last\_run.json\ for use by \crewai eval\. Traces include detailed GenAI attributes (input/output messages, tool definitions, finish reasons) and span-level metadata for crews, tasks, agents, flows, tools, and memory, with safe serialization and truncation to prevent instrumentation failures.

lib/crewai/src/crewai/telemetry/tracing · high confidence

A new \LLMContextLengthExceededError\ exception has been introduced to specifically handle cases where a language model's context window is exceeded. This exception distinguishes context limit errors from throttling errors and provides a user-friendly message suggesting the use of smaller inputs or text splitting strategies.

lib/crewai/src/crewai/utilities/exceptions · high confidence

CrewAI introduces an experimental evaluation module that allows users to automatically assess agent performance using LLM-based metrics. The framework includes an \AgentEvaluator\ that listens to execution events to capture traces, and provides built-in evaluators for goal alignment, reasoning efficiency, semantic quality, and tool selection. It also features an \ExperimentRunner\ for running test cases against agents or crews, comparing results against baselines, and asserting success or regression, with console output for detailed score breakdowns.

lib/crewai/src/crewai/experimental/evaluation · high confidence

Users can now ingest structured and unstructured files into the CrewAI knowledge base. This change introduces specific knowledge source classes for CSV, Excel, JSON, PDF, and plain text files, all inheriting from a new base file source that handles path validation and content loading. A SourceHelper utility automatically detects the file type by extension and instantiates the correct source, allowing users to add diverse document types to their agents' memory for retrieval-augmented generation.

lib/crewai/src/crewai/knowledge/source · high confidence

Added a new YAML example file (flow\_definition\_example.yaml) demonstrating a CrewAI flow with state, methods, and routing, along with a Jinja2 template (flow\_definition\_skill.md.j2) that generates documentation for creating or editing flow definitions.

lib/crewai/src/crewai/flow/templates · high confidence

Users can now generate and view an interactive HTML visualization of their CrewAI flow structure. This new feature, located in the flow visualization module, builds a graph from the FlowDefinition metadata and renders it using a custom JavaScript engine (vis-network) with support for dark mode, node selection, and export to PNG/PDF. The visualization distinguishes between Start, Router, and Listen nodes, and displays AND/OR edge conditions to help users understand flow execution paths.

lib/crewai/src/crewai/flow/visualization · high confidence

Added \scripts/age90\_file\_input\_runner.py\ to manually test and debug PDF file input handling (native multimodal vs. fallback tool paths) for CrewAI agents. Added \scripts/docs/freeze\_current\_edge.py\ and \scripts/docs/freeze\_historical\_versions.py\ to snapshot documentation for the current Edge channel and historical release tags into versioned directories (\docs/v\<X.Y.Z\>/\). Added \scripts/docs/prefix\_version\_paths.py\ to migrate \docs/docs.json\ to use these directory-based paths, inserting an Edge entry and setting up wildcard redirects to preserve canonical URLs.

scripts · high confidence

The tasks module now includes a ConditionalTask class that allows workflows to dynamically skip or execute tasks based on a condition function evaluating previous outputs, and a HallucinationGuardrail class that serves as a placeholder for premium hallucination detection (currently a no-op in the open-source version). Additionally, the module exposes OutputFormat and TaskOutput definitions, standardizing how task results are structured and serialized.

lib/crewai/src/crewai/tasks · high confidence

The crewai-tools package now includes a \generate\_tool\_specs.py\ script that automatically extracts and exports JSON schemas for all registered tools, capturing their names, descriptions, parameter schemas, required environment variables, and package dependencies. This generation logic uses a dynamic exclusion list based on \BaseTool\ fields rather than a hardcoded denylist, ensuring future changes to the base tool class are automatically reflected in the specs. Additionally, a new \Printer\ utility class has been added to standardize colored console output across the package, supporting various text styles and colors for improved readability in CLI interactions.

_lib/crewai-tools/src/crewai\tools · high confidence

The memory subsystem has been replaced with a unified architecture that supports pluggable storage backends. Users can now choose between built-in vector stores (LanceDB or Qdrant Edge) or register custom backends via a process-wide factory. The system introduces a new \StorageBackend\ protocol and handles embedding dimension mismatches gracefully, alerting users when upgrading CrewAI changes the default embedder (e.g., from 1536 to 3072 dimensions) and providing clear migration steps. Additionally, kickoff task outputs are now stored in a dedicated SQLite database with improved concurrency controls.

lib/crewai/src/crewai/memory/storage · high confidence

A new \crewai.utilities\ package has been introduced, providing core infrastructure for structured LLM output conversion via the \Converter\ and \InternalInstructor\ classes, which handle Pydantic model validation and JSON serialization. The module adds a \FileHandler\ and \FileStore\ for persistent logging and temporary file caching during crew execution, along with a \CrewJSONEncoder\ for custom serialization. It also introduces a \crew\_chat\ module that enables interactive, function-calling-based chat interfaces for crews, and includes utilities for resolving declarative Python references (\declarative\_refs\), managing environment context detection (\env\), and handling configuration processing (\config\).

lib/crewai/src/crewai/utilities · high confidence

Users can now replace the default knowledge storage implementation process-wide without subclassing the Knowledge class or passing a storage instance at every call site. A new factory module provides set\_knowledge\_storage\_factory to register a custom backend (implementing BaseKnowledgeStorage) that is used when no explicit storage is provided, while still allowing explicit storage arguments to override this default. The built-in KnowledgeStorage remains the default and supports both synchronous and asynchronous search and save operations against a ChromaDB-backed client.

lib/crewai/src/crewai/knowledge/storage · high confidence

This change introduces a new security module in crewai-tools that validates file paths and HTTP requests to prevent unauthorized file access and Server-Side Request Forgery (SSRF). File path tools now verify that resolved paths remain within an allowed base directory, while URL-fetching tools use a custom HTTP adapter to pin connections to validated peer IPs, blocking private, reserved, and link-local addresses. The implementation also strips sensitive headers on cross-origin redirects and ignores environment proxies to mitigate SSRF via redirect or DNS rebinding attacks.

_lib/crewai-tools/src/crewai\tools/security · high confidence

The CLI source code has been reorganized into a standalone \crewai-cli\ package, introducing a new authentication flow that automatically logs users into the Tool Repository after login, and adding a new interactive TUI for browsing and managing checkpoint files. The package version is updated to 1.15.22.

lib/cli/src · high confidence

A new adapter infrastructure has been added to the \crewai.agents.agent\_adapters\ module, introducing abstract base classes (\BaseAgentAdapter\, \BaseConverterAdapter\, \BaseToolAdapter\) that define the interface for integrating CrewAI agents and tools with external frameworks. This change establishes the structural foundation for native tool calling and structured output conversion, allowing specific agent implementations to adapt their tool configurations and output parsing logic without modifying the core agent logic.

_lib/crewai/src/crewai/agents/agent\adapters · high confidence

The repository has been restructured with a new monorepo layout (manifesting packages like crewai, crewai-cli, crewai-core, crewai-tools, etc.) and migrated to the uv package manager, evidenced by the new uv.lock and .python-version (3.13) files. To support this, a comprehensive pre-commit configuration was added, integrating ruff for linting/formatting, mypy for static typing, commitizen for conventional commits, and pip-audit for vulnerability scanning. The project now includes a dedicated .env.test file with mocked credentials for CI/local testing, a conftest.py with patches for vcrpy/aiohttp compatibility, and an .editorconfig for consistent code style. Documentation workflows were also formalized with AGENTS.md for AI coding agents and DOCS\_TRANSLATIONS.md for locale sync, while the README was significantly expanded to cover the new Flows/Crews architecture and AMP Suite.

(repo-wide) · high confidence

The agent execution flow has been restructured to support a Plan-and-Act pattern, introducing dedicated \StepExecutor\ and \PlannerObserver\ components that handle isolated step execution and post-step observation respectively. This change adds a provider-based architecture for extensible features like human-in-the-loop (HITL) input and content processing, while deprecating the legacy \CrewAgentExecutor\ in favor of the new \AgentExecutor\. Users will experience improved planning capabilities with runtime observation and refinement, along with more robust handling of tool calls and context through the new modular executor design.

lib/crewai/src/crewai/agents · high confidence

The agent initialization process has been updated to automatically detect and apply Agent-to-Agent (A2A) extensions. When an agent is configured with A2A settings, the system now automatically creates an extension registry and wraps the agent instance with the corresponding A2A functionality during the post-initialization setup phase, enabling seamless integration of A2A capabilities without requiring manual wiring by the user.

lib/crewai/src/crewai/agent/internal · high confidence

Conversational flow capabilities have graduated from experimental to stable status in the main \\crewai.flow\\ module. To ensure existing code continues to work, the \\crewai.experimental\\ package now provides compatibility exports: it re-exports conversational classes (such as \\ConversationConfig\\, \\RouterConfig\\, and \\AgentMessage\\) from the new stable location, and uses lazy loading to resolve other experimental symbols like \\AgentExecutor\\ and evaluation tools without causing import cycles. Additionally, the old \\crewai.experimental.conversational\\ and \\conversational\_mixin\\ modules are now transparent aliases pointing to their stable counterparts, ensuring that any remaining imports from the experimental namespace resolve correctly.

lib/crewai/src/crewai/experimental · high confidence

This release updates the library to version 1.15.22 and introduces an LLM overlay feature that allows users to route specific agent roles to different models at runtime without modifying the agent definitions, while also handling role interpolation during kickoff. The CLI module has been deprecated and migrated to a standalone \crewai\_cli\ package, with the current \crewai.cli\ shim issuing a deprecation warning and forwarding imports. Additionally, the package now includes a mypy plugin to support type checking for the \@CrewBase\ decorator and re-exports core settings and version utilities from \crewai\_core\.

lib/crewai/src/crewai · high confidence

The Flow module has been refactored to support conversational flows and provide global configuration options. Users can now build flows with built-in conversational capabilities, including chat state management and routing, by opting in via the flow definition. A new global configuration object allows customization of human-in-the-loop (HITL) feedback providers and input providers for flow interactions. The flow execution engine has been split into focused modules for DSL decorators, flow definition, and runtime execution, improving maintainability and separation of concerns. Additionally, the flow structure visualization and introspection capabilities have been enhanced to provide better insights into flow composition and execution.

lib/crewai/src/crewai/flow · high confidence

The LLM module now automatically retries calls that are throttled by providers (e.g., 429 errors), using a jittered backoff strategy to handle transient rate limits without manual intervention. Additionally, LLM events now surface accurate finish reasons, sampling parameters, and response IDs by centralizing the extraction logic for standard response shapes, ensuring consistent observability across providers like OpenAI, Azure, and LiteLLM.

lib/crewai/src/crewai/llms · high confidence

The memory module now uses lazy loading for heavy dependencies like \lancedb\ (via \Memory\ and \EncodingFlow\), ensuring that importing \crewai\ does not immediately initialize these resources, which improves startup times in pre-fork deployment patterns. Additionally, new utility functions \sanitize\_scope\_name\, \normalize\_scope\_path\, and \join\_scope\_paths\ are introduced to handle hierarchical memory scope paths, providing robust sanitization and normalization of names and paths for memory isolation.

lib/crewai/src/crewai/memory · high confidence

The agent module has been restructured around a new \core.py\ implementation that replaces the legacy \CrewAgentExecutor\ with \AgentExecutor\ as the default execution path. This change introduces a unified runtime state system with checkpoint and fork support, allowing agents to be paused and resumed. It also integrates native structured output handling, JSON-first schema serialization for tool arguments, and a new event bus for observability (including skill usage and knowledge retrieval events). The module now exposes a \LiteAgentOutput\ for simplified responses and supports async task execution and context variable propagation across thread boundaries.

lib/crewai/src/crewai/agent · high confidence

This change introduces a new \crewai.crews\ package containing utility functions for crew operations, including \setup\_agents\ for configuring agent properties (knowledge, skills, callbacks) and \prepare\_task\_execution\ for handling task replay and conditional skip logic. It also adds \enable\_agent\_streaming\ to activate LLM streaming on agents and exports \CrewOutput\ from the package. These utilities support the broader async crew execution and streaming features.

lib/crewai/src/crewai/crews · high confidence

CrewAI introduces a new, unified hook system in the \crewai/hooks\ module that replaces the previous ad-hoc registration with a generic interception dispatcher. This change adds new decorators (\@before\_llm\_call\, \@after\_llm\_call\, \@before\_tool\_call\, \@after\_tool\_call\) that support filtering by agent role or tool name, allowing users to target specific parts of a crew's execution. The system also introduces execution-boundary hooks (\execution\_start\, \input\, \output\, \execution\_end\) and step-level hooks (\pre\_step\, \post\_step\) for broader lifecycle monitoring. Hooks can now abort execution by raising \HookAborted\ or returning \False\ (for before-hooks), and the new architecture supports both global and execution-scoped hook registration, ensuring that internal crewai flows can be excluded from user-defined hooks when necessary.

lib/crewai/src/crewai/hooks · high confidence

The library now introduces a \SerializableCallable\ type in the \types\ module to ensure callback fields can be safely serialized to and deserialized from JSON for checkpointing. This change replaces previous \Any\-typed callback fields with a structured approach that converts module-level named functions to dotted paths (e.g., \builtins.print\) and validates them upon deserialization. Users must use module-level named functions instead of lambdas, closures, or bound methods for callbacks that need to survive checkpoint round-trips, as these non-roundtrippable types will trigger warnings or errors. Additionally, deserialization of callback paths is restricted by default and requires the \CREWAI\_DESERIALIZE\_CALLBACKS=1\ environment variable to be set for trusted data, enhancing security and data integrity during state restoration.

lib/crewai/src/crewai/types · high confidence

The Skills Repository feature has graduated from experimental to the stable \crewai.skills\ namespace, making it the primary location for registry-backed skills alongside the filesystem-based loader. To ensure backward compatibility, the previous \crewai.experimental.skills\ location now acts as a deprecated shim that re-exports the public API (such as \SkillCacheManager\, \SkillRef\, and registry resolution functions) and patches the module namespace so existing imports continue to work, though this shim will be removed in a future release.

lib/crewai/src/crewai/experimental/skills · high confidence

A new \safe\_path\ module has been added to the utilities package, re-exporting validation functions (\validate\_directory\_path\, \validate\_file\_path\, \validate\_url\) from the security layer. This change introduces protections against path traversal and SSRF attacks for tools that handle file paths and URLs, ensuring that user-provided inputs are validated before use.

_lib/crewai-tools/src/crewai\tools/utilities · high confidence

Added comprehensive test coverage for MCP integration components; Added comprehensive test coverage for RAG loaders and embedding service; Added comprehensive tests for RagTool initialization, data handling, and validation; Added telemetry test suite for runtime checkpoints, coding agent detection, and crew execution spans; Added test coverage for AWS Bedrock LLM provider; Added test coverage for Azure LLM integration; Added test coverage for CLI authentication providers and deployment logic; Added test coverage for CLI commands and core utilities; Added test coverage for CrewAI hooks functionality; Added test coverage for CrewAI tools; Added test coverage for Google Gemini LLM integration; Added test coverage for LLM multimodal, retry, caching, and streaming capabilities; Added test coverage for RAG ChromaDB, Qdrant, and embedding providers; Added test coverage for agent execution, A2A delegation, and configuration; Added test coverage for core tooling and adapters; Added test coverage for crew evaluation, agent utilities, and console formatting; Added test coverage for the Skills system; Added test coverage for tool execution, async support, and failure handling; Added test suite for security fingerprinting and checkpointing features; Added tests for A2A integration, agent card generation, and A2UI schema conformance; Added tests for Agent Tools and ReadFileTool; Added tests for Anthropic LLM integration and LiteLLM fallback; Added tests for CLI authentication providers and JWT validation; Added tests for CLI remote template commands; Added tests for CrewAI Platform tools and integrations client; Added tests for CrewContext and baggage-based context management; Added tests for LLM interceptor hooks; Added tests for OpenAI LLM provider error handling and model routing; Added tests for OpenAI-compatible LLM providers; Added tests for SQLite storage connection lifecycle; Added tests for agent and tool adapter initialization and validation; Added tests for async crew execution; Added tests for crew loading, JSON project validation, and task output callbacks; Added tests for crewai-core telemetry, runtime environment, and settings; Added tests for docs versioning freeze and TOML update logic; Added tests for event bus dependency injection, context management, and observability features; Added tests for experimental evaluation metrics and experiment runner; Added tests for first-time contributor issue-gate workflow; Added tests for path validation and SSRF protection utilities; Added tests for system signal event types and handlers; Added tests for the native Snowflake Cortex LLM provider; Added tests for the new unified memory system and its storage backends; Added tests for the pluggable knowledge storage factory and async knowledge operations; Added tests for tracing event collection and isolation.

The project has moved to a monorepo layout, replacing the previous dependency management approach with explicit PEP 621 \pyproject.toml\ files for each workspace package (\crewai\, \crewai-tools\, \crewai-cli\, \crewai-core\, \crewai-files\, \devtools\). This change standardizes dependency declarations across the ecosystem, enforcing a minimum Python 3.10 requirement and integrating security patches directly into the manifests (e.g., \gitpython\>=3.1.59\, \cryptography\>=42.0\, \pypdf\>=6.16.2\). The root \pyproject.toml\ now configures the unified workspace, managing shared dev dependencies like \ruff\, \mypy\, and \pytest\, while the CLI and core packages are explicitly versioned at 1.15.22.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 45 (+4.0)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 95 → 79 (-15.7)
• Architecture 99 (new)
• Maturity 61 → 72 (+10.6)
• Readiness 30 → 44 (+13.8)
• Security 35 → 73 (+38.3)
• Accessibility 28 (new)

• (anonymous) (cognitive 17) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• (anonymous) (cognitive 52) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• (anonymous) (cyclomatic 16) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• Coverage not measured — test suite did not build
• Dimension evaluation failed
• LLM evaluation failed
• Low: security finding (details withheld)
• Low: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• Medium: security finding (details withheld)
• No exposed public API
• No tests found
• Secret: private-key (lib/crewai/src/crewai/a2a/utils/agent_card_signing.py)
• Test reliability not included
• Unpinned build actions
• drawNodeText (cognitive 18) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• drawNodeText (cyclomatic 18) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• early-stage repository — too little history to judge knowledge freshness
• getPathSignature (cognitive 33) (lib/crewai/src/crewai/flow/visualization/assets/interactive.js)
• …and 4 more

• A2UIClientExtension.extract_state_from_history (cognitive 47) (lib/crewai/src/crewai/a2a/extensions/a2ui/client_extension.py)
• A2UIClientExtension.extract_state_from_history (cyclomatic 27) (lib/crewai/src/crewai/a2a/extensions/a2ui/client_extension.py)
• Agent._build_output_from_result (cognitive 21) (lib/crewai/src/crewai/agent/core.py)
• Agent._prepare_kickoff (cognitive 50) (lib/crewai/src/crewai/agent/core.py)
• Agent._prepare_kickoff (cyclomatic 30) (lib/crewai/src/crewai/agent/core.py)
• AgentEvaluator._handle_lite_agent_completed (cognitive 17) (lib/crewai/src/crewai/experimental/evaluation/agent_evaluator.py)
• AgentExecutor._build_replan_context (cognitive 19) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor._execute_single_native_tool_call (cognitive 70) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor._execute_single_native_tool_call (cyclomatic 45) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor._should_parallelize_native_tool_calls (cognitive 26) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor._synthesize_final_answer_from_todos (cognitive 16) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor.decide_next_action (cognitive 16) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor.execute_native_tool (cognitive 54) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor.execute_native_tool (cyclomatic 27) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor.execute_todos_parallel (cognitive 31) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AgentExecutor.finalize (cognitive 25) (lib/crewai/src/crewai/experimental/agent_executor.py)
• AnthropicCompletion._ahandle_completion (cognitive 46) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
• AnthropicCompletion._ahandle_completion (cyclomatic 23) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
• AnthropicCompletion._ahandle_streaming_completion (cognitive 45) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
• AnthropicCompletion._ahandle_streaming_completion (cyclomatic 26) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
• …and 994 more

• 190 commits — 113 feature/other, 77 fixes

• lib/crewai — 81 commits
• docs/edge — 28 commits
• lib/cli — 26 commits
• lib/crewai-tools — 19 commits
• (root) — 16 commits
• .github/CONTRIBUTING.md — 4 commits
• .github/workflows — 3 commits
• .github/security.md — 1 commit
• docs/v1.15.13 — 1 commit
• docs/v1.15.14 — 1 commit
• docs/v1.15.15 — 1 commit
• docs/v1.15.16 — 1 commit
• docs/v1.15.17 — 1 commit
• docs/v1.15.18 — 1 commit
• docs/v1.15.19 — 1 commit
• docs/v1.15.20 — 1 commit
• docs/v1.15.21 — 1 commit
• docs/v1.15.22 — 1 commit
• lib/crewai-core — 1 commit
• lib/crewai-files — 1 commit

• fix: Fix Anthropic cache token usage underreporting (#6844)
• fix: Fix legacy platform tool alias discovery (#7269)
• fix: fix mysql search table name validation (#6341)
• fix: fix(agents): carry from_cache on the native tool path's ToolUsageFinishedEvent (#7501)
• fix: fix(agents): keep message roles when Agent.kickoff gets a conversation (#7065)
• fix: fix(agents): keep null in the task output schema embedded in the prompt (#6775)
• fix: fix(agents): preserve tool results when final answer is empty (#7133)
• fix: fix(agents): render message content parts as text, not a python repr (#7109)
• fix: fix(agents): request the forced final answer as a user turn (#7450)
• fix: fix(azure): key streamed tool calls by wire index (#7487)
• fix: fix(bedrock): fall back to sync calls from acall (#7680)
• fix: fix(bedrock): preserve streaming tool call arguments at contentBlockStop (#6150)
• fix: fix(brightdata): drop stray $ in f-string search URLs (#7326)
• fix: fix(cli): don't crash the run TUI when streamed output contains a literal [...] (#7435)
• fix: fix(cli): keep deploy push on the AMP create source (#7345)
• fix: fix(cli): open the conversational TUI for a declarative chat flow (#7060)
• fix: fix(cli): overwrite stale poetry.lock backup on windows (#7463)
• fix: fix(cli): print whatever areas the evaluation graded (#7701)
• fix: fix(cli): read json checkpoints as utf-8 (#7491)
• fix: fix(core): record the running release on every emitted span (#6989)
• …and 170 more

• Containers 0 added · 0 removed · contexts 1 added · 0 removed · edges 0 added · 0 removed

• python

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

crewAIInc/crewAI was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.