mcp-code-execution

athola's avatarfrom athola

Transform tool-heavy workflows into MCP code execution patterns for token savings and optimized processing.Triggers: MCP, code execution, tool chain, data pipeline, tool transformation, batch processing, workflow optimizationUse when: >3 tools chained sequentially, large datasets (>10k rows), large files (>50KB), context usage >25%DO NOT use when: simple tool calls that don't chain.DO NOT use when: context pressure is low and tools are fast.Use this skill BEFORE building complex tool chains. Optimize proactively.

⭐83stars🔀11forks📁View on GitHub🕐Updated Jan 3, 2026⬇️1downloads

When & Why to Use This Skill

The MCP Code Execution skill is a high-performance orchestration hub designed to optimize complex, tool-heavy workflows within the Model Context Protocol (MCP) ecosystem. It specializes in transforming sequential tool chains into efficient code execution patterns, achieving up to 85% token savings. By proactively managing context pressure and implementing Model Execution Context Window (MECW) compliance, it ensures stable performance for long-running agentic tasks and data-intensive operations.

Use Cases

  • Large-Scale Data Processing: Efficiently handling datasets exceeding 10,000 rows or files larger than 50KB by refactoring tool calls into optimized batch patterns.
  • Token-Efficient Workflow Automation: Reducing overhead in complex agentic sequences where more than three tools are chained, preserving the context window for critical reasoning.
  • Context-Aware Resource Management: Automatically deferring and discovering tools via MCPSearch when descriptions exceed context thresholds, preventing 'context drowning' in high-pressure environments.
  • Multi-Module Orchestration: Coordinating specialized sub-agents and validation modules to ensure high success rates and hallucination prevention in sophisticated technical workflows.
namemcp-code-execution
description|
TriggersMCP, code execution, tool chain, data pipeline, tool transformation, batch processing, workflow optimization
Use when>3 tools chained sequentially, large datasets (>10k rows), large files (>50KB), context usage >25%
DO NOT use whencontext pressure is low and tools are fast.
locationplugin
token_budget200
progressive_loadingtrue
hub[context-optimization, token-conservation]
modules[mcp-subagents, mcp-patterns, mcp-validation]

Table of Contents

MCP Code Execution Hub

Quick Start

Basic Usage

```bash

Run the main command

python -m module_name

Show help

python -m module_name --help ```

Verification: Run with --help flag to confirm installation.

When to Use

  • Automatic: Keywords: code execution, MCP, tool chain, data pipeline, MECW
  • Tool Chains: >3 tools chained sequentially
  • Data Processing: Large datasets (>10k rows) or files (>50KB)
  • Context Pressure: Current usage >25% of total window (proactive context management)

MCP Tool Search (Claude Code 2.1.7+): When MCP tool descriptions exceed 10% of context, tools are automatically deferred and discovered via MCPSearch instead of being loaded upfront. This reduces token overhead by ~85% but means tools must be discovered on-demand. Haiku models do not support tool search. Configure threshold with ENABLE_TOOL_SEARCH=auto:N where N is the percentage.

Core Hub Responsibilities

  • Orchestrates MCP code execution workflow
  • Routes to appropriate specialized modules
  • Coordinates MECW compliance across submodules
  • Manages token budget allocation for submodules

Required TodoWrite Items

  1. mcp-code-execution:assess-workflow
  2. mcp-code-execution:route-to-modules
  3. mcp-code-execution:coordinate-mecw
  4. mcp-code-execution:synthesize-results

Step 1 – Assess Workflow (mcp-code-execution:assess-workflow)

Workflow Classification

def classify_workflow_for_mecw(workflow):
    """Determine appropriate MCP modules and MECW strategy"""

    if has_tool_chains(workflow) and workflow.complexity == 'high':
        return {
            'modules': ['mcp-subagents', 'mcp-patterns'],
            'mecw_strategy': 'aggressive',
            'token_budget': 600
        }
    elif workflow.data_size > '10k_rows':
        return {
            'modules': ['mcp-patterns', 'mcp-validation'],
            'mecw_strategy': 'moderate',
            'token_budget': 400
        }
    else:
        return {
            'modules': ['mcp-patterns'],
            'mecw_strategy': 'conservative',
            'token_budget': 200
        }

Verification: Run the command with --help flag to verify availability.

MECW Risk Assessment

Delegate to mcp-validation module for detailed risk analysis:

def delegate_mecw_assessment(workflow):
    return mcp_validation_assess_mecw_risk(
        workflow,
        hub_allocated_tokens=self.token_budget * 0.5
    )

Verification: Run the command with --help flag to verify availability.

Step 2 – Route to Modules (mcp-code-execution:route-to-modules)

Module Orchestration

class MCPExecutionHub:
    def __init__(self):
        self.modules = {
            'mcp-subagents': MCPSubagentsModule(),
            'mcp-patterns': MCPatternsModule(),
            'mcp-validation': MCPValidationModule()
        }

    def execute_workflow(self, workflow, classification):
        results = []

        # Execute modules in optimal order
        for module_name in classification['modules']:
            module = self.modules[module_name]
            result = module.execute(
                workflow,
                mecw_budget=classification['token_budget'] //
                len(classification['modules'])
            )
            results.append(result)

        return self.synthesize_results(results)

Verification: Run the command with --help flag to verify availability.

Step 3 – Coordinate MECW (mcp-code-execution:coordinate-mecw)

Cross-Module MECW Management

  • Monitor total context usage across all modules
  • Enforce 50% context rule globally
  • Coordinate external state management
  • Implement MECW emergency protocols

Step 4 – Synthesize Results (mcp-code-execution:synthesize-results)

Result Integration

def synthesize_module_results(module_results):
    """Combine results from MCP modules into structured output"""

    return {
        'status': 'completed',
        'token_savings': calculate_savings(module_results),
        'mecw_compliance': verify_mecw_rules(module_results),
        'hallucination_risk': assess_hallucination_prevention(module_results),
        'results': consolidate_results(module_results)
    }

Verification: Run the command with --help flag to verify availability.

Module Integration

With Context Optimization Hub

  • Receives high-level MECW strategy from context-optimization
  • Returns detailed execution metrics and compliance data
  • Coordinates token budget allocation

Performance Skills Integration

  • uses python-performance-optimization through mcp-patterns
  • Aligns with cpu-gpu-performance for resource-aware execution
  • validates optimizations maintain MECW compliance

Emergency Protocols

Hub-Level Emergency Response

When MECW limits exceeded:

  1. Delegates immediately to mcp-validation for risk assessment
  2. Route to mcp-subagents for further decomposition
  3. Apply compression through mcp-patterns
  4. Return minimal summary to preserve context

Success Metrics

  • Workflow Success Rate: >95% successful module coordination
  • MECW Compliance: 100% adherence to 50% context rule
  • Token Efficiency: Maintain >80% savings vs traditional methods
  • Module Coordination: <5% overhead for hub orchestration

Troubleshooting

Common Issues

Command not found Ensure all dependencies are installed and in PATH

Permission errors Check file permissions and run with appropriate privileges

Unexpected behavior Enable verbose logging with --verbose flag