Skip to main content
Glama
Universal Infinite Loop MCP Server

Universal Infinite Loop MCP Server

by gptcompany

Universal Infinite Loop MCP Server

A goal-agnostic parallel orchestration framework implementing Disler's Infinite Agentic Loop patterns as a Model Context Protocol (MCP) server. This system enables sophisticated multi-agent coordination for any domain through specification-driven architecture.

๐ŸŽฏ Core Features

Universal Goal Support

  • UI Components: React, Vue, Angular, Web Components

  • Documentation: Technical docs, API references, tutorials, guides

  • Code Generation: Functions, classes, modules, entire applications

  • Research & Analysis: Data analysis, reports, investigations

  • Content Creation: Articles, marketing copy, social media, blogs

  • Design Systems: Component libraries, style guides, design tokens

Sophisticated Orchestration

  • Wave-Based Generation: Parallel agent coordination with progressive sophistication

  • Context Management: Intelligent context usage monitoring and graceful degradation

  • Innovation Dimensions: Multi-dimensional creative exploration and uniqueness enforcement

  • Quality Assurance: Domain-specific validation and quality scoring

  • Failure Handling: Graceful error recovery and agent reassignment

Specification-Driven Architecture

  • Flexible Specifications: Adapt to any domain through comprehensive specification system

  • Progressive Sophistication: Multiple sophistication levels from basic to revolutionary

  • Evolution Patterns: Linear, exponential, adaptive, and creative burst generation patterns

  • Validation Rules: Customizable validation for syntax, semantics, functionality, and quality

Related MCP server: Bernstein - Multi-agent orchestration

๐Ÿš€ Quick Start

Installation

# Clone and install
git clone <repository-url>
cd infinite-loop-mcp-server
npm install

# Build
npm run build

# Run in development
npm run dev

MCP Configuration

Add to your MCP client configuration:

{
  "mcpServers": {
    "infinite-loop": {
      "command": "node",
      "args": ["/path/to/infinite-loop-mcp-server/dist/server.js"]
    }
  }
}

๐Ÿ› ๏ธ MCP Tools

infinite_orchestrate

Main orchestration tool for goal-agnostic parallel generation.

{
  specification: UniversalSpecification,
  outputDirectory: string,
  mode: {
    type: 'SINGLE' | 'BATCH' | 'INFINITE',
    count: number | 'INFINITE',
    batchSize?: number,
    maxWaves?: number
  },
  config?: {
    contextThreshold?: number,
    gracefulShutdown?: boolean,
    progressiveSophistication?: boolean
  }
}

Example - UI Component Generation:

{
  "specification": {
    "name": "React Search Components",
    "description": "Modern search interface components with various interaction patterns",
    "domain": {
      "category": "UI",
      "subcategory": "React Components",
      "targetAudience": "Frontend Developers",
      "complexity": "MODERATE"
    },
    "outputRequirements": {
      "format": "tsx",
      "structure": "Single component file with TypeScript",
      "namingPattern": "SearchComponent_{number}.tsx",
      "qualityStandards": ["TypeScript compliant", "Accessible", "Responsive"]
    },
    "innovationDimensions": ["interaction_patterns", "visual_design", "accessibility", "performance"],
    "sophisticationLevels": [...],
    "evolutionPattern": "CREATIVE_BURST"
  },
  "outputDirectory": "./generated-components",
  "mode": {
    "type": "BATCH",
    "count": 10,
    "batchSize": 5
  }
}

Example - Documentation Generation:

{
  "specification": {
    "name": "API Documentation",
    "description": "Comprehensive API documentation with examples and best practices",
    "domain": {
      "category": "DOCUMENTATION",
      "subcategory": "API Reference",
      "targetAudience": "Developers",
      "complexity": "COMPLEX"
    },
    "outputRequirements": {
      "format": "md",
      "structure": "Structured markdown with code examples",
      "namingPattern": "api_docs_{number}.md",
      "qualityStandards": ["Complete coverage", "Clear examples", "Best practices"]
    },
    "innovationDimensions": ["clarity", "completeness", "interactivity", "searchability"],
    "evolutionPattern": "LINEAR"
  },
  "outputDirectory": "./docs",
  "mode": {
    "type": "INFINITE",
    "count": "INFINITE"
  }
}

