Make CrewAI 3–34× faster.
No code changes.
Fast-CrewAI is a Rust-accelerated drop-in for CrewAI. One import flips on serde serialization, FTS5 memory search, tool caching, and parallel task scheduling — while staying 100% API-compatible.
pip install fast-crewai · import fast_crewai.shim
What is Fast-CrewAI?
Fast-CrewAI is a Rust-accelerated drop-in performance layer for CrewAI, the Python multi-agent framework. It patches CrewAI's hottest paths — JSON serialization, memory search, and tool execution — with Rust implementations via PyO3, while keeping 100% of the CrewAI API. You add one import; your Agents, Tasks, and Crews run unchanged, just faster.
You keep the real CrewAI. Fast-CrewAI sits on top via dynamic inheritance at import time.
It speeds up executing a crew — memory, serialization, tools — not install or setup time.
An AI engineering consultancy that ships and operates production multi-agent systems.
Problem → solution
Where CrewAI slows down, and what we do about it
These are runtime bottlenecks in the framework itself — not your agent logic. Fast-CrewAI fixes them underneath your code.
Memory search degrades as it grows
CrewAI memory retrieval defaults to LIKE-query scans that walk rows, so latency climbs with every stored memory.
A SQLite FTS5 full-text index with BM25 ranking replaces the scan — 11.2× faster in benchmarks, and it stays fast as memory grows.
Read the deep dive →JSON encoding dominates message passing
Agents, tasks, and tools shuttle JSON constantly. The Python json module becomes a measurable tax on every hop.
Rust serde via PyO3 encodes and decodes the same payloads 34.5× faster with 58% less peak memory.
Read the deep dive →The same tool runs again and again
LLMs call the same tool with the same arguments repeatedly, paying the full execution and validation cost each time.
Result caching plus serde validation collapses repeated calls — 17.3× faster with 99% less memory on the hot path.
Read the deep dive →Concurrent agents contend for the database
Parallel agents fight over a single SQLite connection, serializing work that should run concurrently.
r2d2 connection pooling hands each worker its own connection, lifting concurrent DB throughput.
Read the deep dive →Benchmarks
Measured on real CrewAI workloads
Numbers from the fast-crewai benchmark suite against crewai==1.7.2
with 101 compatibility tests passing. Real end-to-end workflow gains typically land at 1.3–5×,
with the largest wins in memory-intensive and database-heavy pipelines.
Quickstart
One import. Zero refactor.
Fast-CrewAI uses smart monkey patching via dynamic inheritance. Your
Agent,
Task, and
Crew objects
keep their exact API — but the hot paths run through Rust.
Need to disable acceleration for debugging? Set FAST_CREWAI_ACCELERATION=0. Individual components can be toggled too.
# 1. Install
pip install fast-crewai # or: uv add fast-crewai
# 2. Add one line before your CrewAI imports
import fast_crewai.shim
from crewai import Agent, Task, Crew
# 3. Your existing code now runs accelerated
agent = Agent(role="Analyst", goal="Summarize quarterly metrics")
task = Task(description="Extract KPIs from the report", agent=agent)
crew = Crew(agents=[agent], tasks=[task], memory=True)
crew.kickoff()Capabilities
Nine ways Fast-CrewAI earns its keep
Every accelerated path targets a place where Python overhead dominates a CrewAI run — serialization, memory search, tool execution, and connection contention.
Rust serde serialization
CrewAI passes JSON payloads between agents, memory, and tools constantly. Fast-CrewAI routes that hot path through serde via PyO3 instead of Python's json module.
FTS5 memory search
Default CrewAI memory retrieval uses LIKE scans that slow down as memory grows. Fast-CrewAI swaps in a SQLite FTS5 full-text index with BM25 ranking.
Tool result caching
Agents frequently re-invoke the same tool with the same arguments. Fast-CrewAI caches results and validates with serde, collapsing repeated calls.
Pooled DB connections
Concurrent agents contend for SQLite connections. Fast-CrewAI uses r2d2 connection pooling so parallel access no longer serializes on a single handle.
100% API compatibility
No fork, no rewrite. Fast-CrewAI monkey-patches CrewAI at import time via dynamic inheritance. Your Agents, Tasks, and Crews keep their exact API.
One-import activation
Add import fast_crewai.shim before your CrewAI imports and the accelerated paths switch on automatically. Nothing else in your codebase changes.
Granular toggles
Disable acceleration globally with FAST_CREWAI_ACCELERATION=0 for debugging, or turn individual accelerated components on and off independently.
Safe Python fallback
Pre-built wheels ship for Linux, macOS, and Windows on x86_64 and ARM64. If a native wheel is unavailable, Fast-CrewAI falls back to pure Python.
Open source, MIT
The full acceleration layer is MIT-licensed and developed in the open, with a public benchmark suite gating every release against a pinned CrewAI version.
Who it's for
Built for people shipping real CrewAI systems
Developers
You love CrewAI for the ergonomics but your staging runs are slow and token bills are climbing. Drop in one import and reclaim the minutes.
Migrate in 5 minutes →Architects
You're sizing multi-agent systems for production. Understand where CrewAI bottlenecks live and which subsystems to harden first.
Architecture patterns →Companies
You need a team that has read every line of CrewAI. Engage Neul Labs for audits, performance engineering, and bespoke agent builds.
Book a consultation →Knowledge base
Guides and CrewAI issue commentary
Memory search uses LIKE queries and gets quadratically slower
CrewAI's default RAG storage uses substring LIKE queries against SQLite, which are full table scans. As memory grows, every agent turn pays the full cost of the scan.
Production CrewAI architecture patterns
Architectural patterns for running CrewAI in production: memory layering, RAG pipelines, tool isolation, observability, and where Fast-CrewAI fits into each. Written for architects.
Fast-CrewAI vs CrewAI benchmarks, explained
Methodology, raw numbers, and honest caveats behind the 34.5× serialization, 17.3× tool execution, and 11.2× memory search claims. Everything you need to reproduce the results.
Long-term memory grows unbounded and nothing evicts it
CrewAI's long-term memory persists everything and has no default retention policy. Over weeks of production use, it grows without limit — degrading search quality and bloating SQLite files.
Tools get executed repeatedly with identical arguments
LLMs call the same tool with the same arguments over and over. CrewAI has no default caching layer, so every invocation pays the full cost — including the ones that are wasteful.
Migrating to Fast-CrewAI: the zero-code-changes playbook
What the one-line import actually does, how to verify it's active, how to toggle individual components, and how to roll back if something breaks. The honest migration guide.
Going deeper
Reference docs live on GitHub Pages
Full API reference, configuration matrix, and component internals are maintained in the canonical MkDocs site alongside the repo. New here? Start with the CrewAI performance FAQ.
Open technical documentation ↗Explore
Everything else worth a look
The full picture: how the acceleration works, where it pays off, how it compares, and who builds it.
Features
Every accelerated subsystem — serde serialization, FTS5 memory search, tool caching, connection pooling — with the benchmark numbers behind each.
See all features →How it works
The import shim, dynamic inheritance, and the PyO3 boundary that let Fast-CrewAI patch CrewAI hot paths without changing your code.
Read the internals →Use cases
Where the acceleration pays off: research crews, customer support automation, agentic data pipelines, and multi-tenant SaaS agents.
Browse use cases →Compare
Fast-CrewAI versus running stock CrewAI alone, and versus maintaining your own performance fork — honest trade-offs and when to pick which.
Compare options →FAQ
Runtime speedups versus CrewAI's startup-time boost, platform support, rollback, and the other questions teams ask before adopting.
Read the FAQ →About
Neul Labs, the AI engineering consultancy behind Fast-CrewAI, and the background on why the project exists.
Meet the team →Ready to make CrewAI faster?
Talk to the team that wrote the acceleration layer. We take on performance audits, full system builds, and retained engineering.