Adversarial Collaboration
Dual-agent friction, relocated to where the work hasn’t compressed into rules
The prior piece in this series, Lessons from the First Prototype Phase, was about retiring a dual-agent execution model — ChatGPT as prompt compiler, Codex as executor, Claude Code as advisor — and migrating to single-node Claude Code as both control surface and executor. The result was something like fifty times less ceremony at the execution layer, with all the structural friction the prior split had carried now encoded as durable rules in AGENTS.md and the project’s external grounding note.
That piece read as if dual-agent dialogue had been a phase to outgrow.
It wasn’t. It was a phase to relocate.
How execution-layer friction became rules
The retired model — call it Model A — had two agents arguing about execution. Should this commit happen now or wait for the prior chain to close. Should this Airtable mutation be plan-and-execute or probe-and-do. Should this finding land as evidence-chain artifact or navigation update. Each question was real, and the friction was the surface that worked out the answers. The friction was load-bearing as long as the discipline still had to be discovered.
Once the answers had stabilized, they compressed into rules. Plan-Before-Execute. Structured Change Summary. Single-Writer Discipline. Exact-Scoped-Diff Approval. Branch Freshness. Terminal-State Discipline. Encoding those in AGENTS.md made the discipline durable as rules rather than as conversation. With the rules in place, single-node Claude executes against them directly. The ceremony dropped because the friction wasn’t in the conversation anymore; it was in the rules.
That left an unexpected gap. The architectural-thinking layer — should this be a schema mutation; is this strain real or paper-only; where is the boundary between disciplined prose and structural representation; what does the curator-override correction actually clarify about how the curation event should be modeled — those questions haven’t compressed into rules, and may never compress that way. That is exactly where two LLMs in dialogue still earn their keep.
What had to harden first
Three things had to settle before dual-agent dialogue could reclaim the right altitude.
The execution layer became frictionless enough to disappear from the conversation. Single-node Claude with AGENTS.md rules just executes. Branch freshness, scoped diff before commit, structured change summaries, terminal-state discipline — these are no longer subjects of dialogue. They are the substrate.
The grounding note hardened as repo-external truth. The project’s intent, audience, philosophy, foundational premises, and operating model are written down outside the repo, in a slowly-aging document that both agents read on entry. This is the alignment layer. Without it, two agents critiquing the same repo would be having two unrelated conversations.
The repo itself became the project’s persistent state. Architecture artifacts, evidence chains, decision notes, milestones, navigation maps — all in the repo. None of the project state lives inside any specific conversation. Threads are bounded vessels that read from these durable sources on entry and write back on exit.
Together these are the backbone. They make context-loading into a fresh conversation cheap — measured in seconds, not preparation — which is what makes the dialogue pattern viable in the first place.
The pattern
Once the backbone is durable, the workflow is simple to describe.
Start a fresh thread for an architectural arc. Load the inputs: the grounding note, the current repo state, the most recent operational findings. Ask Claude — in the execution thread — to read the repo against the grounding note and surface concerns, doubts, things that don’t make sense. Independently, ask GPT — sitting outside any execution thread as advisor — to do the same critique against the same inputs.
The two critiques converge on the highest-leverage concerns and diverge on emphasis. That divergence is the point of asking both.
Take the advisor’s critique and pass it to the Claude control surface. Ask Claude to fold the advisor’s critique alongside its own and produce a plan to address what was surfaced. Send the plan to the advisor for response. The advisor pushes back, refines scope, splits bundled items, corrects sequencing, names risks the plan elided. Claude revises. The advisor pushes back again. They converge on an approved scope.
Then Claude executes. Each artifact lands as an exact scoped diff. The advisor reviews the diff and either approves or requests precision edits. Claude applies the edits. The advisor reapproves. Claude commits, pushes, opens PR, merges, cleans up branches.
Repeat for each architectural arc. Each arc lands a single bounded artifact or set of artifacts; nothing is bundled.
What this is called
The technique has a name. Adversarial collaboration is the strongest term — coined in social science (Kahneman, Mellers) for two parties with opposing views jointly designing the path toward a better answer. The friction is the mechanism, not a side effect. The paradox in the name is the point: adversarial and collaborative, because the disagreement serves the shared goal.
Two related terms worth knowing, each from a different research lineage:
Multi-agent debate — the active ML research label (Du et al. 2023, Improving Factuality and Reasoning in Language Models through Multiagent Debate). Symmetric: agents argue positions, often with a judge.
Actor-critic — borrowed from reinforcement learning, used loosely now for generator-plus-evaluator pairs. Asymmetric: one proposes, one challenges.
These three are different shapes of the same family, not synonyms. Adversarial collaboration is symmetric and both parties have stakes in the outcome. Multi-agent debate is symmetric with a judge. Actor-critic is asymmetric.
This project’s workflow sits closest to adversarial collaboration in spirit — both Claude and the GPT advisor read from the same backbone and argue from the same evidence base toward a shared goal. There is also a streak of actor-critic in execution: Claude proposes the scoped diff, the advisor critiques and approves, the roles are asymmetric inside each artifact’s land cycle. The orchestrator (ASK) acts as the judge in the multi-agent-debate sense — deciding when convergence has been reached and when to stop iterating.
The output you want is not agreement. It is a better answer. Sometimes the agents end in unresolved disagreement and the human arbitrates. Optimizing for consensus would kill the mechanism.
Why this altitude works
Three reasons. Each is more interesting than it first appears.
LLMs work productively on architectural reasoning when they have a real interlocutor — and degrade in monologue. A single agent thinking aloud builds coherence as it extends, which is helpful for execution but harmful for critique. Two agents pushing back on each other can hold each other to a standard neither could hold alone. The advisor is a better critic of Claude’s plan than Claude is, because Claude can no longer disagree with itself once it has invested two synthesis passes in a direction.
The shared backbone makes the dialogue tractable. Without AGENTS.md rules, the agents would re-litigate procedure every conversation. Without the grounding note, they would re-derive intent, audience, and philosophy. Without the repo as durable truth, they would argue from different memories of project state. With all three, the conversation can stay at the architectural altitude where it does real work. Procedural questions get resolved by reference, not by debate.
Fresh threads are cheap because the backbone is external. This is the structural difference between dual-agent dialogue at execution altitude (Model A) and dual-agent dialogue at architecture altitude (this model). At execution altitude, every handoff was friction — the next conversation had to reconstitute context. At architecture altitude, fresh threads load context in seconds because everything load-bearing is outside the threads. Closing a thread when its scope is done costs nothing.
The roles that emerged
Claude is the control surface and the executor. It proposes plans, drafts artifacts, makes exact scoped diffs, commits and merges. It also reads the advisor’s critique seriously and folds it into its own thinking. The single-node operating model means the same thread does proposing and executing, against the rules in AGENTS.md. Where the agents disagree, Claude does not just defer — it argues back when the advisor is wrong, but updates when the advisor is right, and the threshold is calibrated by the grounding note and the repo’s evidence base.
GPT is the advisor. It sits outside any execution thread. It reviews critiques, plans, and exact scoped diffs. It pushes back on framing, sequencing, scope, and precision. It does not have repo-write authority. Its role is structural: produce honest pushback that a thread which has invested in a direction cannot produce against itself.
ASK orchestrates. Pastes the critique back and forth. Decides when to stop iterating. Authorizes commit. Decides when to start a fresh thread. The orchestrator is not in the synthesis loop — neither agent decides for the other; the orchestrator is the one who knows the project’s actual direction and decides when convergence has been reached.
The roles are stable across arcs. The agents do not need to negotiate their roles each time. The backbone carries that.
What it looked like in practice
The most recent architectural arc on this project is the clearest example.
After the SKU-driven Furniture v1 mode operationalized end-to-end, after collection mode operationalized at probe-depth in the same base, after the architecture had survived all four worked-example modes at probe-depth — the repo had accumulated enough evidence that several architectural questions were live again. I asked Claude, in a fresh thread, to read the repo against the grounding note and surface concerns. Eight points. I asked GPT, sitting outside, to do the same independently. Twelve points.
Their reviews converged on the largest gap: the durable spec / orchestration layer the grounding note targets did not yet exist as a portable, citable artifact in the repo. The architecture lived distributed across many decision and findings notes plus the live Airtable base. They diverged on which secondary issues mattered most — sequencing, scoping of mode-independence claims, where the prose-vs-structure boundary belonged, what the curator-override correction had actually proven about how curation should be modeled.
I passed the advisor’s critique to Claude with the prompt fold this alongside your own and make a plan. Claude produced a five-workstream plan. The advisor pushed back: too broad, risks reproducing the ceremony pattern the critique was meant to cut. Collapse to one or two moves. Claude revised. The advisor approved scope but requested precision edits on the architectural artifact’s exit criterion. Claude applied them. The advisor approved.
Then five artifacts landed in sequence, each as its own bounded scoped diff:
a small reading-note correction on a collection-mode findings artifact addressing a skim-reader trap the advisor had specifically called out
a bounded vocabulary precision pass — five carrier-and-discretion distinctions sharpening the load-bearing terms
a bounded aesthetic-layering modeling pass — layer-shape sketch of where aesthetic lives, with inheritance/override behavior characterized as the load-bearing question
the v1 apex definition-layer artifact — synthesis of the prior three passes into one durable artifact at SKU + same-category-collection scope, with three named limitations carried explicitly
a narrow navigation update surfacing the apex artifact in README.md and docs/index.md
Each artifact went through the same cycle. Claude proposed exact scoped diff. The advisor reviewed, often requested several precision edits. Claude applied them. The advisor reviewed the revised diff. Sometimes one more round of micro-edits. Then approval. Then commit, push, PR, merge, branch cleanup.
Across the arc, there were maybe twenty rounds of advisor critique. Most were a few sentences. Some were substantive scope corrections. None re-litigated procedure. None argued about whether to use plan-before-execute, or whether to stop at exact scoped diff before commit, or whether to use squash-merge. Those questions are settled by the rules in AGENTS.md.
The arc landed in a few hours of orchestrated dialogue. The result is a hardened, citable apex artifact the project did not have at the start, plus four supporting artifacts and one navigation surface. Five PRs.
What this is not
This is not Model A. Model A had two agents arguing about execution. This has two agents arguing about architecture. The execution layer is single-node and rule-governed.
This is not isolation. The agents are in active dialogue throughout each arc. The structural shift is not the absence of advisor presence — it is the altitude at which the dialogue happens.
This is not a methodology. It is a workflow that emerged once the backbone hardened. Other projects with different grounding notes and different rules would need to evolve their own version. The pattern is not “do this exact thing”; it is “find the right altitude for adversarial collaboration once execution is no longer the bottleneck.”
This is not the only valid pattern. For projects without a hardened backbone, this would be ceremony. For projects with a backbone but no architectural uncertainty, single-node execution is fine without dual-agent input. The pattern is proportional to the architectural questions live at any moment.
What generalizes
Two observations.
Adversarial collaboration is valuable where dialogue is the right form of scaffolding for the work. LLMs have well-documented structural deficits in executive control — rule maintenance, inhibitory control, cognitive flexibility under context shift — that show up at every layer they do work on. The remedy is the same shape at both layers: external scaffolding that compensates for what the model can’t do internally. But the scaffolding takes different forms. Procedure compresses into rules. Open-ended judgment doesn’t compress that way; it needs dialogue. Routing dual-agent friction to the architectural layer puts it where the scaffolding it provides isn’t expressible as rules.
The backbone is what makes dialogue cheap. Without durable shared context, two agents cannot have a productive conversation about architecture; they will spend most of their time re-aligning. With a hardened grounding note, repo-as-truth, and rules-as-substrate, adversarial collaboration can stay at the architectural altitude where each round is leverage. The investment is in the backbone, not in the conversation.
The first prototype phase produced the rules and the grounding note. Single-node execution became viable once the discipline Model A’s friction had been developing compressed into rules. Adversarial collaboration is what this approach has earned now that those layers are durable.
The dual-agent surface didn’t go away.
It found the right altitude.
/// /// /// ASK
repo https://github.com/apexSolarKiss/asset-pipeline-ASK
prior piece Lessons from the First Prototype Phase
prior piece Why some LLM reasoning failures look structural, not merely immature