MCP Server Sprawl: Token Cost Real Numbers

# Token cost of MCP tool descriptions in system prompt
mcp_servers = {
    "filesystem": 8,     # read, write, list, mkdir, etc.
    "github": 15,        # issues, PRs, repos, branches, etc.
    "slack": 12,         # send, read, channels, users, etc.
    "postgres": 6,       # query, schema, tables, etc.
    "web-search": 3,     # search, fetch, extract
    "memory": 4,         # store, retrieve, list, delete
    "calendar": 8,       # events, create, update, delete, etc.
    "email": 10,         # send, read, search, labels, etc.
}

tokens_per_tool = 150  # average including schema
total_tools = sum(mcp_servers.values())
total_tokens = total_tools * tokens_per_tool

print(f"Total tools: {total_tools}")
print(f"System prompt tokens from tools: {total_tokens:,}")

# Cost per agent turn (tool descriptions are repeated every inference)
llm_rates = {
    "Claude Sonnet 4": 3.0,
    "Claude Opus 4": 15.0,
    "GPT-4o": 2.5,
}

for model, rate in llm_rates.items():
    cost_per_turn = (total_tokens / 1_000_000) * rate
    print(f"\n{model}:")
    print(f"  Tool description cost per turn: ${cost_per_turn:.4f}")
    print(f"  Over 20 turns: ${cost_per_turn * 20:.3f}")
    print(f"  Over 1000 sessions/day: ${cost_per_turn * 20 * 1000:.2f}/day")

# Realistic agent session cost with MCP sprawl
system_prompt_tokens = 10000    # Tool descriptions
conversation_tokens = 3000      # User messages + previous turns
tool_result_tokens = 500        # Average per tool call result

# Agent makes 8 tool calls to answer a question (too many)
tool_calls = 8
necessary_calls = 3  # Only 3 were actually needed

# Total tokens processed across all turns
total_input_tokens = 0
for i in range(tool_calls):
    turn_tokens = system_prompt_tokens + conversation_tokens + (tool_result_tokens * i)
    total_input_tokens += turn_tokens

rate = 3.0  # Claude Sonnet 4 per 1M input tokens
total_cost = (total_input_tokens / 1_000_000) * rate
necessary_cost = sum(
    system_prompt_tokens + conversation_tokens + (tool_result_tokens * i)
    for i in range(necessary_calls)
) / 1_000_000 * rate

print(f"Total input tokens (8 calls): {total_input_tokens:,}")
print(f"Actual cost: ${total_cost:.4f}")
print(f"Necessary cost (3 calls): ${necessary_cost:.4f}")
print(f"Wasted: ${total_cost - necessary_cost:.4f} ({(1 - necessary_cost/total_cost)*100:.0f}%)")

# MCP tool scoping configuration
TASK_SCOPES = {
    "research": ["web-search", "memory"],
    "coding": ["filesystem", "github"],
    "communication": ["slack", "email", "calendar"],
    "data": ["postgres", "filesystem"],
    "full": None,  # All tools, use sparingly
}

def get_tools_for_task(task_type):
    """Return only the MCP servers needed for this task type."""
    scope = TASK_SCOPES.get(task_type, TASK_SCOPES["research"])
    if scope is None:
        return ALL_MCP_SERVERS  # Full access when explicitly needed
    return {k: v for k, v in ALL_MCP_SERVERS.items() if k in scope}

# Token savings
def estimate_savings(task_type):
    all_tools = sum(mcp_servers.values())
    scoped_servers = TASK_SCOPES.get(task_type, [])
    if scoped_servers is None:
        return 0
    scoped_tools = sum(mcp_servers.get(s, 0) for s in scoped_servers)
    saved_tokens = (all_tools - scoped_tools) * 150
    return saved_tokens

for task, scope in TASK_SCOPES.items():
    if scope is not None:
        saved = estimate_savings(task)
        print(f"{task}: saves {saved:,} tokens/turn")