# Why are top engineers DITCHING MCP Servers? (3 PROVEN Solutions) Source: https://www.youtube.com/watch?v=OIKTsVjTVJE Recap page: https://rapidrecap.app/video/OIKTsVjTVJE Generated: 2025-11-10T14:44:01.259+00:00 --- ## Quick Overview The video demonstrates that building custom agent tooling using CLI scripts and skills offers significant advantages over relying solely on a centralized MCP server, primarily by reducing context window consumption (e.g., from 26% down to 5.6% when using scripts) and offering greater control and portability, while still allowing for complex interactions like tool chaining and external API access. **Key Points:** - The CLI approach (using `kaishi_cli_tools`) consumes significantly less context (e.g., 5.6% vs. 26% with the initial MCP server setup) by replacing large tool definitions with concise, self-contained Python scripts. - The Scripts approach, specifically using the file system scripts, eliminates the need to pass the entire tool definition into the context window every time, leading to major context efficiency gains. - The Skills approach (using `4_skill`) is the most powerful for complex interactions as it allows for tool chaining and context preservation within the skill's definition file (`SKILL.md`), which is read by the agent. - The CLI tools, unlike the MCP server, require local prompts for composability, but offer better portability and simplicity. - The video compares four approaches: MCP Server (high context use), CLI (medium context, good simplicity), Scripts (low context, high portability), and Skills (low context, high feature set, cloud lock-in). - The video concludes that a hybrid approach—leveraging CLI/Scripts for simple tools and Skills for complex, multi-step agent interactions—offers the best balance of control, context efficiency, and capability. ![Screenshot at 04:03: The diagram illustrating the Script Tooling approach shows the Agent receiving input from 'You', processing it through 'prompt.md', executing the 'cli.py' script, which accesses the 'Kaishi \(Data Source\)' for market data, showcasing a direct, modular flow.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-04-03.png) **Context:** The creator, IndyDevDan, explores advanced methods for equipping AI agents with external capabilities, moving beyond the standard Model-Client-Prompt (MCP) server architecture which incurs high context window costs. The video contrasts four distinct tooling approaches: MCP Servers, a local Command Line Interface (CLI), self-contained Python Scripts, and Skills (like those used in Anthropic's ecosystem), analyzing the engineering trade-offs of each. ## Detailed Analysis The video breaks down four methods for giving AI agents external tooling capabilities: MCP Servers, CLI (command-line interface), Scripts, and Skills. The primary issue with MCP Servers is high context window consumption (e.g., 26% of the context window for tools alone), which is mitigated by the other approaches. The CLI approach is medium in context use but requires local prompts for composability. The Scripts approach (using self-contained Python files) drastically reduces context use (down to 5.6% for messages/tools) because it only loads the necessary script definition on demand. Skills offer high portability and feature sets but result in vendor lock-in (e.g., to Claude). The author recommends a hybrid approach: use CLI or Scripts for simple, immediate tasks (like querying Kaishi markets) and Skills when more complex, multi-step logic or context preservation across sessions is required. The file system scripts are shown to be self-contained, requiring no external dependencies, making them highly portable. The key takeaway is that context efficiency is paramount, and custom scripting/skills offer significant advantages over relying on constantly loaded MCP server tool definitions. ### Tooling Comparison - MCP (High Context, Yes Agent, Low Portability) - CLI (Medium Context, No Agent, Medium Portability) - Scripts (Low Context, No Agent, High Portability) - Skills (Low Context, Yes Agent, High Portability but Cloud Lock-in) ### External Tools (Scripts) - Self-contained Python scripts with zero dependencies, using `-json` flag for structured output, and no authentication required. - Workflow involves priming the agent with the script documentation, then running `run --help` for options or executing the script directly. ### CLI Tooling - Requires local prompts for composability, medium context consumption, and medium engineering investment, offering good simplicity. ### Skills Approach - Offers high portability and feature set but introduces vendor lock-in and requires explicit context management for tool definitions. ### The Stakeholder Trifecta - A successful tooling approach must work for You (the engineer), Your Team (collaboration), and Your Agents (tool usability), favoring CLI/Scripts for simplicity and Skills/MCP for complex, context-heavy scaling. ### Key Takeaways - The goal is to minimize context usage by only loading necessary tool definitions, favoring CLI/Scripts for rapid prototyping and Skills for complex, stateful operations. ![Screenshot at 00:02: IndyDevDan introducing the topic of comparing different agent tooling approaches \(MCP, CLI, Scripts, Skills\).](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-00-02.png) ![Screenshot at 00:04: Visual representation of the 10,000 tokens consumed by the MCP server setup before the agent even starts working, highlighting context cost.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-00-04.png) ![Screenshot at 00:10: Context usage breakdown showing that MCP tools alone consume 14.8% of the context window.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-00-10.png) ![Screenshot at 00:31: Diagram contrasting the MCP Server structure with the Agent, Skills, and Data Source flow.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-00-31.png) ![Screenshot at 01:10: Diagram illustrating the basic MCP Server connection flow: You -\> Agent -\> MCP Server -\> Kalshi \(Data Source\).](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-01-10.png) ![Screenshot at 01:24: Agentic Capability comparison chart showing Haiku \(4.5\), Sonnet \(4.5\), and Opus \(4.1\) scores for solving problems, overlaid on the terminal output.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-01-24.png) ![Screenshot at 01:39: Demonstration of using the CLI tool mcp to list connected servers, showing 'kalshi' is connected.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-01-39.png) ![Screenshot at 03:55: The introduction slide for the Script Tools approach, emphasizing incremental context and tools for agents.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-03-55.png) ![Screenshot at 04:03: Diagram illustrating the Script Tooling flow: You -\> Agent -\> prompt.md -\> cli.py -\> Kalshi \(Data Source\), showing modularity.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-04-03.png) ![Screenshot at 04:44: Agent executing prime\_kaishi\_cli\_tools, which reads documentation files for context, demonstrating progressive disclosure capability of the file system script approach.](https://ss.rapidrecap.app/screens/OIKTsVjTVJE/00-04-44.png)