wave_plan

Plan generation waves with sophisticated agent assignment.

{
  existingWork: IterationInfo[],
  sophisticationLevel: SophisticationLevel,
  targetCount: number,
  contextBudget: number
}

agent_coordinate

Coordinate parallel agent execution with uniqueness enforcement.

{
  assignments: AgentAssignment[],
  innovationDimensions: string[],
  contextMonitor: ContextMonitor
}

context_monitor

Monitor context capacity and manage graceful shutdown.

{
  waveId: string,
  capacityThreshold: number,
  gracefulShutdown: boolean
}

spec_validate

Validate and enhance specifications with intelligent defaults.

{
  userSpec: Partial<UniversalSpecification>,
  domain: SpecificationDomain,
  outputRequirements: any
}

๐Ÿ“‹ Specification System

Universal Specification Structure

interface UniversalSpecification {
  id: string;
  name: string;
  description: string;
  domain: SpecificationDomain;
  version: string;
  
  outputRequirements: {
    format: string;
    structure: string;
    namingPattern: string;
    qualityStandards: string[];
  };
  
  innovationDimensions: string[];
  sophisticationLevels: SophisticationLevel[];
  constraints: string[];
  evolutionPattern: 'LINEAR' | 'EXPONENTIAL' | 'ADAPTIVE' | 'CREATIVE_BURST';
  progressionStrategy: string;
  successCriteria: string[];
  validationRules: ValidationRule[];
}

Domain Categories

  • UI: Frontend components, interfaces, user experiences

  • DOCUMENTATION: Technical writing, API docs, tutorials

  • CODE: Functions, classes, modules, applications

  • RESEARCH: Data analysis, investigations, reports

  • CONTENT: Articles, marketing, social media

  • ANALYSIS: Business analysis, performance reports

  • DESIGN: Visual design, component libraries

  • OTHER: Custom domains

Sophistication Levels

  1. Basic: Fundamental functionality with core features

  2. Intermediate: Enhanced features with improved user experience

  3. Advanced: Sophisticated implementation with innovative approaches

  4. Revolutionary: Cutting-edge concepts pushing domain boundaries

๐ŸŒŠ Wave-Based Generation

Generation Modes

  • SINGLE: Generate one iteration

  • BATCH: Generate specific number of iterations in coordinated batches

  • INFINITE: Continuous generation until context limits with progressive sophistication

Wave Coordination

  • Parallel Execution: Multiple agents working simultaneously with unique assignments

  • Innovation Assignment: Each agent gets distinct innovation dimension to explore

  • Context Management: Intelligent context usage tracking and optimization

  • Quality Assurance: Real-time validation and quality scoring

  • Uniqueness Enforcement: Prevention of duplicate concepts across parallel streams

Progressive Sophistication

Wave 1: Basic functional implementations
Wave 2: Enhanced features and user experience  
Wave 3: Advanced concepts and innovative approaches
Wave N: Revolutionary paradigm-defining implementations

๐Ÿ”ง Integration Examples

With Shrimp Task Manager

// Detect when parallel generation is needed
if (taskRequiresParallelGeneration(task)) {
  const specification = generateSpecificationFromTask(task);
  
  const result = await mcpClient.callTool('infinite_orchestrate', {
    specification,
    outputDirectory: task.outputDirectory,
    mode: {
      type: 'BATCH',
      count: task.iterationCount,
      batchSize: 5
    }
  });
  
  return integrateResultsIntoTask(result, task);
}

Custom Domain Integration

// Define custom domain specification
const customSpec: UniversalSpecification = {
  name: "Custom Data Analysis",
  domain: {
    category: "ANALYSIS",
    subcategory: "Financial Reports", 
    targetAudience: "Business Analysts",
    complexity: "COMPLEX"
  },
  innovationDimensions: [
    "visualization_techniques",
    "data_insights", 
    "predictive_modeling",
    "business_impact"
  ],
  // ... rest of specification
};

