AI Agents Shed Token Bloat with New Skill-Based Approach
The landscape of AI agent development is undergoing a significant shift, moving away from traditional, token-intensive tool integration methods towards a more efficient and scalable system. Recent advancements highlight how open-source tools can drastically reduce token consumption for coding agents, extending their capabilities without overwhelming their context windows.
The Problem with Traditional MCP Tools
Historically, AI agents have relied on methods like Multi-Tool Calling Protocol (MCP) servers. While these servers provide a bundle of different tools, each with its own JSON schema and associated information, this data is often loaded into the agent’s context regardless of its immediate relevance. This leads to unnecessary consumption of valuable context window space, limiting the agent’s ability to process and act on new information.
Introducing Skills and CRI: A Scalable Alternative
A more scalable and user-friendly approach has emerged: the combination of ‘skills’ and Command-Line Interface (CRI) tools. This method allows developers to extend an agent’s capabilities to hundreds of different integrations with minimal token overhead. Experimentation has shown that this approach can lead to over 70% reduction in token consumption compared to traditional MCP methods.
The ‘skill’ concept, gaining popularity recently, involves creating a simple Markdown file (skill.md) that contains a snippet of a prompt to be injected into the agent when the skill is retrieved, along with a list of resources the agent can use. Crucially, loading a skill adds only a minimal amount of tokens to the context window. For instance, the description for a single skill might only add 10 to 50 tokens. This means that the token space consumed by a few MCP tools could potentially accommodate thousands of different skills, far exceeding any practical need.
How Skills and CRI Work Together
When an agent executes a skill, the associated prompt is added to its context. This context can then instruct the agent on how to utilize other resources to gather relevant information or execute predefined scripts. This skill-based setup is enabling the creation of much more token-efficient agents.
A notable example of this paradigm shift is seen in the practices of developers like Manis. They have broken down agent tools into fundamental, always-useful capabilities (like reading/writing files) and less frequent tools. The latter are often placed under a command-line interface that the agent can call upon when needed. Instead of directly exposing an MCP to the agent, Manis agents can call a specific CRI tool (e.g., `manus_mcp_cri`) to execute MCP functions. This approach not only saves tokens but also leverages the inherent capabilities of CRI, allowing agents to perform more complex actions, pipe multiple commands together, and handle errors more effectively.
Real-World Impact: Browser Automation Example
To illustrate the benefits, consider browser automation. Traditional browser tools, such as Playwright or even Cloud Code’s own Chrome MCP, can be complex and consume a significant portion of the context window (e.g., 2% or more). This can drastically reduce the effective context available for the agent’s primary tasks.
In contrast, solutions like ‘Agent Browser’ have adopted the skill and CRI approach. Instead of integrating a full MCP tool, they provide a CRI package that agents can run from the command line to perform various browser actions. This method is optimized to return information that helps the agent understand page structure and interactive elements efficiently. By using this skill-based CRI, the same task that consumed a large chunk of context with MCP tools can be completed with significantly less token usage – potentially saving up to 70% of the context window.
Migrating from MCP to Skills with MC P-Porter
The recommendation for developers is to migrate away from MCP tools towards skills. To facilitate this transition, open-source tools like ‘MCP P-Porter’ are emerging. MCP P-Porter allows MCP tools to be run directly via the command line, providing agents with the necessary helper functions and schema information to interact with MCP servers.
This enables developers to integrate MCP functionality by adding a single skill file instead of multiple MCP tools. For example, instead of adding seven different MCP tools for a specific service, a developer can add one skill.md file that describes how to use the MCP P-Porter to call specific functions within that service. This results in a dramatic reduction in token consumption – potentially just a few hundred tokens for numerous skills, compared to thousands for extensive MCP tool integration.
The process can be further automated. A skill like ‘Add New MCPs’ can be created, which guides the agent on how to use MCP P-Porter, install MCP servers, and generate relevant skill files for new integrations. This not only simplifies the addition of new capabilities but also ensures they are implemented in a token-efficient manner.
The Future of Agent Integration
This shift towards skills and CRI represents a fundamental change in how AI agents can be extended. It offers greater freedom in task execution, improved performance, and a more scalable architecture. Companies and developers are encouraged to explore this approach to unlock the full potential of their AI agents without being constrained by context window limitations.
HubSpot’s Cloud Co-Pilot Research
In related news, HubSpot has released free research and materials on HubSpot’s Cloud Co-Pilot, a version of Cloud Code designed to automate not just coding but also knowledge work. This research offers a glimpse into the future of white-collar work. HubSpot’s experiments across hundreds of use cases have identified 12 advanced prompts and use cases that are programmatically useful. These include automated content performance analysis, generation of business documents (job descriptions, SOPs, email sequences), continuous file system organization, and scheduled competitive intelligence reports. Each use case comes with a ready-to-use prompt designed to trigger a predefined Cloud Co-Pilot process.
This resource, available for free download via a link in the video description, provides valuable insights into the paradigm shift Cloud Co-Pilot is poised to introduce.
Source: Why MCP is dead & How I vibe now (YouTube)
