For a long time, I’ve been fascinated by one idea: any sufficiently complex task, as long as its outcome is finite and measurable, can be decomposed into a finite decision tree made of atomic steps.

The problem with today’s language models is that they are not deterministic and often struggle with complex tasks, especially when those tasks consist of many repetitive, structurally similar elements.

Some time ago, I came across a paper that demonstrates the power of decomposition through the Tower of Hanoi problem: Solving a Million-Step LLM Task with Zero Errors.

The core idea is simple but powerful:

If a large, complex task is decomposed into measurable atomic steps and then executed by a swarm of primitive agents, the final result can be significantly better than what a single AI agent could produce.

This is one of the key principles behind swarm intelligence: We don’t necessarily need a superintelligence. A superintelligence may simply be many small, imperfect intelligences working together.

This paper inspired me to design a practical decomposition method. The Tower of Hanoi is a great example, but from a practical standpoint, it is not very useful.

🌈 So meet RAVD — Recursive Atomic Verified Decomposition

How RAVD works

RAVD is built on two core principles:

1. Atomic steps must be finite.

2. Every step must have a clear way to measure error.

If these two conditions hold, then an arbitrarily complex task can be decomposed into a finite set of atomic steps. Each step can then be executed, verified, and evaluated independently. In other words, we can measure whether the task was done correctly through structured error metrics.

The process works as follows:

1. First, every incoming request is normalized and classified. If the task contains repeated structures — for example, “find and download a trilogy of books” — the decomposer must explicitly create three separate branches in the DAG, one for each book. In the system, this is handled through collection_hints.

2. Next, the system retrieves a CIP — Class Instruction Pack — from the knowledge base. A CIP is a formal instruction set that defines schemas, input/output rules, atomicity rules, verifiers, error metrics, and execution constraints. Each task class should have its own CIP.

3. Then, the complex task is recursively decomposed into atomic leaves:

   1. Check whether the current node is atomic.

   2. If it is not, generate decomposition candidates.

   3. Validate the candidates.

   4. Select the best one through voting.

   5. Recursively repeat the process for every child node.

4. For every non-atomic node, the system generates an odd number of candidate decompositions. Invalid candidates are discarded. Equivalent candidates are merged. The final selection is made using a first-to-ahead-by-k voting strategy: the winner is the candidate that gets ahead of all others by k votes, rather than simply receiving the highest number of votes.

5. Finally, the system builds a detailed DAG in the form of a JSON contract. Independent graph branches are executed in parallel through Ray.

For example, in the trilogy task, the search branches for each book would run in parallel.

What is an atomic step?

An atomic step is a step that satisfies all five conditions at once:

• All required context fits into the local step contract.

• The output is typed and follows a strict schema.

• There is a verifier that returns either pass/fail or a numeric score.

• There are no hidden subgoals inside the step.

• The step can be safely retried or rolled back.

Why RAVD is useful in practice

For testing, I selected three task classes:

• Finding and downloading relevant literary resources.

• Verifying marketing data aggregates across multiple CRM and internal systems.

• Selecting and validating robotic actuator systems through MATLAB.

None of these task classes can be reliably solved through a single request to ChatGPT or any other general-purpose model.

For each task class, the system builds a full DAG with acceptable error bounds defined for every atomic step.

Here are a few examples:

Example 1: Legal literature search

The resulting decomposition creates three separate branches — one for each book in the trilogy.

Example 2: Robotic actuator selection

There is a 6-axis pick-and-place robotic manipulator. We need to select electric drives for 
all axes J1-J6.

Data:
J1: rotary base, inertia 0.42 kg*m^2, max speed 90 deg/s.
J2: shoulder, link mass 8 kg, COM 0.38 m, payload 3 kg, move 70 deg in 1.1 s.
J3: elbow, link mass 5 kg, COM 0.25 m, payload contribution 3 kg, 
move 90 deg in 0.9 s.
J4-J6: wrist axes, inertia 0.018/0.011/0.006 kg*

In this case, the decomposition creates separate branches for each actuator that needs to be selected and validated.

For each atomic step, non-gradient hard-fail modes set:

Otherwise:

The step passes when E_step <= expected_error_threshold, should be redone when E_step >= redo_threshold, and becomes hard-fail/human-review when E_step >= hard_fail_threshold or any listed hard-fail mode is present.

Example 3: Contribution Margin audit

This is where things become especially interesting:

How errors are calculated:

Marketing data tasks require more than just calculation. To audit them properly, the system needs to understand the logic of the underlying business metrics, attribution rules, cost models, and data pipelines.

The same applies to physical simulations in tools like MATLAB. The system needs not only to compute values, but also to understand the physical constraints of the real world and reason about whether the result actually makes engineering sense.

That is exactly where DAG decomposition becomes powerful.

It allows us to combine strict algorithmic calculations with flexible AI-driven pipelines.

As a result, we get a system that is more deterministic, more verifiable, and still flexible enough to search for the right approach when the task itself is ambiguous or complex.

The next step is to build the part of the system that launches a swarm to execute every atomic step.

Once this is done, we will finally have a system capable of solving complex, multi-step tasks autonomously — without constant human supervision.

😏 Isn’t that beautiful?