Skip to content
CAI
Software that uses CAICheck a score

crewAIInc/crewAI

39.7

Weak · 14 November 2026

305.9k

lines of production code

Python

primary language

6

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add A2UI extension support for declarative agent-generated UI

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

Add LLM message interceptor hooks for request/response modification

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

Add native Snowflake Cortex LLM provider

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

Added offline evaluation and tracing demo scripts

New Python scripts have been added to support development and testing workflows. The \jev\_evaluation\_runner.py\ script enables offline evaluation of Jev routing (Choice) and guardrail (Noul) decisions by processing JSONL datasets and reporting metrics such as accuracy, coverage, and false acceptance/rejection rates. The \wharf\_runner.py\ script exercises SDK tracing with CrewAI agents using Firecrawl MCP tools, allowing developers to verify trace session handling and span export behavior in a standalone demo environment.

python · high confidence

Async human-in-the-loop feedback support for CrewAI Flows

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

Establishes standardized development environment and CI/CD configuration

The repository now includes a comprehensive set of configuration files to standardize the development experience and automate quality checks. An \.editorconfig\ enforces consistent Python formatting (2-space indentation, LF line endings), while a \.pre-commit-config.yaml\ integrates Ruff for linting/formatting, mypy for static type checking, and pip-audit for vulnerability scanning. A \.python-version\ file explicitly sets Python 3.13 as the target version, and a new \conftest.py\ provides robust pytest fixtures, including patches for VCR compatibility with modern aiohttp and httpx versions. Additionally, a \.env.test\ file centralizes fake credentials for all supported LLM providers and external tools, allowing tests to run locally without real API keys.

(repo-wide) · high confidence

Initial release of CrewAI Devtools CLI

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

Introduce Agent Skills with progressive disclosure and registry support

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

Introduce Agent-to-Agent (A2A) protocol support with configurable transport and event handling

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

Introduce LangGraph agent adapter and LLM overlay routing

CrewAI now supports running agents via LangGraph through a new LangGraph agent adapter (located in \crewai/agents/agent\_adapters/langgraph\), which integrates LangGraph's ReAct agents with CrewAI's tooling, memory, and structured output requirements. Additionally, a new \llm\_overlay\ context manager allows users to dynamically route specific agent roles or model strings to different models for the duration of a run without modifying the agent definitions, enabling flexible model swapping and cost optimization.

lib/crewai/src/crewai · high confidence

Introduce MCP transport implementations (HTTP, SSE, Stdio)

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

Introduce RAG module with data type detection and source handling

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

Introduce centralized core library with OAuth2 authentication and distributed locking

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

Introduce dedicated, isolated telemetry collection for CrewAI

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

Introduce filesystem and SQLite providers for runtime state checkpointing

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

Introduce first-time user trace collection and ephemeral viewing

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

Introduce multimodal file handling and provider-specific formatting

The \crewai-files\ library now provides a complete system for handling multimodal content (images, audio, video, PDFs, text) across multiple LLM providers. Users can now use the high-level \format\_multimodal\_content\ and \aformat\_multimodal\_content\ APIs to automatically resolve, validate, and format files into provider-specific content blocks for OpenAI (including the new Responses API), Anthropic, Google Gemini, and AWS Bedrock. The library includes a \FileProcessor\ that validates files against provider constraints and can automatically resize images, optimize them, or chunk PDFs to fit limits. It also introduces an upload caching system with cleanup utilities to manage temporary files, and specific formatters for each provider to ensure correct block structures (e.g., S3 URIs for Bedrock, base64 for Gemini).

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

Introduce native AWS Bedrock provider with Converse API support

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

Introduce native Azure AI Inference provider with Responses API support

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

Introduce native Google Gemini LLM provider

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

Introduce native multimodal file handling with provider-specific constraints and caching

The \crewai-files\ library now includes a comprehensive file resolution system that automatically determines the optimal delivery method (inline base64, raw bytes, file upload, or URL reference) based on the target LLM provider's capabilities and file size. This change introduces provider-specific constraints for images, audio, video, and text, a streaming upload cache to avoid redundant uploads, and structured performance metrics for file operations, enabling reliable native multimodal support across providers like OpenAI, Anthropic, and Gemini.

