Three Research Modules, One Agent — and a Disabled Flag That Doesn’t Stop Execution

Agent-sharing in multi-module pipelines is the condition where two or more separately configured task modules resolve to the same underlying agent process, so the agent’s execution lifecycle is controlled by the union of all modules mapped to it — not by any single module’s enabled/disabled flag.

The flag you toggled didn’t do what you think

Disabling a module feels decisive. The checkbox is off; the task won’t run. That mental model breaks the moment two modules share one agent runner — because the agent doesn’t belong to the disabled module alone. It belongs to every module mapped to it, and as long as one of those stays enabled, the agent keeps executing.

This is not a hypothetical. In our own pipeline audit measured on 2026-08-10, five research modules resolved to exactly two agent runners — and the enabled/disabled split across them tells the story precisely.

What the audit found

The task-to-agent map showed two separate collision sites.

Collision 1: group12_research.market_agent
Two modules — one disabled, one enabled — both route to the same agent. The disabled module’s scheduling is suppressed. The agent itself is not. It loads, it initializes, and it processes work for the enabled module on the same process that the disabled module would have used.

Collision 2: subagent_runner
Three modules share this runner. Two are enabled; one is disabled. Same pattern: the runner is live because two modules need it. The third module’s disabled flag changes nothing about whether subagent_runner executes — it only changes whether that module contributes tasks to the queue.

The practical implication: a developer who disables a module expecting to silence an agent is actually silencing only that module’s task contribution. The agent’s system prompt still loads, its memory still initializes, and its behavior still influences any shared state.

How the agent actually loads

The measurement from 2026-08-24 clarifies the mechanism. A grep across the nine SAVYX agent definition files found that every single one — 9 out of 9 — carries a rejected_scan field with a value of 1. More critically, the runner code at line 707 passes the agent’s markdown definition file as the system prompt directly. That means when subagent_runner starts for an enabled module, the full agent definition for every module mapped to that runner is structurally present in the process — not just the enabled module’s definition.

This is the underlying reason the disabled flag is insufficient: the agent is instantiated at the runner level, not the module level.

The Science One parallel: verifiability requires tracing the actual chain

Google Research’s Science One Framework, announced July 30, 2026 by Rui Meng and Tomas Pfister, was built to solve a structurally similar problem in AI research pipelines. Autonomous research systems — including systems like Sakana’s AI-Scientist and AutoResearchClaw — generate errors at one stage that get laundered into trusted inputs at the next. Science One’s Chain-of-Evidence (CoE) approach addresses this by building verifiable evidence chains natively, so the execution path is auditable rather than assumed.

The agent-sharing problem is the operational version of the same failure mode. When you assume “disabled = not running,” you are trusting the label rather than the chain. The CoE Audit principle — trace what actually executed, not what the configuration said should execute — applies directly: the agent map is the ground truth, not the module flag.

Why the scheduling window matters

The audit also surfaced a timing detail that is easy to miss. The SAVYX Benchmark Scan last ran on 2026-08-19 at 06:00, before pipeline rewiring was complete. Its next scheduled run is 2026-08-26 at 06:00. Any module-level changes made between those two timestamps are not yet reflected in benchmark output. If a team member reads the 2026-08-19 benchmark and concludes that a disabled module is confirmed silent, that conclusion is based on a pre-rewiring snapshot.

The SAVYX SelfDev Audit, by contrast, ran on 2026-08-10 at 06:00 with a return code of 0, producing a 7,425-byte output file. That run captured the collision state — the three-modules-to-one-runner mapping — before any remediation. It is the authoritative record of what the pipeline was actually doing, and it diverges from what the module flags said it should be doing.

The decision rule for multi-module pipelines

The pattern generalizes beyond this specific case. Any pipeline where the agent count is lower than the module count has at least one sharing collision. The operational rule:

Route by agent lifecycle, not by module label. Before toggling a module’s enabled flag, check the agent map. If any other enabled module resolves to the same runner, the agent will not stop. The correct intervention is either to give the module its own dedicated agent, or to accept that disabling the module only removes its task contribution — not its agent’s presence.

This is the same structural logic that makes multi-agent safety hard in general: properties verified at the module level do not compose at the runner level. Google DeepMind’s 15 years of games research, from DQN’s Atari work through to current partnerships with EVE Online developer Fenris Creations, arrived at a similar principle — the behavior of a system in constrained, instrumented conditions diverges predictably from behavior in live, shared environments. Atari agents optimized in isolation; multi-game generalization required understanding the shared substrate. Multi-module pipelines require the same shift in analysis unit.

What to instrument now

Three checks that catch agent-sharing before it causes confusion:

1. Build the agent map explicitly. For every module, log the agent runner it resolves to at startup. If two modules share a runner, that fact should be visible in the dashboard — not discoverable only by grep.

2. Separate “task enabled” from “agent enabled” in your status model. A module can be disabled (no tasks scheduled) while its agent remains active (runner live for other modules). Treat these as two independent state variables, not one.

3. Timestamp your configuration snapshots against your benchmark runs. The 2026-08-19 benchmark and the 2026-08-26 benchmark are not interchangeable reads on the same system state. Label them as what they are: pre-rewiring and post-rewiring measurements.

The audit’s bottom line is not that the pipeline was broken — it ran cleanly, as the rc=0 on the SelfDev Audit confirms. The finding is that the mental model of “disabled means silent” was wrong, and operating on a wrong mental model of your own infrastructure is where quiet bugs grow into expensive ones.

Looking for more on ai & digital income? Visit SAVYX

Frequently Asked Questions

If I disable a module, does its agent stop running?

Not if another enabled module shares the same agent runner. The agent’s lifecycle is controlled by the union of all modules mapped to it. Disabling one module removes its task contributions but leaves the shared agent active for the remaining enabled modules.

How do I know whether two modules share the same agent?

Check the task-to-agent map at startup, not the module configuration file. In our 2026-08-10 audit, five modules resolved to only two agent runners — a collision invisible from the module-level enabled/disabled flags alone. A startup log that records which runner each module binds to is the reliable source.

Why does the agent’s system prompt matter when a module is disabled?

The runner loads the agent’s markdown definition file as its system prompt at the process level, not the module level. When the runner starts for an enabled module, the full agent definition is structurally present — regardless of which other modules sharing that runner are disabled.

What is the difference between ‘task enabled’ and ‘agent enabled’?

Task-enabled controls whether a module contributes work to the queue. Agent-enabled controls whether the underlying runner process is active. These are independent states: a module can be task-disabled while its agent runner remains live, executing work for other modules mapped to the same runner.

Why don’t benchmark results always reflect the current pipeline state?

Benchmarks are point-in-time snapshots. If a benchmark ran before pipeline rewiring was complete, its output describes the pre-change state. Reading a benchmark without checking its timestamp against configuration changes is the operational equivalent of checking a map that predates a road closure.

Disclosure: As an affiliate, this post may earn a commission from qualifying purchases at no extra cost to you.