๐Ÿ“Š Monitoring & Analytics

Context Monitoring

  • Real-time context usage tracking

  • Graceful shutdown when approaching limits

  • Wave-based context optimization

  • Agent-specific context allocation

Quality Metrics

  • Functionality compliance scoring

  • Innovation uniqueness measurement

  • Domain-specific quality validation

  • Progressive improvement tracking

Performance Analytics

  • Agent coordination efficiency

  • Wave execution timing

  • Resource utilization optimization

  • Failure rate and recovery metrics

๐ŸŽฏ Use Cases

UI/UX Development

  • Generate diverse component variations

  • Explore different interaction patterns

  • Create comprehensive design systems

  • Test accessibility approaches

Documentation Projects

  • Create multi-perspective documentation

  • Generate comprehensive examples

  • Explore different explanation styles

  • Develop interactive documentation

Code Development

  • Generate alternative implementations

  • Explore architectural patterns

  • Create comprehensive test suites

  • Develop optimization variations

Research & Analysis

  • Explore multiple analysis angles

  • Generate diverse visualization approaches

  • Create comprehensive reports

  • Investigate different methodologies

๐Ÿ›ฃ๏ธ Roadmap

Phase 1: Core Implementation โœ…

  • Universal specification system

  • Wave-based generation framework

  • Agent coordination system

  • Context management

Phase 2: Advanced Features

  • Machine learning-based quality prediction

  • Dynamic specification evolution

  • Cross-domain knowledge transfer

  • Performance optimization

Phase 3: Ecosystem Integration

  • IDE extensions and plugins

  • Cloud deployment options

  • Collaboration features

  • Marketplace for specifications

๐Ÿค Contributing

Contributions are welcome! Please read our contributing guidelines and submit pull requests for any improvements.

๐Ÿ“„ License

MIT License - see LICENSE file for details.

๐Ÿ™ Acknowledgments

Based on Disler's Infinite Agentic Loop concept with universal goal-agnostic adaptations for maximum reusability and flexibility.

Available Tools

5 tools
agent_coordinateC

Coordinate parallel agent execution with sophisticated assignment

Inputs: assignments (required), innovationDimensions (required), contextMonitor (required).

context_monitorC

Monitor context capacity and manage graceful shutdown

Inputs: waveId (required), capacityThreshold (required), gracefulShutdown (required).

infinite_orchestrateC

Orchestrate infinite agentic loop generation with universal specifications

Inputs: specification (required), outputDirectory (required), mode (required), config.

spec_validateC

Validate and enhance user specifications for goal-agnostic generation

Inputs: userSpec (required), domain (required), outputRequirements (required).

wave_planB

Plan a generation wave based on existing work and sophistication level

Inputs: existingWork (required), sophisticationLevel (required), targetCount (required), contextBudget (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    TDQS

    B3.1/5.0

    Scored across 5 tools

    Disambiguation4/5

    Each tool targets a distinct aspect of agentic loop orchestration (coordination, monitoring, orchestration, validation, planning) with clear boundaries, though 'infinite_orchestrate' and 'wave_plan' could be mildly confused as both involve generation planning. Descriptions help differentiate them effectively.

    Naming Consistency4/5

    Tools follow a consistent snake_case pattern with descriptive compound names (e.g., agent_coordinate, context_monitor). While all use noun-based structures, there is minor deviation with 'spec_validate' using a verb-noun combination, but overall naming is highly readable and predictable.

    Tool Count5/5

    With 5 tools, this server is well-scoped for its purpose of infinite loop orchestration. Each tool appears to serve a specific, necessary function without redundancy, fitting the typical 3-15 range for a focused domain.

    Completeness4/5

    The toolset covers core lifecycle aspects of agentic loops: planning, validation, orchestration, coordination, and monitoring. A minor gap exists in direct execution or termination tools, but agents can likely work around this with the provided monitoring and orchestration capabilities.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers