AI Letters #25 - The Built-in Tool Race: 30 vs 29 vs 12 (And Why the Headline Number Lies)

"Both SynapseKit and LangChain claim roughly 30 built-in tools. The difference is whether 'built-in' means 'works on install' or 'works after twelve more pip installs'."

Every LLM framework advertises its tool ecosystem. The numbers look impressive in the docs. Then you try to actually use them and discover that half of them require a separate pip install, a third require an API key, and a handful only work on specific operating systems.

Notebook #17 of the LLM Showdown did the audit nobody does in the benchmarks: count only what actually ships in the base install, then split by what works with zero configuration versus what needs extra setup. The headline totals are almost identical - 30, 29, 12. The zero-config counts are not.

Interactive Chart

Tool Ecosystem Timeline →

From the @tool decorator to batteries-included frameworks. Click each milestone to see how each design philosophy evolved and what it costs today.

Interactive Explorer

Tool Category Explorer →

Click any of 9 capability categories to see which frameworks cover it - and whether the tools work immediately or need extra pip installs and API keys.

Evidence Dashboard

Full Benchmark Results →

Total tools stacked, zero-config breakdown, category heatmap - all data from notebook #17 in one view.

What the Numbers Actually Mean

The benchmark defines built-in strictly: only tools included when you run pip install framework. Third-party integrations requiring a separate pip install per tool are counted separately.

Total built-in tools:

Framework       Core tools   Extra-pip tools   Total
-----------------------------------------------------
SynapseKit              30                 0      30
LangChain               17                12      29
LlamaIndex               3                 9      12

SynapseKit and LangChain are nearly tied on total. But LangChain's 12 community tools each require a separate install - pip install duckduckgo-search, pip install slack-sdk, pip install arxiv - before they do anything. SynapseKit's 30 ship as implementations, not wrappers. LlamaIndex has 3 core tool types (FunctionTool, QueryEngineTool, RetrieverTool) and 9 hub packages, all requiring pip install llama-index-tools-*.

Zero-config tools (no API key, no extra pip install):

Framework       Zero-config tools
----------------------------------
SynapseKit                     12
LangChain                      10
LlamaIndex                      3

This is the number that matters for prototyping speed. SynapseKit gives you calculator, datetime, regex, file I/O, Python REPL, shell, HTTP requests, web scraping, and human input - zero additional setup. LangChain gives you file management and shell tools, plus the @tool decorator pattern itself. LlamaIndex gives you the three wrapper types and nothing else that runs without extra installs.

Category coverage:

Framework       Categories covered
------------------------------------
SynapseKit                       9
LangChain                        9
LlamaIndex                       5

SynapseKit and LangChain both cover 9 distinct capability areas. LlamaIndex covers 5 - and its coverage is mostly retrieval-oriented, which matches its RAG-first design.

The Design Philosophy Underneath the Numbers

Tool philosophy - what "built-in" actually means

SynapseKit          LangChain           LlamaIndex
──────────────      ──────────────      ──────────────
Implementations     Thin wrappers       Primitives only
ship in package     delegate to         tools are app-
                    third-party libs    level concerns

pip install X       pip install X       pip install X
-> tool works       + pip install Y     + pip install
                    per community tool  llama-index-
                                       tools-* per tool

30 tools ready      17 tools ready      3 types ready
12 need nothing     10 need nothing     3 need nothing

LangChain's approach is deliberate. Thin wrappers mean the framework doesn't own the dependency - the underlying library (DuckDuckGo, Slack, arXiv) handles updates, auth, rate limiting. The wrapper just shapes it into the tool interface. The cost: an extra pip install every time you want a new capability, and occasional version conflicts between the wrapper and the underlying library.

SynapseKit's approach means more to maintain internally - when the DuckDuckGo API changes, SynapseKit's implementation breaks, not a third-party wrapper. The benefit: pip install synapsekit and you have a working web search tool.

LlamaIndex made a different bet entirely: tools are application concerns, not framework concerns. You build what you need with FunctionTool. The hub packages exist for common cases but they're optional additions, not the core product.

What This Means for Engineers

1. For prototyping and hackathons: SynapseKit's 12 zero-config tools mean you can build a working agent that does web scraping, file I/O, Python execution, and HTTP calls before you've set up a single API key. That's a real time advantage in time-constrained settings.

2. The LangChain community tool count is misleading. When comparing frameworks, don't count community wrappers the same as core tools. A wrapper that requires 3 extra pip installs and an API key is not in the same category as a tool that works immediately.

3. LlamaIndex's 3 core tools are not a weakness - they're a constraint. The framework explicitly doesn't try to solve the tool problem. If you're already using LlamaIndex for retrieval, your query engines and retrievers become first-class tools. Everything else you write yourself with FunctionTool.

4. Multimodal is where the gap is largest. SynapseKit ships ImageAnalysisTool, SpeechToTextTool, and TextToSpeechTool in base. LangChain's multimodal tools (OpenAITextToSpeechTool, OpenAIWhisperParser) require the OpenAI package and API key. LlamaIndex has nothing multimodal in core.

5. The "thin wrapper" model has long-term benefits. LangChain's community tools don't go stale the same way SynapseKit's implementations might - the underlying library handles the API. For production systems running for years, that matters.

The Thing Most People Miss

The zero-config number is a proxy for something deeper: how much cognitive overhead does the framework impose before you can test an idea? Twelve pip installs plus API keys means twelve things to track, debug, and version-pin. Three zero-config tools means three things.

This matters most at the beginning of a project, when you're still figuring out whether your agent architecture is viable. If the framework makes you spend an hour on setup before you can test your first tool call, you're optimising the wrong variable.

SynapseKit wins on setup speed. LangChain wins on long-term maintainability of individual tools. LlamaIndex wins when your tools are retrieval pipelines you were building anyway.

Three Things Worth Doing This Week

1. Audit your current agent's tool imports. Count how many separate pip installs they require. If it's more than 5, ask whether that's accidental complexity or intentional.

2. Test your critical tools with no internet access. Zero-config tools that only need local resources are more reliable in production than tools that call external APIs for every invocation.

3. Read the tool source, not just the docs. For any LangChain community tool you use, find the underlying library it wraps. That library's changelog is more relevant to your upgrade path than LangChain's.

The built-in tool count is marketing. The zero-config count is engineering. Know which number you're optimising for.

Engineers of AI

Read more: www.engineersofai.com

If this was useful, forward it to one engineer who should be reading it.