There's a classic CS joke: git blame tells you who wrote the code, but it can't tell you why it made sense at the time. Multi-agent systems have the same problem — by the time a task finishes, nobody can tell you whether the final output still matches the original intent. The intermediate agents each did their job. The goal just quietly drifted somewhere along the way.

The structural gap I keep hitting with the current SelectorGroupChat design:

AutoGen's Planning Agent is doing two things at once:

• Coordinating execution (assigning tasks, sequencing agents)
• Keeping track of whether the original goal is still being honored

These two responsibilities have very different failure modes. Coordination failure is loud — tasks get dropped, agents deadlock, TERMINATE never fires. Goal drift is silent — every agent reports success, the workflow completes cleanly, and the output is coherent but wrong in a way that only becomes apparent later.

Mixing both into one Planning Agent means that when coordination gets complex (which it always does), goal integrity gets deprioritized. It's just cognitive load — the planner is managing traffic while also trying to remember where everyone was supposed to be going.

The analogy that makes this concrete:

Distributed systems solved a version of this in the 80s. Paxos and Raft aren't about making nodes smarter — they're about designating which node's version of truth wins when nodes disagree. The insight wasn't "let all nodes negotiate equally"; it was "equal negotiation produces noise, not consensus." You need asymmetry to get convergence.

Multi-agent LLM systems are re-discovering this the hard way. When two agents produce conflicting outputs, the current resolution mechanism is essentially: whoever gets read first by the next LLM call wins. That's not consensus. That's a race condition with a language model as the referee.

What I'm proposing — a Mission Keeper role:

Separate the goal-integrity function from the coordination function entirely.

Mission Keeper     → holds the original intent, never executes tasks
     ↓ (validates drift)
Coordinator Agent  → manages task flow, assigns work
     ↓ (executes)
Worker Agents      → do the actual work

The Mission Keeper's only job is to compare intermediate outputs against the original goal and flag when they're diverging. It doesn't assign tasks. It doesn't coordinate. It has no opinion on how the work gets done — only on whether the work is still pointed at the right thing.

This matters especially for long-running tasks where the original user intent is several tool calls back in the context window and getting diluted with each step.

Why this is different from just improving the Planning Agent:

Giving the Planning Agent better prompts for goal-tracking doesn't fix the structural problem. A single node doing both things will always context-switch between them. Under load (many agents, long task chains), goal integrity is what gets dropped first — not because the LLM forgot, but because the planner's attention is genuinely occupied with coordination.

The fix isn't a smarter planner. It's a role separation.

Is this a direction the team has considered? I can see it being implemented as a lightweight wrapper around the existing SelectorGroupChat — an outer observer that receives all messages but only intervenes when it detects goal drift above some threshold. Happy to sketch that out if useful.