crewai-files · high confidence

Introduce pluggable flow state persistence with SQLite backend

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

Introduce polling, streaming, and push notification handlers for A2A task updates

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

Introduce runtime action builders for declarative flow definitions

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

Introduce runtime state checkpointing with configurable providers

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

Introduce structured project scaffolding with decorators and JSON/YAML configuration support

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

Introduces A2A protocol support with authentication, error handling, and A2UI extensions

CrewAI now supports the Agent-to-Agent (A2A) protocol, enabling agents to communicate and delegate tasks to remote agents. This change adds comprehensive authentication schemes for both clients (Bearer, OAuth2, API Keys, Basic, Digest, mTLS) and servers (Simple token, Enterprise, OIDC, OAuth2), along with standardized A2A error codes and exception handling. It also introduces the A2UI extension, allowing agents to render interactive user interfaces (v0.8 and v0.9) in responses, and provides the underlying infrastructure for update mechanisms (polling, streaming, push notifications) and agent wrapping for seamless A2A delegation. Also in this area: Conversational flows promoted to stable with backward-compatible experimental exports.

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

Introduces extensible provider pattern for human-in-the-loop and content processing

The core library now exposes a provider-based architecture for human-in-the-loop (HITL) interactions and content processing. Users can now customize how human feedback is handled during agent execution through the new \HumanInputProvider\ protocol, which supports both synchronous terminal prompts and asynchronous non-blocking I/O via \SyncHumanInputProvider\. Additionally, a \ContentProcessorProvider\ protocol allows for extensible content transformation before task execution, defaulting to a no-op processor. This refactoring replaces previous monolithic implementations with a modular system that enables custom integrations for feedback loops and content handling.

lib/crewai/src/crewai/core · high confidence

Introduces pluggable RAG infrastructure with ChromaDB and Qdrant backends

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

Introduces structured RAG chunking for various file formats

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

Introduction of CacheHandler module

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

Introduction of Knowledge, Security, and Telemetry Infrastructure

This release introduces foundational modules for knowledge retrieval, security identity, and execution context tracking. Users can now configure knowledge retrieval limits and score thresholds via the new KnowledgeConfig, while the Security module provides automatic component fingerprinting and configuration management to support future authentication and scoping features. Additionally, OpenTelemetry-based context propagation is added to track crew execution context across tasks.

(repo-wide) · high confidence

Introduction of unified memory system with hierarchical scoping and lazy loading

The memory module has been replaced with a new unified Memory class that supports pluggable storage backends (defaulting to LanceDB), LLM-driven analysis for scope and importance, and hierarchical memory isolation via a root\_scope configuration. This change introduces automatic root-scope nesting for crews, ensuring memories are stored under structured paths (e.g., /crew/research-crew/\<scope\>) rather than flat namespaces. Additionally, heavy dependencies like LanceDB are now lazily imported to prevent initialization overhead during standard imports, which improves startup performance in deployment environments like Celery.

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

Native MCP client support with improved error reporting and lazy loading

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

Native MCP tool support with improved failure handling

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

New A2A authentication schemas and validation utilities

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

New A2A utility modules for agent card management, delegation, and task execution

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

New AWS Bedrock and S3 integration tools

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

New AWS Bedrock, S3, RAG, and external integration tools

This release adds several new tools to the crewai-tools package. It introduces a suite of AWS Bedrock tools including \BedrockInvokeAgentTool\ for agent invocation, a browser toolkit (\NavigateTool\, \ClickTool\, etc.) for web navigation, a code interpreter toolkit (\ExecuteCodeTool\, \ExecuteCommandTool\, etc.) for running code, and a \BedrockKBRetrieverTool\ for querying knowledge bases. Additionally, it adds \S3ReaderTool\ and \S3WriterTool\ for reading and writing files in Amazon S3. The release also includes a new RAG infrastructure with \BaseLoader\, \RAG\ class, and related components for managing document loading, chunking, and embedding via ChromaDB. Finally, it adds \AIMindTool\ for querying data via AI-Minds and \ArxivPaperTool\ for fetching and downloading Arxiv papers.

