pip install agent-framework put 207 Python distributions and 912.4 MB into a clean Python 3.13 environment on November 20, 2026. pip install agent-framework-core, from the same Microsoft repository and the same 1.26.0 release, put in 11 distributions and 18.2 MB: a 50x difference for the same from agent_framework import Agent.
That is the headline from a small experiment I ran this morning. I installed 16 packages from 14 Python AI agent frameworks, each into its own empty virtual environment, then measured what landed on disk and how long the main agent class took to import. The research question was simple: what does choosing an AI agent framework cost you in install size, dependency count, and cold-start import time before you write a line of agent code?
Install size rarely shows up in framework comparisons. It does show up in your container image, your Lambda or Cloud Run cold start, your CI cache, and your dependency audit.
How was the install footprint measured?
Each package went into a fresh venv on one Linux box, and I measured that venv's site-packages.
-
Sample: 16 PyPI packages. That is the main package for LangGraph, CrewAI, OpenAI Agents SDK, Google ADK, Microsoft Agent Framework, Pydantic AI, smolagents, LlamaIndex, Agno, Strands Agents, Haystack, AutoGen AgentChat, AG2 and DSPy, plus the slim variants
agent-framework-coreandpydantic-ai-slim. -
Install:
uv venv -p python3.13thenuv pip install <package>(uv 0.13.8), resolving the latest versions on PyPI on November 20, 2026, with no extras. -
Size:
du -sbofsite-packagesafter deleting every__pycache__, so compiled bytecode is not counted. "Distributions" is the count fromuv pip list. -
Import time: wall-clock time of
python -c "<import the main agent class>", run once to warm the bytecode, then 9 timed runs. I report the median. "Modules" islen(sys.modules)after that import. - Machine: x86_64 Linux, 8 vCPU, Python 3.13.5.
-
Limitations: Wheels differ by platform, so macOS and Windows sizes will not match. Import times come from a shared cloud VM and will vary by a few tens of milliseconds between runs. Installing with pip instead of uv resolves the same dependency set, but pip adds itself to the venv. Extras such as
crewai[tools]were not installed, so real projects are often larger than this.
The table below is the full dataset: version, distribution count, size, largest top-level directory, import time and module count for every package.
Which AI agent framework has the largest install?
Microsoft Agent Framework's meta package is the largest at 912.4 MB, and CrewAI comes second at 604.7 MB.
| Package (version) | Distributions | site-packages | Largest directory | Import median | Modules loaded |
|---|---|---|---|---|---|
| agent-framework 1.26.0 | 207 | 912.4 MB | claude_agent_sdk, 378.1 MB | 0.180 s | 322 |
| crewai 1.15.44 | 119 | 604.7 MB | lancedb, 189.9 MB | 1.731 s | 2,135 |
| llama-index 0.14.26 | 71 | 184.3 MB | numpy, 28.7 MB | 0.934 s | 1,331 |
| pydantic-ai 2.71.0 | 96 | 127.9 MB | cryptography, 14.9 MB | 0.735 s | 1,170 |
| haystack-ai 3.5.0 | 41 | 97.4 MB | numpy, 28.7 MB | 0.445 s | 1,067 |
| strands-agents 1.65.0 | 48 | 64.5 MB | botocore, 21.1 MB | 0.417 s | 917 |
| google-adk 2.15.0 | 48 | 64.4 MB | google, 24.7 MB | 0.686 s | 562 |
| langgraph 1.2.24 | 38 | 53.3 MB | zstandard, 23.9 MB | 0.560 s | 1,029 |
| smolagents 1.26.0 | 28 | 52.5 MB | pillow.libs, 14.7 MB | 0.327 s | 725 |
| openai-agents 0.25.0 | 38 | 49.6 MB | cryptography, 14.9 MB | 1.083 s | 1,358 |
| agno 3.2.1 | 31 | 49.6 MB | agno, 23.6 MB | 0.309 s | 480 |
| autogen-agentchat 0.7.5 | 11 | 30.4 MB | pillow.libs, 14.7 MB | 0.231 s | 436 |
| dspy 3.5.0 | 26 | 24.0 MB | pydantic_core, 5.3 MB | 0.470 s | 796 |
| pydantic-ai-slim 2.71.0 | 17 | 23.8 MB | pydantic_ai, 10.9 MB | 0.499 s | 679 |
| agent-framework-core 1.26.0 | 11 | 18.2 MB | pydantic_core, 5.3 MB | 0.160 s | 322 |
| ag2 1.3.3 | 14 | 16.6 MB | pydantic_core, 5.3 MB | 0.242 s | 531 |
Measured November 20, 2026. Python 3.13.5, uv 0.13.8, Linux x86_64. Sizes exclude __pycache__.
The spread runs from 16.6 MB (AG2) to 912.4 MB, a 55x range across packages that all give you an agent loop with tool calling.
Why is pip install agent-framework 912 MB?
The meta package installs every integration, and one of them bundles a full Claude Code binary.
The agent-framework 1.26.0 package declares a single requirement, agent-framework-core[all]==1.26.0. The all extra pulls in 29 agent-framework-* integration packages: connectors for Anthropic, Bedrock, Gemini, Mistral, Ollama, Redis, Cosmos DB, Foundry, Copilot Studio, Purview, DevUI and more. One of them, the Claude connector, depends on claude-agent-sdk (0.2.186 in this install). That package's _bundled/ folder holds a claude executable whose version file reads 2.1.329 (Claude Code).
That one directory is 378.1 MB, or 41% of the whole environment. After it, the next largest directories are onnxruntime, python_guest, foundry_local_sdk, numpy and botocore.
If you only need one or two model providers, the practical fix is to install agent-framework-core plus the specific agent-framework-<provider> packages you call. The import path is the same: from agent_framework import Agent worked in both environments. Because the meta package loads its integrations lazily, its import time (0.180 s) is almost identical to core's (0.160 s). Neither one loaded more than 322 modules to get Agent. The cost of the meta package is disk, image size and supply-chain surface, not startup time.
Why does CrewAI take 1.7 seconds to import?
CrewAI eagerly loads 2,135 modules, which is more than any other package in this test, and it requires a vector-database stack.
crewai 1.15.44 lists lancedb and qdrant-client as hard requirements, not extras. LanceDB requires pyarrow. Together, lancedb (189.9 MB) and pyarrow (171.2 MB) are 361.1 MB of CrewAI's 604.7 MB, or 60%. LanceDB and Qdrant are both vector stores, the kind of dependency that backs agent memory and knowledge retrieval. Every CrewAI install pays for them, whether or not your crew uses those features.
The import number matters more than the disk number for short-lived workers. A 1.731 s median to run from crewai import Agent, Crew is 1.7 s added to every cold start in a serverless function or a per-task container. The next slowest were the OpenAI Agents SDK (1.083 s) and LlamaIndex (0.934 s).
Does a bigger install mean a slower import?
No. In this sample, disk size and import time barely track each other.
The largest install (agent-framework, 912.4 MB) imported in 0.180 s. The OpenAI Agents SDK, the 10th-largest install at 49.6 MB, took 1.083 s and loaded 1,358 modules. Lazy imports decide import time, and the dependency list decides disk size. You have to measure both, because neither predicts the other.
GitHub popularity does not predict either one. In aiagentsinfo.com's GitHub stats snapshot of 19 agent framework repositories, taken on November 5, 2026, crewAIInc/crewAI had 60,514 stars and pydantic/pydantic-ai had 21,032. On install weight their order flips: CrewAI is 604.7 MB, and Pydantic AI's full package is 127.9 MB, or 23.8 MB as pydantic-ai-slim. That same snapshot found that 14 of the 19 repositories had a release within 30 days. That is one more reason to re-measure after each upgrade rather than trust last quarter's image size.
Are the slim packages worth it?
Yes, if you know which providers you need. The slim packages cut size by 5x to 50x without changing your import line.
-
pydantic-ai→pydantic-ai-slim: 96 → 17 distributions, 127.9 → 23.8 MB (5.4x smaller), import 0.735 → 0.499 s. The full package pulls in the OpenAI, Anthropic and Google GenAI SDKs, OpenTelemetry,tiktokenand MCP. The slim one lets you add only the extras you use, for examplepydantic-ai-slim[openai]. -
agent-framework→agent-framework-core: 207 → 11 distributions, 912.4 → 18.2 MB (50x smaller).
Be careful with download counts here. aiagentsinfo.com's daily PyPI download tracker for pydantic-ai-slim recorded 9,010,191 downloads from November 13 to 19, 2026, against 1,577,815 for pydantic-ai. But pydantic-ai depends on the slim package, so every full install also downloads the slim one. That gap counts dependency installs, CI runs and direct slim users together. It does not show how many teams chose slim on purpose. The same caveat applies to the CrewAI download history and the rest of the framework downloads tracker: a download is a file request, not a project.
How should this change which framework you pick?
Install footprint should break ties, not make the decision. The capability you need comes first.
A graph runtime with checkpointing, a role-based crew, and a minimal handoff loop solve different problems. The comparison of LangGraph, CrewAI and the OpenAI Agents SDK and the broader guide to the best AI agent frameworks cover that side. If protocol support decides it for you, there is also a check of which frameworks support MCP and A2A.
Once you have two or three candidates, the numbers above turn into a short checklist:
-
Container or serverless? Avoid meta packages. Install the core package plus the provider packages you use, and run
du -sh $(python -c "import site; print(site.getsitepackages()[0])")in CI so an upgrade that adds 300 MB fails a size budget instead of shipping silently. -
Cold starts matter? Time your real import line with
python -X importtime -c "...". In this run, 1.7 s (CrewAI) and 0.16 s (agent-framework-core) both count as "fast" in a notebook, but they behave very differently in a function that starts 10,000 times a day. - Security review? The distribution count is your dependency audit surface. 207 packages and 11 packages are very different reviews, even when they come from the same vendor.
-
Check for bundled binaries. A 378 MB executable inside a Python wheel is easy to miss in
pip listand obvious indu.
What's the takeaway?
The same agent class can cost you 18 MB or 912 MB, depending on which package name you type. In both of the full-versus-slim pairs I measured, the obvious package name was the heavy one. Measure your own install before you ship.
I'll re-run this measurement as new versions land. If you maintain one of these frameworks and think a number is wrong, the install and import commands are listed above so you can reproduce it.
This article was written with AI assistance and reviewed for accuracy.
Top comments (1)
The 50× gap between the meta package and core is striking, especially with the same import path and nearly identical import time. Have you considered adding a one-provider install with common extras enabled? That would make the numbers easier to apply to a typical deployment.