MDAP — Multi-Dimensional Adaptive Planning

This module was previously the standalone brainwires-mdap crate. It now lives in brainwires-agent behind the mdap feature flag.

MAKER voting framework — microagents, decomposition, red flags, and scaling for the Brainwires Agent Framework.

Paper

This crate is a Rust implementation of MAKER (Multi-Agent K-consensus Error correction) as described in:

Solving a Million-Step LLM Task with Zero Errors Elliot Meyerson, Giuseppe Paolo, Roberto Dailey, Hormoz Shahrzad, Olivier Francon, Conor F. Hayes, Xin Qiu, Babak Hodjat, Risto Miikkulainen arXiv:2511.09030, November 2025 https://arxiv.org/abs/2511.09030

The paper introduces Massively Decomposed Agentic Processes (MDAPs) — a scaling approach that decomposes tasks into minimal subtasks handled by focused microagents, with multi-agent voting for error correction at every step. MAKER achieves zero-error execution on million-step tasks through extreme decomposition, first-to-ahead-by-k voting, and red-flag output validation.

This implementation also integrates techniques from three supplementary papers:

• RASC (arXiv:2408.17017) — early stopping with variance tracking and loss-of-hope detection
• CISC (arXiv:2502.06233v1) — confidence-weighted voting with dynamic confidence extraction
• Ranked Voting (arXiv:2505.10772) — Borda count ranking as an alternative consensus method

Overview

This module provides a complete implementation of the MAKER framework organized around five core components that map directly to the paper's algorithms and equations:

• Voting (Algorithm 2) — first-to-ahead-by-k consensus with three voting methods, early stopping, and confidence weighting
• Microagents (MAD) — focused single-step agents (m=1) that execute one subtask with minimal context
• Red Flags (Algorithm 3) — output validation that catches self-correction, confused reasoning, truncation, and format violations
• Decomposition (Algorithm 4) — binary recursive task decomposition with AI-driven splitting and dependency resolution
• Scaling Laws (Equations 13–19) — cost and probability estimation for choosing optimal k given a budget or reliability target

Design principles:

• Paper-faithful — algorithms, equations, and heuristics follow the MAKER paper directly
• Composable — each component is independent; use voting without decomposition, red flags without microagents, etc.
• Provider-agnostic — generic over MicroagentProvider trait; works with any LLM backend
• Intent-based tool use — microagents express tool intent (deterministic) rather than executing tools (non-deterministic), preserving voting correctness
• Full observability — per-subtask metrics, voting round tracking, red-flag breakdowns, and cost analysis

  ┌──────────────────────────────────────────────────────────────────────┐
  │                    brainwires-agent::mdap                            │
  │                                                                      │
  │  Task ──► Decomposition (Alg.4) ──► Subtask DAG                      │
  │                                         │                            │
  │               ┌─────────────────────────┘                            │
  │               ▼                                                      │
  │  ┌─── Per Subtask ──────────────────────────────────────────────┐    │
  │  │                                                              │    │
  │  │  Microagent ──► Sample k responses ──► Red Flags (Alg.3)     │    │
  │  │  (m=1 steps)        │                      │                 │    │
  │  │                     ▼                      ▼                 │    │
  │  │              Valid responses ──► Voting (Alg.2)              │    │
  │  │                                      │                       │    │
  │  │              ┌───────────────────────┘                       │    │
  │  │              ▼                                               │    │
  │  │  Winner + VoteResult + SubtaskMetric                         │    │
  │  └──────────────────────────────────────────────────────────────┘    │
  │               │                                                      │
  │               ▼                                                      │
  │  Composer ──► Final result        Scaling (Eq.13-19) ──► Estimates   │
  │                                   Metrics ──► Cost/performance data  │
  └──────────────────────────────────────────────────────────────────────┘

Quick Start

Add to your Cargo.toml:

[dependencies]
brainwires-mdap = "0.11"

Run a simple voting consensus:

use brainwires_mdap::{
    FirstToAheadByKVoter, SampledResponse, ResponseMetadata,
    StandardRedFlagValidator, RedFlagValidator,
};

// Create a voter with k=3, max 20 samples
let voter = FirstToAheadByKVoter::new(3, 20);

// Red-flag validator
let validator = StandardRedFlagValidator::strict();

// Vote with a sampler function that queries an LLM
let result = voter.vote(
    || async {
        let response = call_my_llm("What is 2+2?").await?;
        Ok(SampledResponse::new(
            response.text.clone(),
            ResponseMetadata {
                token_count: response.tokens,
                response_time_ms: response.latency,
                format_valid: true,
                finish_reason: Some("stop".into()),
                model: Some("claude-sonnet".into()),
            },
            response.text,
        ))
    },
    &validator,
).await?;

println!("Winner: {} (votes: {}/{})", result.winner, result.winner_votes, result.total_votes);

Estimate cost before running:

use brainwires_mdap::{estimate_mdap, ModelCosts};

