Control-Loop-Mapped Agent Chain

also known as ARC-Mapped Operator Agents, One Agent Per Feedback Loop, Selector-Arbitrated Agent Team

Give each existing feedback loop in a plant's control chain its own operator agent carrying that loop's control-theoretic context, and resolve their competing proposals with the chain's own deterministic selector logic.

This pattern helps complete certain larger patterns —

specialisesStochastic-Deterministic Boundary (SDB)★— Formalize the seam between an LLM proposal and a system action as a four-part contract — proposer, verifier, commit step, reject signal — so the contract itself, not the agent's good intent, gates side-effects.

Context

A physical process — a distillation column, a barn ventilation system, a compressor train — is already run by a commissioned chain of feedback loops. Each loop defends one controlled variable against one manipulated variable, each has a setpoint and limits, and the chain records which loop wins when two of them pull the same actuator: MIN and MAX selector networks decide between competing controlled variables, split-range logic divides one manipulated variable between loops, and an override layer sits above both. That structure was derived from a hazard analysis and signed off long before anyone proposed putting a language model near the plant. Someone now wants operator agents that read the process, propose the next move, and explain the move in words an operator can check.

Problem

The default multi-agent shape invents roles for the task and asks a coordinating model to arbitrate between them. Both halves fail here. Roles invented for the task have no relationship to the loops the plant actually runs, so nobody can review the team against an engineered artefact, and the prompt for a general-purpose agent has to carry whole-plant context that only retrieval can supply — which turns a reviewable prompt into a scored guess. Arbitration by a model is worse: contention over a shared manipulated variable already has an answer that came out of a safety analysis, and a coordinating model can at best reproduce that answer and at worst overrule it under load, at a tier too slow to run at every control sample. Measurement shows why the loops cannot simply be handed over: on Skogestad's Column A an ungated agent supervisor beat a Pareto-tuned linear controller on off-nominal target acquisition, at an error ratio of 0.361 at the upper confidence bound, and inverted by a factor of 16.03 on disturbance rejection over the same sixteen-point grid.

Forces

A general-purpose model does well on general tasks and badly on narrow domain ones, largely because supplying narrow context and bounding the task are both hard; a loop-scoped prompt makes the bound structural instead of retrieved.
Contention over a shared manipulated variable already has an engineered, hazard-derived answer, and any arbitrator that reasons about it can only match that answer or degrade it.
A model arbitrator can express nuance a fixed selector network cannot, but it runs at a slower tier and cannot be guaranteed to return a usable value at every control sample.
One agent per loop is affordable only when each agent's task fits a small local model — the reported case ran Qwen 2.5 7B Instruct offline on a single 24 GB consumer graphics card at a five-minute cadence — and cost then scales with loop count.
The same agent that wins on one regime loses badly on another, so per-loop competence is scenario-dependent and cannot be assumed uniform across the chain.

When to use

The domain already has a commissioned control-loop topology with a documented priority structure such as selectors, split-range logic or an override layer.
Contention over a shared actuator has a safety-derived answer that predates the agent and must not be renegotiated at runtime.
Each agent's task can be bounded to one controlled variable and the measurements belonging to its loop.
Per-sample records and an operator-readable rationale are needed for audit or for a control campaign logbook.
The control cadence is slow enough that one model call per loop fits inside a sample interval.

When not to use

No prior control chain exists and the roles genuinely have to be invented for the task.
The conflicts are open-ended objective trade-offs with no engineered priority, where a human-authored resolution table or an escalation path fits better.
The correct response to a conflict is to renegotiate the objective rather than to apply a fixed structural priority.
Loop count times per-call latency exceeds the control cadence, so proposals would arrive after the sample they were meant for.
The regulatory layer would have to be modified for the agents to act, rather than the agents writing into an existing setpoint interface.

Example

A dairy barn holds its air temperature, humidity and air change rate with three feedback loops that were commissioned years ago, and when the barn turns hot and damp at once an existing selector already decides which loop gets the fans. A small language model is added to each loop, proposing the next fan setting and writing a sentence a farmer can check. The selector is left untouched, so it still decides what actually reaches the fans. When one of the models returns nothing before the next sample, the original controller holds that loop and the log records a fallback for the sample.

Diagram

flowchart TD D["Commissioned control chain diagram"] --> A1["Agent: loop 1 (CV, setpoint, priority, selector kind)"] D --> A2["Agent: loop 2"] D --> A3["Agent: loop 3"] A1 --> P["Proposals: u_request, mode, rationale"] A2 --> P A3 --> P P --> O{"Proposal valid and on time?"} O -- "no" --> F["Base regulatory controller holds, fallback flag set"] O -- "yes" --> S["Deterministic orchestrator: MIN/MAX selectors, split-range rule, override layer"] S --> C["Single actuator command"] F --> C P --> L["Per-sample record: timestamp, measurement, setpoint, u_request, mode, rationale, fallback"] S --> L

