
A research agent divides a request into subtasks. Each worker finds a reason to request two more. The application allows only two active workers, yet the queue keeps growing as earlier workers finish. The concurrency limit is respected while the overall work continues to expand. For the business, that can mean delay and unpredictable resource consumption without a more useful deliverable.
Agent fan-out needs separate limits for separate dimensions. Depth limits the permitted generations of delegation. The lifetime total limits how many new jobs are admitted throughout the run. Concurrency limits how many are active at once. None automatically replaces the other two, and none is itself a time or model-usage limit.
Define What Each Counter Measures
We use an explicit convention: the initial coordinator is at depth zero and the first worker at depth one. With maximum depth one, that worker cannot create another generation through the coordinator. A total limit of six workers includes all admitted creations throughout the run, even after most have finished. The initial coordinator is excluded from this particular count.
These are definitions for this experiment, not universal meanings across platforms. A tool may use recursion limit for workflow steps or apply concurrency at another level. Before relying on a setting, establish what it actually counts and where it is enforced. The same name in two libraries does not establish that it constrains the same behaviour.
Derive the Parent and Depth in the Coordinator
A worker proposes a subtask but does not decide its own depth. In the experiment, a message is associated with the particular Worker object that sent it. The coordinator retrieves the registered parent identity and derives the next depth. Claiming depth zero in the message does not reset the chain. An attempt to declare a different parent is rejected.
The lifetime budget also needs to be reserved before queue admission. Counting only workers that have started can allow many accepted but waiting jobs to exceed the intended limit. Checking and reserving must form one consistent decision. Our local experiment uses one coordinator in a single process; it does not establish equivalent atomicity in a distributed system.
The outline below describes the decision order. The source_id comes from the coordinator rather than a field chosen by the worker. This is not complete production code or an implementation of a particular agent framework.
parent = registry[source_id]
next_depth = parent.depth + 1
reject if next_depth > depth_cap
return existing if key is known
reject if accepted >= total_cap
reserve(parent, task_key)
enqueue()Three Actual Local Runs with Different Limits
We used actual Node.js worker_threads with cooperative synthetic workers. Each requested two distinct subtasks, repeated one request and attempted to declare a different parent. No LLM, agent framework or external API was used. The experiment concerns actual local worker creation and termination through the coordinator, without claims about any model’s quality, speed or cost.
The official Node.js documentation describes worker_threads as threads executing JavaScript. We used them to observe creation and exit events, not to recommend dedicating a thread to every model call. All workers started with an explicitly empty environment, which was verified within the experiment. No service credentials were distributed.
| Run | Created | Peak active |
|---|---|---|
| Depth 1 | 3 | 2 |
| Total 6 | 6 | 2 |
| Active 2 | 9 | 2 |
The first run allowed up to 50 workers overall but only depth one. It created the three initial workers and rejected later generations. The second allowed depth five but only six admitted workers overall. It created six, then rejected additional proposals at the lifetime limit. The different reasons for refusal were recorded separately.
The third run allowed depth two and a total of twenty. It created nine workers while never exceeding two active workers. This demonstrates specifically why concurrency does not bound the lifetime total. Repeated requests that had already been admitted did not create another worker, and parent overrides were rejected. In all three runs, every created worker exited and the queue emptied.
Keep Refused Work Visible
When a new branch is refused, its parent needs to know which question remains open. The application may return a partial result, request a specific human decision or close the task with an explicit limitation. Stopping worker creation must not be presented as complete coverage. The user needs a useful explanation of the gap rather than internal traces or a generic success message.
A creation limit also does not prevent an existing worker from continuing excessively. Runtime, repeated tool calls and model consumption need their own controls. Other creation paths with independent capabilities can bypass the central policy. This local experiment was neither a hostile-code sandbox nor a restart-durability test.
Related Stigmahost services
When accepting a business application, request separate evidence for depth, lifetime count and active workers, with the counting conventions written down. Stigmahost App Development can cover the mechanism that admits and records new work. AI Automation can help define which subtasks the workflow needs and when further delegation should stop. The deliverable should explain what finished and which limit left something unresolved.