let estimate = estimate_mdap(
    10,                           // num_steps (subtasks)
    0.85,                         // per-step success probability
    0.99,                         // target overall success rate
    &ModelCosts::claude_sonnet(), // model pricing
    500,                          // avg input tokens per call
    200,                          // avg output tokens per call
)?;

println!("Recommended k={}, cost=${:.4}, P(success)={:.4}",
    estimate.recommended_k,
    estimate.expected_cost_usd,
    estimate.success_probability,
);

Architecture

Voting (Algorithm 2)

The core consensus mechanism. Multiple independent LLM samples are collected and the first answer to lead by k votes wins.

FirstToAheadByKVoter

Constructors:

Methods:

VoterBuilder — fluent builder: VoterBuilder::new().k(3).max_samples(20).voting_method(BordaCount).build()

VotingMethod

EarlyStoppingConfig

RASC-style early stopping (arXiv:2408.17017) to reduce unnecessary samples when consensus is already clear.

Presets: aggressive() (stop fast), conservative() (higher confidence required), disabled()

VoteResult<T>

SampledResponse<T>

Microagents (MAD)

Maximal Agentic Decomposition — each microagent executes exactly one subtask (m=1 step) with a focused system prompt that discourages hedging, self-correction, and unnecessary explanation.

Subtask

Constructors: atomic(id, description), new(id, description, input_state)

MicroagentConfig

MicroagentProvider trait

#[async_trait]
pub trait MicroagentProvider: Send + Sync {
    async fn chat(
        &self,
        system_prompt: &str,
        user_prompt: &str,
        max_tokens: usize,
        temperature: f32,
    ) -> MdapResult<MicroagentResponse>;

    fn available_tools(&self) -> Vec<ToolSchema> { vec![] }
    fn has_tools(&self) -> bool { false }
}

Microagent<P>

Confidence Extraction

extract_response_confidence(text, metadata) computes a 0.1–0.99 confidence score by analyzing:

• Finish reason (stop vs length)
• Response length relative to token limit
• Hedging language ("maybe", "perhaps", "I think")
• Self-correction patterns ("Wait,", "Actually,", "Let me reconsider")
• Confident assertions ("definitely", "clearly", "the answer is")
• Format validity

Red Flags (Algorithm 3)

Output validation that catches unreliable LLM responses before they enter voting.

RedFlagConfig

Presets: strict() (paper-recommended), relaxed() (fewer false positives)

Strict confusion patterns: "Wait,", "Actually,", "Let me reconsider", "I made a mistake", "On second thought", "Hmm,", "I think I", "Let me correct", "Sorry, I meant", "That's not right"

StandardRedFlagValidator

Implements Algorithm 3. Validation checks (in order):

1. Length — token count vs max, minimum length
2. Self-correction — confusion pattern regex matching
3. Format — expected output format matching
4. Truncation — finish reason analysis
5. Empty lines — empty line ratio

RedFlagResult

OutputFormat

Other Validators

• AcceptAllValidator — always returns Valid (useful for testing)
• CompositeValidator — chains multiple validators; first failure wins

Decomposition (Algorithm 4)

Breaks complex tasks into a DAG of minimal subtasks.

DecomposeContext

DecompositionStrategy

DecompositionResult

TaskDecomposer trait

#[async_trait]
pub trait TaskDecomposer: Send + Sync {
    async fn decompose(&self, task: &str, context: &DecomposeContext)
        -> MdapResult<DecompositionResult>;
    fn is_minimal(&self, task: &str) -> bool;
    fn strategy(&self) -> DecompositionStrategy;
}

BinaryRecursiveDecomposer<P>

AI-driven implementation of Algorithm 4. Uses the LLM with voting (k consensus) to decide how to split each task, recursing until subtasks are minimal.

Minimal task heuristics: very short (< 50 chars), single-action verbs (return, calculate, get, set, check, etc.), no multi-step conjunctions.

SequentialDecomposer

Non-AI decomposer that extracts numbered steps or splits by sentences. Useful for pre-structured tasks.

Utilities

• validate_decomposition(result) — checks non-empty, valid dependencies, no circular references
• topological_sort(subtasks) — Kahn's algorithm for dependency ordering

Composer

Combines subtask outputs into a final result.

CompositionFunction

Composer

CompositionBuilder

Fluent builder with input validation: CompositionBuilder::new(function).add_result(output).compose()

Tool Intent

Microagents express tool intent without executing — this keeps voting deterministic since tool execution has side effects.

ToolSchema

Converts from brainwires_core::Tool via From trait.

ToolIntent

ToolCategory

read_only_categories() returns categories safe for microagents. side_effect_categories() returns categories that modify state.

Intent Parsing

parse_tool_intent(response) extracts ToolIntent from LLM responses containing tool_intent JSON blocks. Returns IntentParseResult::NoIntent, WithIntent, or ParseError.

Scaling Laws (Equations 13–19)

Cost and probability estimation from the paper's mathematical framework.

estimate_mdap()

Main estimation function implementing Equations 13–19:

