More executors do not remove prerequisites
An AI-agent system answers from a document, catalog and rules. Individual agents seem fast and steps can overlap, but a third executor does not improve completion time. We must know prerequisites rather than merely divide durations. A small explicit workflow gives a lower bound and a schedule reaching it. The question concerns coordination, not answer accuracy.
Abstract. Six synthetic tasks require 13 s total work; dependencies enforce 10 s path A→B→D→F. One worker takes 13 s, two 10 s, third adds no improvement. Code filters 720 permutations to five valid topological orders and constructs integer-duration nonpreemptive schedules. Matching the critical-path bound proves optimality for this instance. Durations are chosen, not LLM, service or EL-AI measurements.
A graph describes constraints, not a conversation
A directed acyclic graph, DAG, has task nodes and arrows A→B meaning B needs completed A. No dependency path returns to its origin. We model no iterative dialogue, retries or graph-changing decisions; cycles need another model or finite iteration expansion. Each task runs once, without external effects or interruption.
A is document preparation 2 s; B catalog search 4 s; C rule reading 1 s; D combining 3 s; E separate rule check 2 s; F finalization 1 s. Names explain chosen tasks, not available modules. B, C need A; D needs B, C; E only C; F needs D, E. E’s explicit independence from B permits useful overlap.
| Task | Duration(s) | Predecessors |
|---|---|---|
| A | 2 | — |
| B | 4 | A |
| C | 1 | A |
| D | 3 | B, C |
| E | 2 | C |
| F | 1 | D, E |
The bound no worker count beats
With unlimited workers, a task’s earliest finish is its duration plus maximum predecessor finish. All must be ready, not merely the fastest. Empty predecessor maximum is zero. Topological order places predecessors first so their finishes are known. This yields a lower bound, not yet a two-resource schedule.
Final 10 s comes from A→B→D→F:2+4+3+1. Its tasks cannot overlap, a critical path. Even 1000 workers cannot finalize before D receives and combines B. A→C→E→F takes 6 s and does not bind here; E is still required, its timing can be absorbed while awaiting another branch.
Capacity also gives T≥W/P for 13 worker-seconds and P identical workers without duplicated work. Thus T≥max(10,13/P); with 2, path 10 dominates 6.5. Bounds alone do not generally construct a schedule; constraints may add waiting. But a valid 10 s schedule proves optimality under these assumptions.
Build and check a schedule reaching the bound
Two workers run A 0–2 s; B 2–6 alongside C 2–3; after C, E 3–5. At 6, B and C complete, D runs 6–9. E already ended, so F 9–10. At most two tasks overlap and all prerequisites precede starts. Figure shows task intervals, not CPU/GPU utilization measurements.
| Workers | Makespan(s) | Total work(s) |
|---|---|---|
| 1 | 13 | 13 |
| 2 | 10 | 13 |
| 3 | 10 | 13 |
Work stays 13 s, makespan 13→10 by overlap, speedup 1.3 not 2. Third worker cannot parallelize the critical chain, so adds no benefit here. It identifies the actual bottleneck rather than advising more agents. A third service could still help throughput across concurrent requests; we study one workflow completion.
Accelerate the right node
Code runs separate variants: E 2→1 s leaves completion 10 s; E already finished before critical branch. B 4→2 s enables 8 s with two workers. Change one duration at a time and recompute, without assuming free speedup. E optimization may save work or help other goals, but need not reduce this workflow’s makespan.
| Variant | Makespan(s) |
|---|---|
| E:2→1 | 10 |
| B:4→2 | 8 |
Topological order is not yet a timed schedule
Python 3.14 graphlib TopologicalSorter accepts predecessors and exposes nodes whose prerequisites are completed; get_ready/done were read. A static order does not assign durations or workers. done must mean required result ready, not merely request started. No agent framework tested; we separate library ordering from coordinator responsibilities.
Enumerate 720 permutations, retain 5 respecting edges. For each priority order, place tasks in earliest free integer interval after predecessors, capacity P, nonpreemptive. This priority enumeration is not claimed to describe every schedule generally. Finding 10 s plus independent lower bound 10 s proves this instance optimal.
Assertions verify precedence and capacity. Factorial search is educational, not scalable to hundreds of agents. Earliest-finish calculation in topological order is O(V+E) for nodes/edges given durations. Complexity is abstract, not platform timing. Code/JSON expose every plotted interval.
Where the model ends and the service begins
Real agents have variable duration, network waits, rate limits and unequal memory. Independent calls may share a GPU. Our identical abstract workers run one task each for its full duration; contention is unmodeled. Mean durations are not hard deadlines, and slowest branches can vary. Dependency graphs do not replace timing-distribution measurements.
Operational comparison should record starts and result-ready times, separating execution from waiting. This is proposed, not an EL-AI experiment. Agent quality, token cost and reliability are unmeasured; faster completion does not prove correct answers. These require different evidence. Quantitative conclusions apply only to the declared deterministic schedule.
Parallelism helps work that can overlap. Two workers reach 10 s bound; third cannot shorten critical path. Speeding B changes the bound, not E in the tested variant. Explicit dependencies replace vague impressions with verifiable explanation of unavoidable versus resource-dependent waiting.
from experiment import D,PRE,schedule
print(schedule(tuple(D),2))Code, data, and instructions · JSON. Educational calculations executed with Python 3.14.0; figures with Matplotlib 3.11.2. AI-assisted analysis, without claiming peer review or human review. Original illustrative ImageGen cover: it does not document EL-AI people, premises, or installations. Sources accessed 17 October 2026.