House MCP Manager — Summary

A TypeScript CLI tool (house-mcp-manager) that addresses the context-window token problem caused by MCP servers loading all their tool definitions at startup. The tool manages MCP server enable/disable states across Claude Code, Cursor, and Cline, allowing users to profile and switch between server configurations without manually editing JSON files.

The core insight is quantified in the README: individual MCP servers can consume 78,000+ tokens at startup (Canvas MCP), and loading all configured servers can consume 127,000 tokens — 63% of a 200K context window — before the user writes a single line of code. House MCP Manager provides an interactive TUI checkbox interface and profile save/load to solve this.

The tool uses an adapter pattern per IDE: it reads and mutates ~/.claude.json for Claude Code, ~/.cursor/mcp.json for Cursor, and VS Code's settings.json for Cline. It also supports project-level configuration with inheritance from user-level config. All operations are safe (automatic backups, JSON validation).

Part of the "House suite" alongside house-code (context-efficient Claude Code clone) and house-agents (sub-agent framework). Compared to seeds: this is closest to a tooling utility that augments agent-os — it has no skill files, no agents, no hooks, just a CLI binary that manages the JSON config files that MCP clients read. Unlike all 11 seeds, it's the only framework whose primary purpose is controlling MCP server token consumption rather than workflow methodology.

House MCP Manager — Overview

Origin

Created by houseworthe (GitHub), published October–November 2025. Part of the "House suite" of productivity tools for Claude Code. The repo explicitly references multiple highly-upvoted GitHub issues on the Anthropic/claude-code tracker (#6638, #5722, #7068, #7936) about the lack of official MCP management, positioning house-mcp-manager as a community solution to a known platform gap.

Philosophy

The README frames the problem starkly:

"AI coding agents load ALL configured MCP servers on startup, consuming massive amounts of your context window before you even start coding. Some servers like Canvas can consume 78,000+ tokens — that's nearly 40% of your 200K context budget!"

The solution philosophy is "surgical control over what's loaded" rather than any kind of workflow enforcement. The tool is explicitly neutral about what you do with the freed context — it just frees it.

Real-World Impact Numbers (from README)

Before:
  Total Active Token Usage: ~127,000 tokens
  Context Available: 73,000 tokens (36% of budget)

After disabling unused servers:
  Total Active Token Usage: ~14,000 tokens
  Context Available: 186,000 tokens (93% of budget)

That's 113,000 tokens saved

Known Token Costs (community-reported values)

Scope

A standalone TypeScript CLI with 139 automated tests. Not a skill pack or methodology — purely a configuration management utility.

House MCP Manager — Architecture

Distribution

cli-tool — TypeScript compiled to a Node.js binary, linked globally via npm link.

Install

git clone https://github.com/houseworthe/house-mcp-manager.git
cd house-mcp-manager
npm install
npm run build
npm link

npm install -g house-mcp-manager is listed as "Coming Soon."

Directory Tree (source)

house-mcp-manager/
├── src/
│   ├── cli.ts              # CLI entry point (cobra-style command dispatch)
│   ├── config.ts           # Config file path resolution per tool
│   ├── adapters/           # Per-IDE adapters (claude, cursor, cline)
│   ├── commands/           # Command implementations
│   │   ├── detect.ts
│   │   ├── disable.ts
│   │   ├── enable.ts
│   │   ├── interactive.ts
│   │   ├── list.ts
│   │   ├── profile.ts
│   │   └── status.ts
│   └── utils/              # Token estimation, backup, validation
├── tests/                  # 139 tests (vitest), 130 passing
├── package.json
└── tsconfig.json

Adapter Pattern

Each supported IDE has its own adapter implementing a common interface:

Safety: All adapters make automatic backups before any modification. JSON validation after every change.

Project-Level Config (Claude Code)

{
  "mcpServers": { /* user-level servers */ },
  "projects": {
    "/path/to/project": {
      "mcpServers": { /* project-specific servers */ },
      "disabledMcpServers": ["canvas"]
    }
  }
}

Target AI Tools

Claude Code, Cursor, Cline (VS Code extension). Continue and Zed listed as "Coming Soon."

Required Runtime

Node.js >= latest LTS (TypeScript compiled)

House MCP Manager — Components

CLI Commands (10)

Flags

Skills (0)

None.

Hooks (0)

None.

MCP Servers (0)

None. This tool manages MCP servers but is not itself an MCP server.

Scripts (0)

None (beyond the main binary).

Templates (0)

None.

Token Estimation Logic

Uses two strategies:

1. Known servers: Hardcoded community-reported values (canvas=78k, notion=35k, github=15k, puppeteer=8k)
2. Heuristics: Smart guessing based on server type when unknown

Estimates displayed in status command output with visual indicators (⚠️ for high, ✓ for low).

Interactive TUI

The interactive command launches a checkbox-style terminal UI:

• ↑/↓ to navigate
• Space to toggle
• Enter to confirm

Built with Node.js; specific TUI library not identified in surface README (likely inquirer or similar).

House MCP Manager — Uniqueness

differs_from_seeds

None of the 11 seeds address MCP server management at the configuration level. The closest seed is claude-flow (which bundles an MCP server with 305 tools) — but claude-flow creates MCP tool consumption, while house-mcp-manager controls it. agent-os is the closest in philosophy (managing what's loaded at session start via CLAUDE.md templates), but agent-os operates through instruction documents while house-mcp-manager operates by mutating JSON config files. This tool occupies a unique category: MCP configuration management utility.

Positioning

Part of a three-tool "House suite" (house-code + house-agents + house-mcp-manager). While the other two House tools are not yet analyzed, house-mcp-manager addresses a platform gap that Anthropic has not officially filled (multiple open GitHub issues cited).

Distinctive Opinion

The README makes a strong claim with data: "Some servers like Canvas can consume 78,000+ tokens — that's nearly 40% of your 200K context budget." This is the only framework in the batch that quantifies its value proposition in tokens rather than developer experience.

Observable Failure Modes

1. Token estimates are approximate: Based on community reports and heuristics; actual consumption varies with server version
2. No official npm publish: npm link is not suitable for team use; each developer must clone and link separately
3. Config file drift: If a user edits ~/.claude.json manually while house-mcp-manager is active, the tool's state may become inconsistent
4. Test coverage gap: 130/139 tests pass (93.5%); 9 failing tests unknown in scope
5. IDE version coupling: Adapter implementations are tied to specific config file formats; IDE updates may break the adapters

What Makes It Novel vs. the 11 Seeds

• Only framework in the entire corpus specifically addressing MCP context consumption
• Only CLI tool (not skill/command/hook) designed to manage which AI tools are loaded at startup
• Only framework with cross-IDE portability as a primary design goal (Claude Code + Cursor + Cline)
• Only framework with documented token cost estimates per server