pub fn estimate_mdap(
    num_steps: usize,         // s: number of subtasks
    per_step_success: f64,    // p: per-step success probability (must be > 0.5)
    target_success: f64,      // target overall success rate (0, 1)
    model_costs: &ModelCosts, // pricing per 1K tokens
    avg_input_tokens: usize,  // average input tokens per call
    avg_output_tokens: usize, // average output tokens per call
) -> MdapResult<MdapEstimate>

Key Equations

ModelCosts

MdapEstimate

suggest_k_for_budget()

Budget-constrained k selection — finds the largest k affordable within a dollar budget.

Metrics

Full observability into MDAP execution.

MdapMetrics

Comprehensive metrics covering execution, steps, sampling, voting, cost, time, and success rate.

SubtaskMetric

Error Handling

MdapError is a comprehensive error enum with sub-error types for each component:

Helper methods: is_retryable(), is_user_error(), is_tool_error(), is_red_flag(), should_restart_voting()

Usage Examples

Voting with red-flag validation

use brainwires_mdap::prelude::*;

let voter = FirstToAheadByKVoter::new(3, 20);
let validator = StandardRedFlagValidator::strict();

let result = voter.vote(
    || async { sample_llm_response().await },
    &validator,
).await?;

println!("Winner: {}", result.winner);
println!("Confidence: {:.2}", result.confidence);
println!("Red-flagged: {}", result.red_flagged_count);

Voting with early stopping (RASC)

use brainwires_mdap::{FirstToAheadByKVoter, EarlyStoppingConfig};

let voter = FirstToAheadByKVoter::with_early_stopping(
    3,
    20,
    EarlyStoppingConfig::aggressive(),
);

let result = voter.vote(sampler, &validator).await?;
if result.early_stopped {
    println!("Stopped early at {} samples", result.total_samples);
}

Confidence-weighted voting (CISC)

use brainwires_mdap::FirstToAheadByKVoter;

let voter = FirstToAheadByKVoter::with_confidence_weighting(3, 20);

let result = voter.vote(sampler, &validator).await?;
println!("Weighted confidence: {:?}", result.weighted_confidence);

Builder pattern for voter configuration

use brainwires_mdap::{VoterBuilder, VotingMethod, EarlyStoppingConfig};

let voter = VoterBuilder::new()
    .k(5)
    .max_samples(30)
    .voting_method(VotingMethod::BordaCount)
    .early_stopping(EarlyStoppingConfig::conservative())
    .parallel_limit(4)
    .build()?;

Cost estimation before execution

use brainwires_mdap::{estimate_mdap, ModelCosts, suggest_k_for_budget};

// What k do I need for 99% success on 10 steps?
let estimate = estimate_mdap(10, 0.85, 0.99, &ModelCosts::claude_sonnet(), 500, 200)?;
println!("Need k={}, cost=${:.4}", estimate.recommended_k, estimate.expected_cost_usd);

// What k can I afford with $0.50?
let k = suggest_k_for_budget(10, 0.85, &ModelCosts::claude_haiku(), 500, 200, 0.50)?;
println!("Budget allows k={}", k);

Task decomposition

use brainwires_mdap::{
    decomposition::{BinaryRecursiveDecomposer, DecomposeContext, validate_decomposition, topological_sort},
};

let decomposer = BinaryRecursiveDecomposer::new(provider, 4, 3, 15);
let context = DecomposeContext::new().with_max_depth(4);

let result = decomposer.decompose("Implement an LRU cache with get/put", &context).await?;
validate_decomposition(&result)?;

let ordered = topological_sort(&result.subtasks)?;
for subtask in &ordered {
    println!("{}: {}", subtask.id, subtask.description);
}

Composing subtask results

use brainwires_mdap::{Composer, CompositionFunction, SubtaskOutput};

let composer = Composer::new();

let outputs = vec![
    SubtaskOutput::new("step-1", serde_json::json!("struct definition")),
    SubtaskOutput::new("step-2", serde_json::json!("impl block")),
    SubtaskOutput::new("step-3", serde_json::json!("tests")),
];

let final_result = composer.compose(&CompositionFunction::Concatenate, &outputs)?;

Tracking metrics

use brainwires_mdap::{MdapMetrics, SubtaskMetric, ConfigSummary};

let mut metrics = MdapMetrics::new("exec-001".into());
metrics.start();

metrics.record_subtask(SubtaskMetric {
    subtask_id: "step-1".into(),
    description: "Parse input".into(),
    samples_needed: 5,
    red_flags_hit: 1,
    final_confidence: 0.95,
    succeeded: true,
    // ... other fields
    ..Default::default()
});

metrics.finalize(true);
println!("{}", metrics.summary());
println!("{}", metrics.red_flag_analysis());

Integration

Use via the brainwires facade crate with the mdap feature, or depend on brainwires-agent directly:

# Via facade
[dependencies]
brainwires = { version = "0.11", features = ["mdap"] }

# Direct
[dependencies]
brainwires-mdap = "0.11"

The prelude module re-exports the most commonly used types:

use brainwires_mdap::prelude::*;

License

Licensed under the MIT License. See LICENSE for details.