Waldzell Metagames Server

Waldzell Metagames MCP Server

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

Overview

The Waldzell Metagames server exposes 27+ structured problem-solving frameworks organized into 6 main categories, each designed to transform 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

Configuration

Add to your MCP client configuration:

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

For Claude Desktop, add 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 preventing 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 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 Theory of Constraints
- shadow-price-showdown: Constraint valuation using dual analysis
Multi-Objective
- pareto-pursuit: Surface trade-offs along 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 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

List All Metagames

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

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

Filter Metagames

// 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' 
});

Get 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:

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

Development

Adding New Metagames

Create markdown file in appropriate category folder
Add metadata to subcategory's metadata.json
Follow the metagame template structure
Validate against schema: npm run validate

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

Fork the repository
Create feature branch (git checkout -b feature/new-metagame)
Add metagame following template structure
Update metadata.json with metagame details
Submit pull request with 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 ship results while avoiding common failure modes.

License

MIT License - See 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

This server cannot be installed

security - not tested

license - permissive license

quality - not tested

How are these scores calculated?

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Provides access to 27+ structured problem-solving frameworks and game-theoretic workflows for software development, project management, and operations research. Helps prevent analysis paralysis and scope creep by transforming open-ended challenges into systematic, time-boxed approaches with clear decision gates.

Related MCP Servers

Sequential Thinking MCP Server
arben-adm
A
security
A
license
A
quality
This server facilitates structured problem-solving by breaking down complex issues into sequential steps, supporting revisions, and enabling multiple solution paths through full MCP integration.
Last updated -
659
MIT License
Sequential Thinking MCP Server
zalab-inc
A
security
F
license
A
quality
Provides a tool for dynamic and reflective problem-solving by breaking complex problems into manageable steps with support for revision, branching, and hypothesis generation.
Last updated -
1
97,637
3
Project Explorer MCP Server
MausRundung362
A
security
A
license
A
quality
Provides tools for analyzing project structures, searching through codebases, managing dependencies, and performing file operations with advanced filtering capabilities.
Last updated -
6
160
1
MIT License
Clear Thought Server
ThinkFar
A
security
F
license
A
quality
Provide systematic thinking, mental models, and debugging approaches to enhance problem-solving capabilities. Enable structured reasoning and decision-making support for complex problems. Facilitate integration with MCP-compatible clients for advanced cognitive workflows.
Last updated -
11
1

View all related MCP servers