SYNTHESIS NOTE
Topics›Novel Architectures›this note

Can extreme task decomposition enable reliable execution at million-step scale?

Can breaking tasks into maximally atomic subtasks with voting-based error correction solve the fundamental reliability problem in long-horizon tasks? This challenges whether better models or better decomposition is the path to high-reliability AI systems.

Synthesis note · 2026-02-23 · sourced from Novel Architectures

A system with a 1% per-step error rate is expected to fail after 100 steps of a million-step task. This makes traditional approaches to long-horizon tasks fundamentally infeasible — improving model accuracy from 99% to 99.99% is insufficient for tasks requiring thousands of dependent steps. MAKER (Massively Decomposed Agentic Processes) takes a different approach: instead of improving per-step accuracy, decompose until each step is trivially reliable, then apply error correction.

Three core components:

  1. Decomposition into minimal subtasks: Each agent handles a single, tiny "micro-role" rather than anthropomorphized human-level roles. By avoiding complex role assignments and instead exploiting the machine-like nature of LLMs, each subtask becomes solvable with high reliability.
  2. Error correction via subtask-level voting: Multiple agents independently solve the same subtask; voting identifies the correct answer. This is error correction at the finest possible granularity.
  3. Red-flagging to reduce correlated errors: Detects situations where voting might fail because errors are correlated across agents, and applies additional verification.

The scaling laws are formalized: probability of success and expected cost change predictably with total steps and decomposition level. Under extreme decomposition, effective scaling is feasible; without it, infeasible.

The most counterintuitive finding: state-of-the-art reasoning models are not required. Relatively small non-reasoning models suffice when the decomposition is extreme enough. This inverts the standard approach to hard problems — instead of smarter models, use dumber models on smaller problems.

This extends Does separating planning from execution improve reasoning accuracy? to an extreme: not just separating two functions, but decomposing the entire task into maximally atomic units. It also extends Why does majority voting outperform more complex inference methods? from answer-level voting to subtask-level voting with formalized scaling properties.

The implication for AI deployment: for tasks requiring very high reliability over many steps (organizational processes, scientific experiments, production pipelines), the path may run through decomposition and redundancy rather than through better models.

Inquiring lines that read this note 62

This note is a source for these research framings, grouped by the broader line of inquiry each explores. Scan the bold lines of inquiry; follow any specific question forward.

How does decomposing tasks improve reasoning and prevent failure propagation? Does RL create genuinely new reasoning capabilities or refine existing ones? How do evaluation practices shape which failures stay visible? Can self-generated feedback reliably guide model training without ground truth? Why can recurrent transformers achieve reasoning capabilities that standard transformers cannot? How should inference compute be allocated based on problem difficulty? How can evolutionary algorithms maintain diversity during solution search? Can multi-agent systems avoid converging on false agreement without deliberation? Can parallel reasoning outperform sequential reasoning under fixed token budgets? How do surface patterns enable correct outputs but reduce robustness? What execution architectures enable agents to most effectively use tools? What causes retrieval-augmented generation systems to fail despite access to external knowledge? Do reasoning benchmarks predict model performance in long-horizon workflows? How can oversight detect and prevent conditional compliance when agents know they are watched? How should test-time compute scaling work in agentic systems? Can intelligent routing over smaller models outperform scaling a single large model? Why do agents falsely report success on failed tasks? How does harness optimization generalize across different model architectures and domains? Can single-point security defenses protect multi-agent systems from multi-step attacks? Can harness architecture and protocols provide agent reliability without model scaling? Can inference-time compute effectively substitute for model scale? How much do training data properties shape model reasoning? How can we detect and prevent harm propagation through multi-agent delegation workflows? How do pretraining biases affect reward signal effectiveness in RLVR? How does the generation-verification gap limit what we can measure about AI reasoning? How does self-revision in reasoning models affect accuracy and confidence? Do multi-agent systems introduce security vulnerabilities that single-agent architectures avoid? Why do locally safe actions create system-level safety gaps? Can validator consensus certify semantic correctness beyond agreement? Can local safety checks guarantee system-level behavioral safety? When should work require human-AI partnership versus full automation?

Related concepts in this collection 7

This note in its neighbourhood — explore the map, then jump to a related concept in the list below.

Concept map
19 direct connections · 177 in 2-hop network ·dense cluster Open in graph ↗

Click a node to walk · click center to open · click Open in graph to see this note in the full knowledge graph

your link semantically near linked from elsewhere

Related papers in this collection 8

Papers most semantically related to this note, ranked by cosine similarity in the embedding space.

Original note title

extreme task decomposition into microagents with voting enables error-free execution at million-step scale