Waldzell Metagames Server

🚀 Waldzell Metagames MCP Server

A Model Context Protocol (MCP) server offering access to a comprehensive library of game - theoretic workflows and problem - solving frameworks. These metagames prevent common pitfalls such as analysis paralysis, perfectionism spirals, and scope creep, and provide systematic approaches to software development, project management, and operations research challenges.

🚀 Quick Start

The Waldzell Metagames server provides over 27 structured problem - solving frameworks grouped into 6 main categories. Each framework is designed to convert open - ended challenges into systematic, time - boxed workflows with clear decision gates and termination conditions.

📦 Installation

# Clone the repository
git clone https://github.com/yourusername/waldzell-metagames-server.git
cd waldzell-metagames-server

# Install dependencies
npm install

# Build the server
npm run build

📚 Documentation

Configuration

Add the following to your MCP client configuration:

{
  "mcpServers": {
    "waldzell-metagames": {
      "command": "node",
      "args": ["/path/to/waldzell-metagames-server/dist/index.js"]
    }
  }
}

For Claude Desktop, add it to ~/Library/Application Support/Claude/claude_desktop_config.json.

Metagame Categories

1. Software Development

Focus: Code quality, testing, documentation, and architecture

• Code Quality

  • code-review-game: Game - theoretic code review to prevent bikeshedding
  • refactoring-game: Systematic refactoring without perfectionism spirals

• Debugging & Testing

  • debugging-hypothesis-to-spec-game: Convert bugs into ranked hypotheses
  • sandbox-testing-mechanism: Test code in isolated E2B sandboxes

• Documentation

  • docs-improvement-game: Discover API gaps and ship production docs
  • docs-verification-game: Ensure docs match implementation reality

• Architecture

  • complexity-navigator: Break down and manage system complexity

2. Product Development

Focus: Feature ideation, implementation, and innovation

• Ideation

  • feature-discovery: Generate diverse implementations avoiding the first - idea trap
  • idea-to-specs-protocol: Transform ideas into curated specifications

• Implementation

  • feature-implementation-game: Ship capabilities with OR - inspired risk minimization

• Innovation

  • virgil-protocol: Deliberate innovation using Virgil Abloh's 3% Rule

3. Project Management

Focus: Planning, resource allocation, and execution

• Planning

  • critical-path-quest: Uncover tasks controlling delivery time
  • stage-gate-sentinel: Phased delivery with Stage - Gate/DMAIC principles

• Resource Allocation

  • knapsack-sprint: Rapid allocation using knapsack optimization
  • queue-triage: Balance wait times and service utilization

• Execution

  • ooda-loop-sprint: Rapid iteration combining OODA, PDCA, and Lean Startup

4. Operations Research

Focus: Optimization, constraints, and uncertainty

• Constraint Analysis

  • bottleneck-blitz: Throughput optimization via the Theory of Constraints
  • shadow-price-showdown: Constraint valuation using dual analysis

• Multi - Objective

  • pareto-pursuit: Surface trade - offs along the Pareto frontier

• Risk & Uncertainty

  • monte-carlo-mandate: Compare strategies via stochastic simulation
  • sensitivity-sweep: Stress - test plan assumptions

5. MCP Ecosystem

Focus: MCP server development and quality assurance

• Server Development

  • mcp-server-implementation-game: Implement and validate MCP servers end - to - end

• Quality Assurance

  • mcp-dogfood: Execute a full dogfooding pass against MCP servers

6. Meta - Learning & Frameworks

Focus: Learning systems and knowledge extraction

• Learning Systems

  • learning-accelerator: Optimize how command systems learn over time

• Knowledge Extraction

  • wisdom-distillation: Extract strategic principles from tactical implementations

• Protocols

  • ulysses-protocol: High - stakes debugging preventing endless iteration

• Templates

  • metagame-template: Standard structure for creating new metagames

API Usage

Basic Usage

// List all available metagames
await mcp.call('listMetagames', {});

// List as hierarchical tree
await mcp.call('listMetagames', { format: 'tree' });

Filtering

// Filter by category
await mcp.call('listMetagames', { 
  category: 'software-development' 
});

// Filter by complexity
await mcp.call('listMetagames', { 
  complexity: 'intermediate' 
});

// Filter by subcategory
await mcp.call('listMetagames', { 
  category: 'project-management',
  subcategory: 'planning' 
});

Getting Specific Metagame

// Get metagame content
await mcp.call('getMetagame', { 
  name: 'refactoring-game' 
});

// Get with metadata
await mcp.call('getMetagame', { 
  name: 'refactoring-game',
  includeMetadata: true 
});

Access via Resources

// List all metagame resources
const resources = await mcp.listResources();

// Read specific metagame resource
const content = await mcp.readResource('metagame://refactoring-game');

Example Usage in Claude

# Basic usage
Use the refactoring game to improve the src/ directory

# With parameters
Run the code review game on the latest PR with strict time boxing

# Discovery
What metagames can help with technical debt?

# Specific complexity
Show me beginner - level project management metagames

Metagame Structure

Each metagame follows a consistent structure:

1. Problem Statement: What challenge it addresses
2. Phases: Time - boxed stages with clear objectives
3. Decision Gates: Explicit points for go/no - go decisions
4. Termination Conditions: When to stop (preventing spirals)
5. Success Metrics: How to measure effectiveness
6. Anti - Patterns: Common pitfalls to avoid

Development

Directory Structure

src/resources/metagames/
├── categories.json              # Category definitions
├── metagame-schema.json        # Validation schema
├── 01-software-development/
│   ├── code-quality/
│   │   ├── *.md               # Metagame files
│   │   └── metadata.json      # Subcategory metadata
│   └── ...
└── ...

Building and Testing

# Build the server
npm run build

# Run tests
npm test

# Validate metagame schemas
npm run validate

# Development mode
npm run dev

👥 Contributing

1. Fork the repository
2. Create a feature branch (git checkout -b feature/new-metagame)
3. Add a metagame following the template structure
4. Update metadata.json with metagame details
5. Submit a pull request with a description of the problem it solves

💡 Philosophy

These metagames embody principles from:

• Game Theory: Nash equilibria, mechanism design, auction theory
• Operations Research: Linear programming, queueing theory, optimization
• Software Engineering: Agile, DevOps, test - driven development
• Systems Thinking: Feedback loops, constraints, emergence

The goal is to transform unbounded problems into systematic workflows that deliver results while avoiding common failure modes.

📄 License

MIT License - See the LICENSE file for details

🙏 Acknowledgments

Named after the Glass Bead Game's Waldzell, where formal games explore infinite possibility spaces within structured constraints.

🛠️ Support

• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Documentation: Wiki