crewai-tools · high confidence

New OpenAI Agents adapter for CrewAI integration

This change introduces a new adapter module (\lib/crewai/src/crewai/agents/agent\_adapters/openai\_agents\) that enables CrewAI agents to run on top of the OpenAI Agents SDK. The adapter includes an \OpenAIAgentAdapter\ to manage agent execution, an \OpenAIAgentToolAdapter\ to convert CrewAI tools into OpenAI-compatible function tools (enforcing strict JSON schemas), and a \structured\_output\_converter\ to handle JSON and Pydantic output formats. This allows users to leverage OpenAI's native agent capabilities within the CrewAI framework.

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

New Python DSL for defining CrewAI flows

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

New RAG loader infrastructure and diverse data source support

This release introduces a comprehensive RAG loader package in \lib/crewai-tools/src/crewai\tools/rag/loaders\, providing a unified interface for ingesting data from a wide variety of sources. The new loaders include support for local and remote files (CSV, DOCX, JSON, JSONL, MDX, PDF, Text, XML), web content (WebPage, Documentation Sites), code repositories (GitHub), and databases (MySQL, PostgreSQL). Additionally, it adds specialized loaders for YouTube channels and Jupyter Notebooks, along with a DirectoryLoader for recursive local file processing. All loaders are exported via a central \\\init\\_.py\ and utilize a shared safe-fetching utility for URL-based content.

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

New adapter layer for RAG, MCP, LanceDB, and external integrations

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

New agent builder module with base agent and output conversion utilities

The \lib/crewai/src/crewai/agents/agent\_builder\ package has been introduced, establishing the foundational structure for agent construction. This includes a \BaseAgent\ abstract class that defines core agent attributes (role, goal, backstory) and handles serialization, LLM resolution, and executor configuration. Additionally, a new \OutputConverter\ utility has been added to enable agents to transform unstructured text into structured Pydantic models or JSON, supporting retry logic for reliable data formatting.

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

New devtools commands for automated documentation analysis and versioned snapshots

The \crewai-devtools\ package now includes two new capabilities: a \docs-check\ command that analyzes git diffs to identify necessary documentation updates and can generate or update MDX documentation (including translations) using an LLM, and a directory-based versioning system that freezes the current 'Edge' documentation into immutable per-version snapshots (e.g., \docs/v\<X.Y.Z\>/\) while updating navigation and redirects in \docs.json\.

crewai-devtools · high confidence

New event system utilities for console formatting and handler execution

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

New event system with lazy loading and dependency-ordered handlers

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 includes a comprehensive, event-driven tracing system that records detailed spans for crews, agents, tasks, tools, and flows. Execution traces are buffered locally in memory (defaulting to 1,000 spans or 8 MiB) and are only uploaded to the trace viewer after explicit user consent, ensuring privacy by default. The system captures rich context, including declared output formats, actual outputs, prompts, answers, and tool cache status, while adhering to OpenTelemetry GenAI semantic conventions. A record of the last successful run is saved to \.crewai/last\_run.json\ to enable seamless evaluation via the CLI without manual ID copying.

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

New exception for LLM context length errors

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

New experimental agent evaluation and testing framework

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

New file-based knowledge sources for CSV, Excel, JSON, PDF, and text

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

New flow definition templates and example

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

New interactive flow visualization tool

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

New native Anthropic provider with structured outputs and tool support

This change introduces a new native Anthropic LLM provider implementation, replacing previous integration methods. It adds support for native structured outputs on specific Claude models (Fable 5, Opus 5, Sonnet 5, Opus 4.8, and 4.5-era models), enabling direct JSON schema validation without tool-based fallbacks. The provider also implements native tool calling, including support for tool search and dynamic tool injection, and handles multimodal file references via the Anthropic Files API beta. Additionally, it manages model-specific max token limits (up to 128,000 for newer models) and integrates with the existing hook and event systems for token usage tracking and call interception.

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