Solution

Therefore:

Take the chain diagram as the specification for the team. Every feedback loop in it becomes exactly one operator agent, and that agent's prompt carries the loop's control-theoretic context and nothing else: the controlled variable it defends, the current setpoint and limits, its priority within the chain, the kind of selector it feeds, and the measurements belonging to that loop. Because the scope comes from the diagram rather than from a search over plant documentation, the retrieval problem becomes a prompt an engineer can verify by reading it. At each control sample every agent proposes a value for its own manipulated variable together with a mode and a short rationale. An orchestrator collects the proposals and applies the chain's interaction logic in the order the chain prescribes — MIN and MAX selectors for switching between competing controlled variables, the split-range rule for dividing one manipulated variable, then the override layer — and that step contains no model call, so every constraint conflict resolves deterministically regardless of what the models produced. A proposal that is missing, late, or outside its declared limits is dropped and the base regulatory controller's own output holds the loop, with the substitution flagged. Each agent appends one record per sample carrying the timestamp, measurement, setpoint, requested output, mode, rationale and fallback flag, which gives an auditable trajectory and a logbook written in operator language. A slower advisory tier may use a model to comment on the trajectory or suggest setpoint changes for review, but it never becomes the per-sample arbitrator.

What it gives you

Each agent's context is bounded by construction, so the retrieval problem is replaced by a prompt a domain expert can verify by inspection.
The team inherits the safety property of the control chain: every constraint conflict is resolved deterministically by the orchestrator, whatever the models emit.
The topology is reviewable against an artefact that already exists and was already commissioned, rather than against roles someone invented for the task.
Per-loop scope keeps each agent small enough for a local open-weight model, so the control cadence does not depend on a hosted frontier model.
The per-sample records give an auditable trajectory paired with an operator-voice rationale, which is what a control campaign logbook needs.

What it costs you

The pattern only applies where a control-loop topology exists and is documented; where override logic was rewired in the field and never redrawn, the mapping produces a team that defends the wrong variables.
The priority structure is fixed at commissioning, so a conflict the chain never anticipated is still resolved by a rule that was not written for it, and no agent can escalate past that rule.
Per-loop competence is scenario-dependent: the same agent supervisor that beat a tuned linear controller on target acquisition inverted by a factor of 16.03 on disturbance rejection, so each loop needs its own gate rather than blanket trust.
Deterministic arbitration reads numbers only, so the rationale that makes the trajectory reviewable plays no part in the decision and can drift away from what was applied.
Inference cost and per-sample latency both scale with loop count, which caps how many loops can be mapped at a given control cadence.
Where the operating specification sits on a safety limit, arbitration blocks well-behaved requests as readily as harmful ones — in one 250-cell pass 534 of 590 interventions had that geometry, against 318 blocks that corrected actively harmful proposals.

What this pattern forbids. Agents may only propose a value for their own loop's manipulated variable and cannot change their own chain priority; contention over a shared manipulated variable is settled only by the chain's selectors, split-range rule and override layer, so the arbitration step must contain no model call; and a proposal that is missing, late, or outside its declared limits must fall back to the base regulatory controller rather than being applied.

The smaller patterns that complete this one —

usesDecision Log★★— Persist the agent's reasoning trace alongside its actions so post-hoc review can explain why.

And the patterns that stand alongside it, or against it —

alternative-toRole Assignment★★— Assign each agent a named role (researcher, writer, critic, planner) with a role-specific prompt, tool palette, and acceptance criteria.
alternative-toOrchestrator-Workers★★— An orchestrator dynamically breaks a task into subtasks at runtime and delegates each to a worker LLM, then synthesises results.
alternative-toSupervisor★★— Place a coordinating agent above a set of specialised agents and route work to them.
alternative-toSOP-Encoded Multi-Agent Workflow★— Encode a human Standard Operating Procedure (roles, ordered phases, standardised hand-off artefacts) into a multi-agent pipeline so that agents communicate through structured documents rather than free-form chat.
complementsPriority Matrix (Conflict Resolution)★— Pre-define how the agent must resolve specific classes of goal conflicts via a human-authored lookup table — transforming the agent from a decision-maker (where it fails on competing objectives) into a decision-implementer.
complementsAction-Admissibility Tiering★— Gate a proposed physical action through an ordered ladder of independent, non-compensatory admissibility tests, and rank actions by usefulness only among those that passed every tier.
complementsGraceful Degradation★★— When a dependency fails, downgrade the user-facing experience to a working subset rather than failing entirely.

Neighbourhood

Click any neighbour to follow the language. Scroll to zoom, drag to pan.

References

Provenance

Source: patterns/control-loop-mapped-agent-chain.md on GitHub · commit 4eec3f8 · view history
Added to catalog: 2026-09-09
Last updated: 2026-09-09
Contribute: open an issue or PR at github.com/agentpatternscatalog/patterns.