# Maker Rs

> Zero-error LLM execution via SPRT voting. Rust library and MCP server implementing the MAKER algorithm for mathematically-grounded error correction in long-horizon AI agent tasks. Research experiment based on arXiv:2511.09030

- **Type:** MCP server
- **Install:** `agentstack add mcp-zircote-maker-rs`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [zircote](https://agentstack.voostack.com/s/zircote)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [zircote](https://github.com/zircote)
- **Source:** https://github.com/zircote/maker-rs

## Install

```sh
agentstack add mcp-zircote-maker-rs
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# 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](https://arxiv.org/abs/2511.09030) (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](https://arxiv.org/abs/2511.09030) (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

```rust
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

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

Add to your Claude Code MCP configuration:

```json
{
  "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.

```bash
# 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).

```bash
# 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](https://arxiv.org/abs/2511.09030)

## References

1. Meyerson, E., et al. (2025). *Solving a Million-Step LLM Task with Zero Errors*. [arXiv:2511.09030](https://arxiv.org/abs/2511.09030)
2. Anthropic. (2024). *Introducing the Model Context Protocol*. [anthropic.com](https://www.anthropic.com/news/model-context-protocol)
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](https://github.com/zircote)
- **Source:** [zircote/maker-rs](https://github.com/zircote/maker-rs)
- **License:** MIT

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

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-zircote-maker-rs
- Seller: https://agentstack.voostack.com/s/zircote
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.