New pre-deploy validation, experimental evaluation command, and custom tool template

The CLI now includes a pre-deploy validation module that checks for required project structure (pyproject.toml, lockfiles, package directories, crew/flow files) and environment configuration before deployment, blocking on errors and warning on potential issues. An experimental \crewai eval\ command allows users to evaluate traced crew runs through CrewAI AMP, supporting model comparison, export of evaluation data, and automatic crew execution when no trace exists. Additionally, a template for creating custom tools has been added to the CLI scaffolding.

crewai-cli · high confidence

New tool specification generator and standardized console output utilities

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

New unified memory system with pluggable storage backends

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

New utilities module with structured output, file storage, and chat interfaces

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

Pluggable default storage backend for knowledge collections

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

Support for native OpenAI-compatible providers

Users can now connect to additional LLM providers via the OpenAI-compatible API interface. The system includes built-in configurations for OpenRouter, DeepSeek, Ollama, vLLM, Cerebras, Dashscope, and DeepInfra. This allows specifying these providers directly (e.g., using a model string like 'deepseek/deepseek-chat' or setting provider='ollama') without manual endpoint configuration. Additionally, Ollama base URLs are automatically normalized to ensure correct scheme, port, and path handling.

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

Security

New SSRF and path traversal protections for tools

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

Architecture

CLI is refactored into a standalone crewai-cli package with new authentication and checkpoint features

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. Also in this area: 1 commit (1 fix) fixing lib/cli; 1 commit (0 fixes) modifying lib/cli; Version bump to 1.15.30; Updated AGENTS.md template to clarify eval login behavior and iteration limits; CLI login now selects an organization and auto-fetches integration tokens; and 4 more.

lib/cli/src · low confidence · unverified

Introduction of agent and tool adapter abstraction layer

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

Behavioural changes

1 commit (0 fixes) modifying lib/crewai-files/src/crewai\_files/core, lib/crewai-files/src/crewai\_files/resolution

A change to existing behaviour in lib/crewai-files/src/crewai\_files/core, lib/crewai-files/src/crewai\_files/resolution — 1 commit, 4 files: “feat: native multimodal file handling; openai responses api”.

_lib/crewai-files/src/crewai\_files/core, lib/crewai-files/src/crewai\files/resolution · medium confidence · unverified

2 commits (0 fixes) modifying lib/crewai-files/src/crewai\_files/spreadsheets

