Maker Rs

MAKER Framework

Zero-Error Long-Horizon LLM Execution via SPRT Voting, Red-Flagging, and Microagent Orchestration

[](https://github.com/zircote/maker-rs/actions) [](https://opensource.org/licenses/MIT) [](https://www.rust-lang.org/) [](https://modelcontextprotocol.io/) [](https://arxiv.org/abs/2511.09030)

> ## ⚠️ EXPERIMENTAL - NOT FOR PRODUCTION USE > > This is a research experiment, not production software. > > - Purpose: Validate and explore claims from the research paper Solving a Million-Step LLM Task with Zero Errors (Meyerson et al., 2025) > - Goals: Implement the MAKER algorithm, discover alternative approaches, test boundaries of zero-error LLM execution > - Status: Active research - may never reach production readiness > - Use at your own risk: APIs will change, results are experimental, not suitable for critical applications

MAKER (Massively decomposed Agentic processes with K-margin Error Reduction) is a Rust implementation exploring mathematically-grounded error correction in LLM agents. It tests zero-error execution through SPRT-based voting, red-flag validation, and m=1 microagent decomposition.

Based on: Solving a Million-Step LLM Task with Zero Errors (Meyerson et al., 2025)

The Problem

Even with 99% per-step accuracy, a 1,000-step task has only a 0.004% success rate. The MAKER algorithm aims to transform this into 95%+ reliability with logarithmic cost scaling.

This implementation explores whether that claim holds in practice.

| Task Length | Naive Success Rate | MAKER Success Rate | MAKER Cost Scaling | |------------|-------------------|-------------------|-------------------| | 7 steps | 93% | 99%+ | 21 samples | | 1,023 steps| 0% | 95%+ | ~6,138 samples | | 1M steps | 0% | 95%+ | Θ(s ln s) |

Quick Start

As a Rust Library

use maker::core::{calculate_kmin, MockLlmClient, VoteConfig, vote_with_margin};

// Calculate required k-margin for your task
let k = calculate_kmin(
    0.85,   // p: per-step success probability
    0.95,   // t: target task reliability
    1_023,  // s: total steps (10-disk Hanoi)
    1,      // m: steps per agent (must be 1)
).unwrap();

// Run error-corrected voting
let client = MockLlmClient::constant("correct_answer");
let config = VoteConfig::default();
let result = vote_with_margin("What is 2+2?", k, &client, config).unwrap();
println!("Winner: {} ({} samples)", result.winner, result.total_samples);

As an MCP Server

# Build and run
cargo build --release
cargo run --bin maker-mcp

Add to your Claude Code MCP configuration:

{
  "mcpServers": {
    "maker": {
      "command": "/path/to/maker-mcp",
      "args": [],
      "env": {
        "OPENAI_API_KEY": "your-key",
        "ANTHROPIC_API_KEY": "your-key"
      }
    }
  }
}

Run the Demos

See [Validation Demos](#validation-demos) below for detailed documentation and results.

Validation Demos

These demos validate MAKER's error correction capabilities against different task types.

Hanoi Demo (examples/hanoi_demo.rs)

Purpose: Validates MAKER on multi-step reasoning tasks requiring algorithmic thinking.

# 3-disk Hanoi (7 steps) with OpenAI
cargo run --example hanoi_demo -- --disks 3 --provider openai

# 5-disk Hanoi (31 steps) with strict mode (halt on first error)
cargo run --example hanoi_demo -- --disks 5 --provider openai --strict

# With ensemble (multiple providers)
cargo run --example hanoi_demo -- --disks 3 --provider openai --ensemble

# Mock mode for CI/testing
MAKER_USE_MOCK=1 cargo run --example hanoi_demo -- --disks 10 --accuracy 0.85

Key flags: | Flag | Description | |------|-------------| | --disks N | Number of disks (1-20) | | --provider | LLM provider: ollama, openai, anthropic | | --model | Model name override | | --strict | Halt on first error (true zero-error mode) | | --ensemble | Enable multi-provider ensemble |

Results (gpt-5-mini):

• 31/31 steps (5-disk) with 0 errors using few-shot + chain-of-thought prompt
• ~2.7 samples per step average
• p_hat converges to 0.950 (target reliability)

Key Finding: Raw prompts fail on step 2 (systematic reasoning errors). Few-shot examples + chain-of-thought prompting converts systematic errors into random errors that voting can correct.

Arithmetic Demo (examples/arithmetic_demo.rs)

Purpose: Validates MAKER on tasks with truly random errors (calculation mistakes).

# 20 problems with OpenAI
cargo run --example arithmetic_demo -- --problems 20 --provider openai

# 50 problems with higher difficulty
cargo run --example arithmetic_demo -- --problems 50 --provider openai --difficulty 3

# Strict mode with reproducible seed
cargo run --example arithmetic_demo -- --problems 50 --provider openai --strict --seed 42

# Mock mode for CI/testing
MAKER_USE_MOCK=1 cargo run --example arithmetic_demo -- --problems 100 --accuracy 0.90

Key flags: | Flag | Description | |------|-------------| | --problems N | Number of problems to solve | | --difficulty 1-5 | Number magnitude (10^difficulty) | | --provider | LLM provider | | --strict | Halt on first error | | --seed N | Reproducible problem generation |

Results (gpt-5-mini):

• 50/50 problems correct with 0 errors
• 2.7 samples per problem average
• Handles addition, subtraction, multiplication

Key Finding: Random calculation errors are effectively corrected by voting. This validates MAKER's core premise - voting corrects random errors.

---

Research Findings

Our validation experiments reveal important insights about MAKER's applicability:

What MAKER Can Correct

| Error Type | Example | Correctable? | Why | |------------|---------|--------------|-----| | Random errors | LLM occasionally miscalculates 73-38 | ✅ Yes | Independent errors cancel out through voting | | Prompted reasoning | Hanoi with few-shot examples | ✅ Yes | Converts systematic to random errors |

What MAKER Cannot Correct

| Error Type | Example | Correctable? | Why | |------------|---------|--------------|-----| | Systematic errors | LLM can't reason about Hanoi | ❌ No | All samples fail the same way | | Knowledge gaps | LLM doesn't know an algorithm | ❌ No | Voting achieves consensus on wrong answer |

Key Insight

> MAKER corrects random errors, not systematic reasoning failures. > > If an LLM consistently fails at a task, voting will achieve consensus on the wrong answer. Prompt engineering (few-shot examples, chain-of-thought) is critical to convert systematic failures into random errors that voting can correct.

Observed Accuracy

| Task | Model | Per-Step Accuracy | Samples/Step | |------|-------|-------------------|--------------| | Arithmetic (difficulty 3) | gpt-5-mini | ~95% | 2.7 | | Hanoi (few-shot+CoT) | gpt-5-mini | ~95% | 2.7 | | Hanoi (raw prompt) | gpt-5-mini | Meyerson, E., Qiu, X., & Lehman, J. (2025). Solving a Million-Step LLM Task with Zero Errors. arXiv:2511.09030

References

1. Meyerson, E., et al. (2025). Solving a Million-Step LLM Task with Zero Errors. arXiv:2511.09030
2. Anthropic. (2024). Introducing the Model Context Protocol. anthropic.com
3. Wald, A. (1945). Sequential Analysis. (SPRT foundational work)

License

MIT - see [LICENSE](./LICENSE)

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: zircote
• Source: zircote/maker-rs
• License: MIT

Install and usage instructions live in the source repository linked above.