MAKER Framework Skill

Transform unreliable single-model inference into robust, verifiable reasoning through maximal decomposition, parallel consensus voting, and systematic error filtering.

When to Use MAKER

High-value triggers:

• Tasks requiring >90% accuracy (medical, legal, financial)
• Multi-step reasoning where errors compound (p^n problem)
• Verification-critical outputs (code, calculations, facts)
• Ambiguous tasks benefiting from diverse perspectives

Skip MAKER for:

• Single-fact retrieval (no decomposition benefit)
• Creative tasks where diversity is desirable
• Time-critical responses (voting adds latency)

Core Architecture

MAKER operates on three pillars applied sequentially:

Task → [Pillar 1: Decompose] → DAG of subtasks
     → [Pillar 2: Vote]      → Parallel execution + consensus
     → [Pillar 3: Filter]    → Red-flag invalid outputs
     → Validated Result

Pillar 1: Maximal Agentic Decomposition (MAD)

Decompose complex tasks into atomic, independently-executable subtasks forming a DAG.

Decomposition principles:

• Each subtask has single, well-defined objective
• Subtasks receive explicit input/output schemas
• Dependencies form acyclic graph (no cycles)
• Maximize width (parallelism) over depth (sequential)

Tool: makerbuilddag

Pillar 2: First-to-Ahead-by-k Voting

Execute each subtask with m parallel agents; accept when one result leads by k votes.

Configuration by criticality:

Tool: makervote, makerget_config

Pillar 3: Red-Flagging System

Discard outputs exhibiting error indicators before voting.

Red flag types:

• Length exceeded (verbose = uncertain)
• Format violation (schema mismatch)
• Placeholder detected ([TODO], [N/A])
• Uncertainty markers ("possibly", "might be")

Tool: makerredflag

Workflow

Standard MAKER Pipeline

1. Decompose task → maker_build_dag
2. For each subtask in topological order:
   a. Generate prompts → maker_generate_prompt (×m)
   b. Execute agents (parallel LLM calls)
   c. Validate outputs → maker_red_flag (each)
   d. Vote on valid outputs → maker_vote
3. Compose results → maker_compose_results

Example: Multi-Hop QA

Task: "What is the capital of the country where the inventor of the telephone was born?"

Step 1: Decompose

{
  "subtasks": [
    {"id": "t1", "description": "Identify inventor of telephone", "dependencies": []},
    {"id": "t2", "description": "Determine birthplace of {t1}", "dependencies": ["t1"]},
    {"id": "t3", "description": "Identify capital of {t2}", "dependencies": ["t2"]}
  ]
}

Step 2: Execute with voting (m=5, k=2 for medium criticality)

t1 outputs: ["Alexander Graham Bell", "Alexander Graham Bell", "A.G. Bell", "Alexander Graham Bell", "Bell"] → Normalize → "alexander graham bell" wins with 4 votes

t2 (with input "Alexander Graham Bell"): → "Edinburgh, Scotland" wins after red-flagging one verbose response

t3 (with input "Scotland"): → "Edinburgh" wins unanimously

Step 3: Compose Final answer: "Edinburgh"

Integration with Reasoning Skills

With hierarchical-reasoning

MAKER complements hierarchical-reasoning by adding reliability to each reasoning level:

Strategic level → MAKER(criticality=high) for key decisions
Tactical level  → MAKER(criticality=medium) for approach validation
Operational     → Direct execution for atomic operations

With knowledge-graph

Use MAKER voting on entity extraction to achieve higher-quality knowledge graphs:

Document → [MAKER: Extract entities (m=5)] → Validated entities
        → [MAKER: Extract relations (m=5)] → Validated relations
        → knowledge-graph merge

Tool Reference

makerbuilddag

Construct DAG from subtask definitions. Validates acyclicity and computes execution order.

makerredflag

Apply red-flag validation to agent output. Returns is_valid boolean and flag details.

maker_vote

Execute first-to-ahead-by-k voting. Returns consensus output with confidence score.

makercomputereliability

Calculate theoretical system reliability for given (m, k, n) configuration.

makergetconfig

Get recommended (m, k) configuration for criticality level.

makercomposeresults

Combine validated subtask outputs into final result.

makergenerateprompt

Create optimized micro-agent prompt with constraints and schema.

Configuration Guide

Selecting m and k

Cost-accuracy tradeoff:

• Higher m → more reliable but costlier
• Higher k → stronger consensus but slower termination
• Early termination typically reduces cost by 30-50%

Decision framework:

1. Start with criticality-based defaults via makergetconfig
2. Use makercomputereliability to validate configuration
3. Adjust based on empirical accuracy and cost metrics

Output Schema Design

Well-designed schemas enable format-based red-flagging:

{
  "type": "object",
  "properties": {
    "answer": {"type": "string"},
    "confidence": {"type": "number", "minimum": 0, "maximum": 1}
  },
  "required": ["answer"]
}

Equivalence Methods

• exact: String equality after trim (dates, numbers)
• normalized: Lowercase + whitespace normalization (text)
• json: Parse and re-serialize for canonical comparison (structured)

Performance Characteristics

Reliability improvement (assuming 85% agent accuracy):

Cost multiplier: ~4-6× single agent (with early termination)

Latency: ~2-4× single agent (parallelism offsets voting overhead)

Error Handling

Insufficient valid outputs (red-flagging too aggressive):

1. Retry with additional agents
2. Relax red-flag thresholds
3. Refine subtask prompt

No consensus (high disagreement):

1. Further decompose the problematic subtask
2. Increase k threshold
3. Escalate to human review

Cycle detected in DAG:

1. Review dependency structure
2. Break circular dependencies into sequential steps