A change to existing behaviour in lib/crewai-files/src/crewai\_files/spreadsheets — 2 commits, 1 file: “feat(files): read spreadsheets for agents in crewai-files (\#9184)”; “feat(agents): read spreadsheet URLs in an agent's input with tools over every row (\#9234)” (refs \#9184, \#9234).

_lib/crewai-files/src/crewai\files/spreadsheets · medium confidence · unverified

4 commits (1 fix) modifying scripts

A change to existing behaviour in scripts — 4 commits (1 fix), 5 files: “Refresh the LiteLLM catalog after the version-bump PR merges. (\#8103)”; “feat(devtools): open a standalone litellm catalog PR before the version bump (\#8799)”; “Lorenze/fix/file input not working reliably (\#6020)”; and 1 more (refs \#8103, \#8799, \#6020, \#6202).

scripts · medium confidence · unverified

4 commits (2 fixes) modifying lib/crewai-files/src/crewai\_files/formatting

A change to existing behaviour in lib/crewai-files/src/crewai\_files/formatting — 4 commits (2 fixs), 6 files: “chore(crewai-files): drop self-explanatory comments”; “Lorenze/fix/file input not working reliably (\#6020)”; “feat: native multimodal file handling; openai responses api”; and 1 more (refs \#6020).

_lib/crewai-files/src/crewai\files/formatting · medium confidence · unverified

8 commits (2 fixes) modifying crewai-core

A change to existing behaviour in crewai-core — 8 commits (2 fixs), 4 files: “fix: enforce owner-only permissions on credential files (\#6242)”; “refactor: extract CLI into standalone crewai-cli package”; “feat(cli): improve platform integration setup UX (\#7453)”; and 5 more (refs \#6242, \#7453, \#7573, \#8593, \#7990, …).

crewai-core · medium confidence · unverified

Agent initialization now automatically applies A2A extensions

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

Flow framework restructured with conversational support and global configuration

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

Improved LLM reliability with rate-limit retries and standardized response metadata

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

Introduce new agent execution architecture with planning and step-based execution

The agent module has been restructured to support a new 'Plan-and-Act' execution pattern. This introduces a \StepExecutor\ that handles individual plan steps in isolation, a \PlannerObserver\ that analyzes step results to refine or replan the remaining tasks, and a new \ToolsHandler\ for managing tool usage and caching. These components replace the previous monolithic agent execution flow, enabling more robust planning, observation, and error handling during task execution.

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

New core agent implementation with unified execution and checkpointing

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

New crew execution utilities and streaming support

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

New unified hook system with execution interception and filtering

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

Serializable callback types for reliable checkpointing

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

Skills Repository moved to stable namespace with experimental shim

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

Fixes

3 commits (2 fixes) fixing lib/crewai-files/src/crewai\_files/cache

A fix in lib/crewai-files/src/crewai\_files/cache — 3 commits (2 fixs), 2 files: “fix(files): raise ValueError instead of bare raise in get\_uploader (\#7283)”; “feat: native multimodal file handling; openai responses api”; “fix(files): run the provider listing off the loop in acleanup\_provider\_files (\#8642)” (refs \#7283, \#8642).

_lib/crewai-files/src/crewai\files/cache · medium confidence · unverified

3 commits (2 fixes) fixing lib/crewai-files/src/crewai\_files/processing

A fix in lib/crewai-files/src/crewai\_files/processing — 3 commits (2 fixs), 6 files: “fix(files): raise ValueError instead of bare raise in get\_uploader (\#7283)”; “feat: native multimodal file handling; openai responses api”; “fix: resolve mypy errors in crewai-files and add all packages to CI type checks” (refs \#7283).

_lib/crewai-files/src/crewai\files/processing · medium confidence · unverified

3 commits (2 fixes) fixing lib/crewai-files/src/crewai\_files/uploaders

A fix in lib/crewai-files/src/crewai\_files/uploaders — 3 commits (2 fixs), 6 files: “fix(files): raise ValueError instead of bare raise in get\_uploader (\#7283)”; “feat: native multimodal file handling; openai responses api”; “fix(files): honor an injected aioboto3 session in BedrockFileUploader (\#8521)” (refs \#7283, \#8521).

_lib/crewai-files/src/crewai\files/uploaders · medium confidence · unverified

Add path and URL validation utilities to RAG tools

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

Test coverage

13 commits adding/updating tests in lib/devtools/tests; 2 commits adding/updating tests in lib/crewai-files/tests/spreadsheets; 26 commits adding/updating tests in lib/crewai/tests/llms; 27 commits adding/updating tests in lib/crewai-core/tests; 3 commits adding/updating tests in lib/crewai/tests/llms/litellm; 4 commits adding/updating tests in lib/crewai-files/tests/processing; 5 commits adding/updating tests in lib/crewai-files/tests; Added comprehensive test coverage for MCP integration components; 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 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 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 authentication providers and deployment packaging; Added tests for CLI remote template commands; Added tests for CrewAI Platform tools and integrations client; Added tests for CrewAI event bus, RWLock, and shutdown behavior; 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 RAG loaders and embedding service; Added tests for SQLite storage connection lifecycle; Added tests for agent and tool adapter initialization and validation; Added tests for async task execution; Added tests for crew and task evaluator utilities; Added tests for crew loading, JSON project validation, and task output callbacks; 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.

Dependencies

Migrate to monorepo structure with PEP 621 pyproject.toml manifests

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 cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 41 → 40 (-1.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 60 → 59 (-0.9)
  • Architecture 91 → 91 (-0.6)
  • Maturity 68 → 67 (-1.3)
  • Readiness 39 → 38 (-0.9)
  • Security 78 → 70 (-7.6)
  • Accessibility 24 → 23 (-1.0)
  • Performance 100 → 100 (+0.0)

Resolved (77)

  • Documentation: no project overview (README.md)
  • Documentation: no project overview (lib/crewai-tools/src/crewai_tools/tools/contextualai_create_agent_tool/README.md)
  • Duplicate intent with divergent signatures. cli.train_crew takes no arguments (likely relying on defaults or context), while train_crew.train_crew requires explicit n_iterations and filename. This creates confusion about whether the user should call the CLI wrapper or the underlying function directly.
  • Duplicated block (10 lines × 2) (lib/crewai/src/crewai/rag/qdrant/utils.py)
  • Duplicated block (11 lines × 2) (lib/crewai/src/crewai/events/utils/console_formatter.py)
  • Duplicated block (11 lines × 2) (lib/crewai/src/crewai/telemetry/tracing/handlers.py)
  • Duplicated block (11–13 lines × 2) (lib/crewai/src/crewai/telemetry/tracing/handlers.py)
  • Duplicated block (12 lines × 2) (lib/cli/src/crewai_cli/run_crew.py)
  • Duplicated block (12 lines × 2) (lib/devtools/src/crewai_devtools/cli.py)
  • Duplicated block (12–14 lines × 2) (lib/crewai/src/crewai/llms/providers/snowflake/completion.py)
  • Duplicated block (13 lines × 3) (lib/crewai/src/crewai/events/utils/console_formatter.py)
  • Duplicated block (14 lines × 2) (lib/cli/src/crewai_cli/skills/main.py)
  • Duplicated block (14–15 lines × 2) (lib/crewai-tools/src/crewai_tools/aws/bedrock/browser/browser_session_manager.py)
  • Duplicated block (15 lines × 4) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
  • Duplicated block (16 lines × 2) (scripts/wharf_runner.py)
  • Duplicated block (16–19 lines × 2) (lib/cli/src/crewai_cli/skills/main.py)
  • Duplicated block (17 lines × 2) (lib/crewai/src/crewai/agent/core.py)
  • Duplicated block (18 lines × 2) (lib/crewai-tools/src/crewai_tools/tools/tavily_extractor_tool/tavily_extractor_tool.py)
  • Duplicated block (18–20 lines × 2) (lib/crewai/src/crewai/rag/embeddings/providers/ibm/embedding_callable.py)
  • Duplicated block (20–22 lines × 2) (lib/crewai/src/crewai/agent/core.py)
  • …and 57 more

New (272)

  • Change coupling: cli.py ↔ kickoff_flow.py (lib/cli/src/crewai_cli/cli.py)
  • DeployValidator._check_module_imports (cyclomatic 17) (lib/cli/src/crewai_cli/deploy/validate.py)
  • DeployValidator._classify_import_error (cognitive 16) (lib/cli/src/crewai_cli/deploy/validate.py)
  • Duplicated block (105–106 lines × 2) (lib/crewai/src/crewai/llm.py)
  • Duplicated block (12 lines × 2) (lib/crewai/src/crewai/llms/providers/anthropic/completion.py)
  • Duplicated block (13 lines × 2) (lib/crewai/src/crewai/llms/providers/azure/completion.py)
  • Duplicated block (13–15 lines × 2) (lib/crewai/src/crewai/agents/agent_executor.py)
  • Duplicated block (13–15 lines × 2) (lib/crewai/src/crewai/flow/conversational_mixin.py)
  • Duplicated block (14 lines × 2) (lib/crewai/src/crewai/utilities/converter.py)
  • Duplicated block (14–16 lines × 2) (lib/cli/src/crewai_cli/create_flow.py)
  • Duplicated block (14–17 lines × 2) (lib/devtools/src/crewai_devtools/cli.py)
  • Duplicated block (18 lines × 2) (lib/crewai/src/crewai/agent/core.py)
  • Duplicated block (19–20 lines × 2) (lib/cli/src/crewai_cli/skills/main.py)
  • Duplicated block (19–23 lines × 2) (lib/crewai/src/crewai/llms/providers/openai/completion.py)
  • Duplicated block (20 lines × 2) (lib/crewai/src/crewai/utilities/agent_utils.py)
  • Duplicated block (21–22 lines × 2) (lib/crewai/src/crewai/agent/core.py)
  • Duplicated block (24–25 lines × 3) (lib/crewai/src/crewai/llms/providers/openai/completion.py)
  • Duplicated block (36–37 lines × 2) (lib/crewai/src/crewai/llms/providers/openai/completion.py)
  • Duplicated block (55 lines × 2) (lib/crewai/src/crewai/llms/providers/openai/completion.py)
  • Duplicated block (7 lines × 2) (lib/crewai/src/crewai/crews/crew_output.py)
  • …and 252 more

Changes since last survey

  • 153 commits — 75 feature/other, 78 fixes

By area

  • lib/crewai — 59 commits
  • lib/cli — 39 commits
  • docs/edge — 21 commits
  • lib/crewai-tools — 8 commits
  • (root) — 7 commits
  • lib/crewai-files — 3 commits
  • .github/workflows — 2 commits
  • lib/devtools — 2 commits
  • docs/v1.15.31 — 1 commit
  • docs/v1.15.32 — 1 commit
  • docs/v1.15.33 — 1 commit
  • docs/v1.15.34 — 1 commit
  • docs/v1.15.35 — 1 commit
  • docs/v1.15.36 — 1 commit
  • docs/v1.15.37 — 1 commit
  • docs/v1.15.38 — 1 commit
  • docs/v1.15.39 — 1 commit
  • docs/v1.15.40 — 1 commit
  • docs/v1.15.41 — 1 commit
  • lib/crewai-core — 1 commit

Notable commits

  • fix: Lorenze/fix/failing flaky tests (#8686)
  • fix: SECT-602: fix path traversal in output_file via template interpolation (#8622)
  • fix: fix(README): update FAQ links to AMP headings (#9303)
  • fix: fix(agent): ask for structured output when a tool-using agent finishes (#8703)
  • fix: fix(agent): load from_repository set inside an agent's config (#8610)
  • fix: fix(agent): stop an agent whose apps CrewAI AMP cannot resolve (#9285)
  • fix: fix(agent): warn on repeated tool calls and keep the work when stopping (#8706)
  • fix: fix(agents): tell the model how to recover from an unreadable deferred result (#8705)
  • fix: fix(checkpoint): save unrestorable callbacks as null instead of breaking restore (#8596)
  • fix: fix(ci): respect maintainer PR reopen actions (#8701)
  • fix: fix(cli): add the chosen provider's crewai extra to new projects (#9029)
  • fix: fix(cli): count a crewai eval run that exits with an error as run_failed (#9227)
  • fix: fix(cli): count a crewai run whose project script fails (#8895)
  • fix: fix(cli): create the project .env owner-only when crewai eval turns tracing on (#9224)
  • fix: fix(cli): crewai update prints the upgrade commands instead of rewriting uv projects (#8592)
  • fix: fix(cli): eval asks to share the trace with Enter meaning yes, and says why (#9207)
  • fix: fix(cli): exit 1 when a crewai+ command needs a login (#8590)
  • fix: fix(cli): exit non-zero when crewai run's project script fails (#9221)
  • fix: fix(cli): exit with guidance when a python conversational flow has no terminal (#8589)
  • fix: fix(cli): exit with the uv status when crewai install fails (#9346)
  • …and 133 more

Architecture

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

Added bounded contexts (1)

  • lib/cli/src/crewai_cli/templates/flow

Removed bounded contexts (1)

  • lib/cli/src/crewai_cli/templates/flow

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

Survey your own repository

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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit d7dfa0ef5ade793bd48ff7357c6eb45a45294371 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-36d4cd83012f.