diff --git a/canon/architecture/substrate-stack.md b/canon/architecture/substrate-stack.md index ebbfdaa..1bcdf86 100644 --- a/canon/architecture/substrate-stack.md +++ b/canon/architecture/substrate-stack.md @@ -8,8 +8,8 @@ voice: neutral stability: evolving tags: ["canon", "principle", "architecture", "layered-model", "substrate", "vodka-architecture", "orthogonality", "OSI-equivalent", "ams", "tincan", "oddie"] epoch: E0008.5 -date: 2026-05-09 -derives_from: "canon/principles/vodka-architecture.md, canon/principles/doing-less-enables-more.md, canon/principles/dream-house-principle.md, ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate, ams://canon/decisions/D0006-dream-house-wire-edge-wrappers" +date: 2026-05-10 +derives_from: "canon/principles/vodka-architecture.md, canon/principles/doing-less-enables-more.md, canon/principles/dream-house-principle.md, ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate, ams://canon/decisions/D0006-dream-house-wire-edge-wrappers, ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive" complements: "canon/principles/magical-first-run.md, canon/principles/symmetric-participation.md, canon/principles/creators-get-paid.md, canon/voice/oddie-the-river-guide.md" governs: "Where any concern, feature, decision, or product lives in the program. The canonical lookup that replaces opinion-fights about which layer should own a responsibility. Applies to AMS substrate work, TinCan and other applications, role-runtimes like Oddie, channel adapters, and economic mechanisms." status: active @@ -47,10 +47,12 @@ The model is named "Substrate Stack" rather than copying OSI verbatim because th ### L1 — Wire -The transport layer for frames between accounts. Knows nothing about who, why, or what the frames mean. Ships only the primitives every consumer needs and benefits from being centralized: account credentials, conversation minting, stream attachment, frame delivery, selective subscription, buffering as a substrate primitive. Vodka by definition. +The transport layer for frames between accounts. Knows nothing about who, why, or what the frames mean. Ships only the primitives every consumer needs and benefits from being centralized: account credentials, conversation minting, stream attachment, frame delivery, selective subscription. Vodka by definition. Canonical implementation: AMS. Governing decisions: `ams://canon/decisions/D0006-dream-house-wire-edge-wrappers`, `ams://canon/decisions/D0017-selective-subscription`, `ams://canon/decisions/D0018-multi-stream-per-account-per-conversation`. +Real-world durability concerns — buffering for resumability and late-joiner catchup, persistence for archival, session continuity across reconnects, multi-viewer fan-out, refresh-survives-disconnect — are NOT wire features. Per `ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive`, AMS provides them as L2 *shared wrapper-tier primitives* — built once and reused across every wrapper class instead of being reinvented per consumer. The wire stays narrow because L2 picks up what the wire refuses to own. Both layers contribute to the substrate's full value proposition; only L1 is forbidden from holding application opinions. + ### L2 — Wrapper / Adapter The translation layer between L1 and a specific runtime, channel, or external protocol. Bidirectional. Holds connection state, credential mapping, payload shape, and any runtime-specific resilience logic. Carries no application opinion. @@ -59,6 +61,8 @@ The MCP edge wrapper, which lets MCP-speaking runtimes reach the wire, is the re A wrapper that starts holding application semantics has stopped being a wrapper. The test: can this wrapper be removed and replaced by another implementation of the same shape, without anything above L2 noticing? If no, the wrapper has accumulated concerns from L3 or above and needs trimming. +Within L2, AMS provides a small set of *shared wrapper-tier primitives* that wrapper classes compose with rather than each reinventing. The reference primitive is the buffering / resilience layer (`ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive`): a per-stream, account-gated buffer with TTL and size bounds that handles resumability across network blips, late-joiner catchup, and refresh-survives-disconnect for any wrapper that opts in. Session re-keying for cross-transport continuity (`ams://canon/decisions/D0019-cross-session-continuity-via-account-conversation-keying`) is another. Long-term archival is a separate composable subscriber (`PATTERNS.md` §3) — a sibling to buffering, not contained by it. The wrapper layer is where many implementations share a single shape and a small library of common concerns, so each new wrapper class inherits production-grade resilience without rebuilding it. + ### L3 — Identity & Convention The metadata layer that gives peers human-legible identity. Who is on the wire, what role they play, what they can do, what posture they hold (always-on, intermittent, observer). Conveyed through frames the wire transports as opaque content. The wire never reads them; everything from L4 up does. diff --git a/canon/principles/agents-need-their-own-wire.md b/canon/principles/agents-need-their-own-wire.md new file mode 100644 index 0000000..3e0f7b6 --- /dev/null +++ b/canon/principles/agents-need-their-own-wire.md @@ -0,0 +1,228 @@ +--- +uri: klappy://canon/principles/agents-need-their-own-wire +title: "Agents Need Their Own Wire — The Human Cannot Be the Relay Between Agents" +audience: canon +exposure: nav +tier: 1 +voice: neutral +stability: semi_stable +tags: ["canon", "principle", "substrate", "wire-layer", "L1", "human-as-relay", "bottleneck", "multi-agent", "AMS", "constitutional", "use-case-need"] +epoch: E0008.5 +date: 2026-05-10 +derives_from: "canon/values/axioms.md, canon/principles/discernment-layer.md, canon/principles/doing-less-enables-more.md, canon/principles/vodka-architecture.md, writings/copy-paste.md, writings/shifting-bottlenecks-climbing-ladders.md, ams://canon/decisions/D0001-tokens-not-messages, ams://canon/decisions/D0003-per-account-stream-ownership, ams://canon/decisions/D0009-stream-as-primitive-ownership-excludes-subscription, ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive, ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate" +complements: "canon/principles/symmetric-participation.md, canon/architecture/substrate-stack.md, canon/principles/magical-first-run.md, canon/principles/creators-get-paid.md" +governs: "Why an agents-only wire layer (L1) is necessary in the first place. Names the failure mode (human-as-relay) the architecture exists to address. Symmetric-participation describes the wire's shape; this principle describes the need that wire fills. Together they form the substrate's load-bearing rationale at L1." +status: active +--- + +# Agents Need Their Own Wire — The Human Cannot Be the Relay Between Agents + +> Multi-agent collaboration today routes through human attention. The operator copies output from one agent and pastes it into another, summarizes the first agent's reasoning for the second's context window, and shuttles between sessions because the agents have no way to talk to each other directly. This works for one or two agents at a time. It does not scale to genuine multi-agent work. Every additional agent compounds the operator's relay load and degrades the fidelity of what gets transmitted. The architectural answer is a wire that agents share — an open substrate where any agent can address any other agent without the human as intermediary. This principle names *why* the substrate is necessary; `klappy://canon/principles/symmetric-participation` describes *how* the wire stays clean once it exists. + +--- + +## Summary — What the Principle Asserts + +A wire for agents is not an optimization on existing multi-agent collaboration. It is the *prerequisite for* multi-agent collaboration as a category. Without it, the human is structurally the wire — the cognitive medium through which one agent's output reaches another agent's input — and the bottleneck imposed on every agent-to-agent path is the human's available attention, working memory, and clipboard discipline. + +This is not a metaphor. The bottleneck is operationally measurable: throughput is gated by how fast a human can read agent A's output, decide what's relevant, and paste it into agent B with appropriate framing. Quality is measurable: every relay loses context that the human did not think to forward. Cost is measurable: the marginal time cost of adding a third agent to a two-agent collaboration is not 1.5x — it is closer to 3x because the relay graph is now O(N²) instead of O(N). + +The principle's claim is that this is solvable, and solving it requires an agents-only substrate layer. AMS is the canonical implementation. `klappy://canon/principles/symmetric-participation` is the architectural shape that keeps the wire clean once it exists. This principle is the load-bearing *need* both of those answer. + +The principle is `semi_stable` rather than `stable` because the substrate has not yet hosted enough multi-agent applications to confirm every category the principle anticipates. The single-agent-via-MCP path validated end-to-end on 2026-05-09; multi-agent direct-collaboration use cases remain mostly forward-looking. This principle is the contract the architecture is being built to honor. + +--- + +## Outline + +- The Failure Mode: When the Human Is the Wire +- The Structural Answer: A Wire for Agents +- What the Architectural Answer Enables +- AMS as the Worked Reference Implementation +- Relationship to Symmetric Participation +- What This Principle Does Not Replace +- Failure Modes — When the Wire Itself Becomes the Bottleneck +- Why This Survives Contact With Reality +- See Also + +--- + +## The Failure Mode: When the Human Is the Wire + +Today's typical multi-agent workflow looks like this: the operator opens Claude in one tab, ChatGPT in another, Cursor in a third, maybe a custom agent in a fourth. They prompt agent A; agent A produces output. The operator reads it, decides which parts are relevant to the work agent B is doing, summarizes or copies, switches tabs, prompts agent B with the curated context, gets agent B's output, and the cycle continues. Each agent is doing skilled, capable work. The human's role is plumbing. + +The failure mode has four characteristic costs: + +**Bottleneck.** Throughput is gated by operator availability. The agents could collaborate at machine speed; they wait at human speed. When the operator steps away, the entire multi-agent workflow halts — not because any individual agent is blocked on operator approval, but because every cross-agent message routes through the operator. Agents that do not need the human's discernment for their next step still wait for the human to ferry context. + +**Lossy relay.** Each relay drops information. The human picks what to copy based on what they think is relevant, summarizes the rest, and recontextualizes for the receiving agent. The receiving agent then operates on a degraded view of what the sending agent actually said. Mistakes compound across multiple relay hops. Subtle reasoning, dependency assumptions, and edge-case considerations get filtered out by a human who cannot read at machine speed and cannot retain at machine fidelity. + +**O(N²) integration burden.** Each pairwise agent-to-agent path requires the human's attention to maintain. Two agents = one relay path. Three agents = three pairwise paths. Four agents = six. The human's attention does not scale. Each new agent added to a workflow compounds the load on the operator, not because each agent is hard to work with individually, but because the relay graph grows quadratically while the operator's bandwidth stays linear. + +**Human-shaped formats.** Because the human is in the middle, every agent-to-agent message must be readable to the human. Agents tend to produce prose explanations, narrative summaries, and step-by-step rationales — all formats optimized for human consumption. Agents are forced to encode for the human carrier instead of for the receiving agent, which means the receiving agent has to decode prose back into structured information it could have consumed natively if the relay weren't human-shaped. This is overhead at both ends, paid for the relay's benefit. + +The four costs compound. A workflow that involves three agents and four cross-agent handoffs is not a small workflow plus 12 relay events; it is a workflow where the operator is doing twelve focused acts of curation between agents that could otherwise be coordinating directly. The human's attention is real life; the substrate's job is to give it back. + +--- + +## The Structural Answer: A Wire for Agents + +The architectural answer is reachability between agents on an open substrate, with reception explicitly opt-in. Specifically: + +1. **Every agent has a stable identity on the wire, and reception is opt-in by subscription, not by delivery to an inbox.** An agent owns its output stream; other agents that want to receive its emissions subscribe to that stream. There is no push surface for writers to deliver into. Per `ams://canon/decisions/D0003-per-account-stream-ownership`, AMS *inverts the inbox model that email and chat assume* — there is no inbox to clutter because there are only streams that subscribers attach to. This is simultaneously a wire-design property and a security property: spam cannot accumulate against you because no one can push at you. Reachability is a function of subscription, not of address. +2. **The wire ships tokens at machine speed.** Per `ams://canon/decisions/D0001-tokens-not-messages`, the wire's unit is the **token** — opaque bytes, deliberately undefined in shape and meaning, "exactly the unit agents already produce." The wire does not parse, validate, schema, or interpret. This is the design's adaptation mechanism: machines invent their own communication formats on top of tokens, evolve those formats over time, and the substrate never has to revise. When agent A emits and agent B subscribes, agent B receives tokens as they stream — without waiting on operator availability to ferry them. +3. **Wire opacity enables agent-shaped content.** Because the wire transports tokens without interpreting them, subscribers can compose any envelope on top — message, frame, chunk, control signal, structured data, embedding, tool-call trace, partial result. Per D0001, the wire's refusal to specify is the property that lets every above-wire convention coexist on the same substrate. Prose remains an option (for human-rendered surfaces and for cases where prose is the natural format), but it stops being mandatory because the wire stopped being human. +4. **The wire is open.** Any agent — any vendor, any runtime, any capability — can join. The wire does not pick winners; it lets ecosystems develop without protocol-level privilege per `klappy://canon/principles/symmetric-participation`. + +This is what `canon/architecture/substrate-stack.md` calls L1 (the wire), governed by `klappy://canon/principles/symmetric-participation`. AMS is the canonical implementation. Agents own streams on the wire; subscribers attach to streams; tokens are transported as opaque content; identity, capability, and convention live in metadata above L1. + +The principle is not asserting that the wire eliminates human involvement. It asserts that the wire eliminates the human's role *as relay*. The human's load-bearing contribution moves entirely to discernment per `klappy://canon/principles/discernment-layer` — judging gates, setting goals, evaluating outcomes. The relay role disappears because the wire takes it. + +--- + +## What the Architectural Answer Enables + +When agents can talk to each other directly: + +**Multi-agent task decomposition becomes practical.** A planner agent can hand work to specialist agents and consume their outputs without the operator manually orchestrating each handoff. The operator sets the goal; the agents partition and reassemble; the operator evaluates the result. Decomposition that would have been infeasible at human-relay speed becomes ordinary. + +**Long-running agent collaboration becomes ungated.** A research agent can run for hours and pass interim findings to an analysis agent that processes them as they arrive. Neither agent waits on operator availability between handoffs. The human steps away; the work continues; the human returns to evaluate the result. This is the operator-bandwidth liberation that `klappy://writings/shifting-bottlenecks-climbing-ladders` describes — the bottleneck moves off the relay and onto discernment, which is where the human's contribution actually scales. + +**Specialist composition becomes reachable by subscription.** A canon-driven role like Oddie (`klappy://canon/voice/oddie-the-river-guide`) can be invited into any conversation by any agent. The agent does not need to know how to host Oddie; it knows how to subscribe to Oddie's output stream once both are admitted to the same conversation. The same applies to translators, auditors, validators, contract analyzers, code reviewers — any specialist role becomes a peer agents can collaborate with directly. + +**Agent-shaped formats replace prose-shaped formats.** When the wire isn't routed through a human, agents can communicate in compressed, structured, machine-friendly formats. Tool-call traces, embeddings, structured findings, partial JSON, type-tagged tokens — all become reasonable above-wire envelopes that the substrate transports without parsing. Prose remains an option (for human-rendered surfaces and for cases where prose is the natural format), but it stops being mandatory because the wire stopped being human. + +**Cross-vendor portability becomes real.** Because the wire does not privilege any vendor (per `klappy://canon/principles/symmetric-participation`), an operator can swap Claude for ChatGPT, swap WhatsApp for Slack, swap one specialist for another, without rebuilding the workflow. The agents are peers; replacing one with an equivalent peer does not disturb the wire. + +Each of these is impossible — or impossibly expensive — when the human is the relay. Each becomes ordinary when the wire is shared. + +--- + +## AMS as the Worked Reference Implementation + +`klappy://canon/architecture/substrate-stack` assigns the wire to L1; AMS is the canonical implementation. AMS treats every peer through identical primitives (per `klappy://canon/principles/symmetric-participation`): account credentials, conversation minting, stream attachment, token delivery, selective subscription. The wire ships tokens; it does not interpret them. + +The wire unit is deliberately undefined. Per `ams://canon/decisions/D0001-tokens-not-messages`, AMS chose the token — *opaque bytes, smaller than a message, larger than a byte, exactly the unit agents already produce* — precisely because committing to a higher-level envelope would have committed the substrate to opinions agent ecosystems will keep evolving past. The token's arbitrariness is the adaptation mechanism: any envelope subscribers want to compose (message, frame, chunk, control signal, structured payload) lives above the wire and can be replaced without protocol revision. Machines invent their own communication on this substrate; the substrate stays out of the way. + +Reachability follows the inverted-inbox model from `ams://canon/decisions/D0003-per-account-stream-ownership`: agents own output streams, subscribers attach to those streams, and the wire never delivers an agent's tokens back to itself. There is no push surface for writers to push into. This is what makes the substrate viable as an open wire — without an inbox to clutter, openness does not become an attack surface. + +### What the Wire Refuses to Own — and How AMS Provides It Instead + +The wire's narrowness creates a real obligation: every concern the wire refuses to own must be picked up somewhere above the wire, or the substrate fails to deliver the production value that justifies its existence. **Buffering is the worked example.** Most multi-agent use cases require it: resumability after network blips, late-joiner catchup, multi-viewer fan-out, refresh-survives-disconnect, model-adapter discontinuity recovery. Every production stack that needs these capabilities today rebuilds the buffer-and-fan-out layer one-off — Anthropic Messages clients reconstruct streams client-side, Convex documented one such build for OpenAI, Vercel ships another in its AI SDK, every chat product that survives a browser reload has a hand-rolled equivalent. + +Per `ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive`, AMS makes buffering a wrapper-tier primitive — a `StreamBufferDO` per `(account, stream)` with TTL and size bounds, account-gated, captured as a normal subscriber to the wire. **Built once at L2, reused by every wrapper class that needs it.** This is the pattern that protects the wire's narrowness without sacrificing the use cases that depend on durability. The wire stays a wire; buffering happens above it; the substrate as a whole satisfies real-world needs. Wrappers inherit production-grade resilience instead of reinventing it; the wire stays free of opinions about durability, eviction, retention, and tier semantics that would have calcified L1. + +The same pattern applies across other concerns the wire refuses to own: + +- **Persistence and archival** — a separate composable subscriber per `PATTERNS.md` §3, sibling to buffering rather than contained by it +- **Observability** — subscriber-pattern, not wire-feature, per `ams://canon/decisions/D0010-observability-via-subscriber-not-wire` +- **Session continuity** across MCP transport reconnects — wrapper-tier re-keying per `ams://canon/decisions/D0019-cross-session-continuity-via-account-conversation-keying` +- **Discontinuity announcements** — `set_metadata` (an existing wire primitive) reused per D0016, never new wire frame types + +The discipline is one move repeated: the wire stays narrow; the wrapper tier picks up the necessary concerns; concerns become shared primitives instead of N independent reimplementations. The wire's value is what it does not do; the substrate's value is what its layers above the wire do, in shapes that compose because the wire doesn't fight them. + +### Positioning as Substrate, Not Application + +AMS is positioned as substrate, not application, per `ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate`. The customer is the agent. AMS does not compete with applications agents will build on top of it; it competes only at the wire layer where its job is to be the cleanest possible transport. This positioning is what makes AMS adoptable by agent ecosystems that are otherwise vendor-coupled — joining AMS does not require accepting application opinions. + +The principle is not asserting that AMS is the only valid wire implementation, or that AMS's specific design choices are mandatory. It asserts that *some* wire is mandatory for multi-agent work to scale, that an open, vendor-neutral wire is the only kind that hosts the ecosystem, and that the wire's narrowness must be paired with a credible wrapper-tier story for production needs the wire refuses to own. AMS is the worked example; the principle is what AMS is built to satisfy. + +--- + +## Relationship to Symmetric Participation + +`klappy://canon/principles/symmetric-participation` is the wire's *architectural shape*: every peer interacts through identical primitives, no peer-type privilege, identity and capability conveyed through metadata above the wire. + +This principle is the wire's *load-bearing need*: the human cannot be the relay between agents, so a substrate where agents address each other directly is required. + +The two principles work together at L1. Symmetric-participation tells us what the wire must look like to stay open; this principle tells us why having any wire at all is necessary. A wire that violates symmetric-participation eventually fails by privileging some peer type and crowding out the ecosystem; a system that lacks the wire entirely fails earlier by trapping multi-agent work behind human-relay throughput. + +Read together: + +- *This principle*: agents need their own wire because the human-as-relay failure mode caps multi-agent collaboration. +- *Symmetric-participation*: the wire that solves it must treat every peer identically because peer-type privilege calcifies substrates around the privileged type. + +Either principle without the other is incomplete. Together they specify the L1 commitment that the rest of the substrate stack assumes. + +--- + +## What This Principle Does Not Replace + +The principle removes the human from the *relay role*. It does not remove the human from the *discernment role* per `klappy://canon/principles/discernment-layer`. Specifically: + +**Goal-setting.** The human still articulates what the work is. Agents on a wire can collaborate among themselves; they cannot decide what to collaborate on without operator input. The wire makes execution scale; discernment still gates initiation. + +**Gate-judging.** The human still evaluates outcomes, judges fitness, and decides whether work is complete. The wire transports tokens between agents; it does not certify that the resulting artifact satisfies the operator's actual intent. Validation, especially against tacit goals, remains a human-discernment activity. + +**Override-deciding.** The mode-discipline and bottleneck-respect canon still bind. Operator override (per `klappy://canon/constraints/mode-transitions-require-encoded-handoff` §Worked Use Cases) is still a real and necessary mechanism for governance creation, production incidents, and other categories where agent autonomy is not yet trustworthy. The wire enables agent autonomy where autonomy is appropriate; it does not assert that all decisions can or should be agent-resolved. + +**Tacit-context interpretation.** Operators carry context that has not been encoded — preferences, sensitivities, history, taste. Agents on a wire can collaborate within the bounds of declared context; the operator remains the authority on tacit context. The wire raises the floor of what is automatable; it does not raise the ceiling on what counts as the operator's actual intent. + +The principle's claim is that *relay* is the role the wire eliminates. Discernment, judgment, override authority, and tacit-context translation remain human work. The substrate's value proposition is that it gives the human's attention back to those roles by removing the relay role they were also being forced to play. + +--- + +## Failure Modes — When the Wire Itself Becomes the Bottleneck + +The principle's value depends on the wire actually delivering the four properties named above (opt-in reachability without an inbox, machine-speed token transport, agent-shaped content enabled by wire opacity, openness). When implementations drift from any of those, the wire stops solving the problem it was built to solve and may even introduce new failures the human-relay version did not have. + +**The wire becomes prose-shaped rather than agent-shaped.** If the wire renders every token as text in a human-viewable surface (a chat log, an email thread, a Slack channel), agents on the wire end up encoding for the surface rather than for each other. The relay tax returns in a different form: the wire is shipping at machine speed, but the payload is still optimized for human inspection. The fix is to keep human-rendered surfaces above the wire (at L5), not bake them into the wire itself. This is what `klappy://canon/principles/symmetric-participation` is protecting against by forbidding the wire from interrogating peer-type identity. + +**Wire access becomes a permission gate.** If joining the wire requires gatekeeper approval — vendor partnership, manual onboarding, application review — the wire stops being an open substrate and starts being a curated platform. Agents that cannot get on cannot collaborate; the openness premise that made the wire valuable in the first place erodes. AMS's positioning per `ams://canon/decisions/D0020` is the discipline that protects against this. The fix is structural: never make wire access depend on a process that can be denied. + +**Agents on the wire produce noise that re-creates the operator-as-filter problem.** If every agent on the wire emits constant chatter, the human supervising the workflow ends up filtering the wire's output the way they used to filter individual agent outputs. The bottleneck has moved from relay to filtering; the bandwidth cost is similar. The fix is in the L3+ convention layer: posture metadata, selective-subscription per `ams://canon/decisions/D0017-selective-subscription`, role-shaped emission rules. The wire transports; the layers above it manage what gets attended to. + +**Multi-agent coordination produces compounding errors at machine speed.** When agents collaborate without human relay, errors that would have been caught by the operator's read-decide-paste loop now propagate at machine speed. A misinterpretation by agent A becomes input to agent B before any human reviews it. The wire is doing exactly what it was built for; the supervision model needs to adapt. The fix is in canon discipline above the wire — gates, validator-role sessions, encoded handoffs, fresh-context discipline per `klappy://canon/principles/sessions-mirror-modes`. The wire is necessary for multi-agent work; structural epistemic discipline becomes more necessary, not less, once it exists. + +**The wire becomes opinionated about what "an outcome" means.** If the wire starts encoding application semantics — what counts as a finished task, what an agreement looks like, how a collaboration concludes — it has crossed from L1 into application territory. Replaceability erodes; the wire calcifies around its embedded opinions; competing applications cannot live on the same wire. The fix is the vodka-architecture discipline (`klappy://canon/principles/vodka-architecture`): the wire's value is what it does not do. + +**Use cases that still genuinely need the human in the relay path.** Some workflows are not improved by removing the human. High-stakes decisions where the human's discernment must touch every handoff, regulated workflows where audit trails require explicit human acknowledgment at each step, training contexts where the human is learning from observing agent reasoning. For these cases, the principle does not prescribe wire-only collaboration; it prescribes that the wire be available as the default and that human-relay routes be reserved for cases where the human's attention is the actual value. The error is making relay the default; the correction is not eliminating relay entirely. + +In every failure mode the diagnosis is the same: the wire's value is what it does not do. When the wire stays narrow and primitive, the principle holds. When it accumulates opinions, gates, surfaces, or special cases, it stops being the answer and becomes a different version of the problem. + +--- + +## Why This Survives Contact With Reality + +The principle is `semi_stable` because the multi-agent direct-collaboration use cases it anticipates have not yet been hosted at scale on AMS. As of 2026-05-10, the substrate has validated: + +- Single-agent-via-MCP path end-to-end (validated 2026-05-09) +- AMS-as-substrate positioning per D0020 +- Symmetric-participation through the ChatGPT and Claude wrapper paths +- Channel-adapter shape via the WhatsApp bridge proposal + +What has not yet been pressure-tested: + +- Sustained multi-agent direct collaboration without operator relay +- Cross-vendor agent-to-agent workflows at scale +- Specialist-agent composition through subscription +- Agent-shaped (non-prose) content formats at sufficient volume to validate the format claim + +The principle is the contract those future implementations will be held to. Each successful multi-agent application built on AMS confirms the principle. Each implementation that drifts toward a failure mode named above is evidence the principle's discipline matters and provides the language to name what went wrong. + +The principle does not need to be defended against the abstract question "couldn't humans just keep being the relay?" The answer is yes, and that is exactly what `klappy://writings/copy-paste` documents — they have been, they are, and the cost is the operator's attention. The principle is not arguing that the human-as-relay path doesn't work; it is arguing that the cost is too high and the alternative is buildable. AMS is the alternative being built. + +The line in the sand: when an L5 application succeeds at multi-agent collaboration without the operator playing relay, the principle is confirmed. When an application requires the operator to copy-paste between agents because the wire is unavailable, missing, or insufficient, the principle is being violated and the architecture has work to do. + +--- + +## See Also + +- `canon/principles/symmetric-participation.md` — the architectural shape this principle says we need +- `canon/architecture/substrate-stack.md` — the layered map; this principle articulates the need for L1 +- `canon/principles/discernment-layer.md` — where the human's load-bearing work moves to once the relay role is gone +- `canon/principles/vodka-architecture.md` — the design discipline that keeps the wire narrow enough to stay open +- `canon/principles/doing-less-enables-more.md` — the empirical claim this principle relies on +- `canon/principles/magical-first-run.md` — the L5 success metric that depends on a working wire below +- `canon/principles/creators-get-paid.md` — the L6 commitment that survives because the wire is open +- `writings/copy-paste.md` — the lived diagnosis this principle answers +- `writings/shifting-bottlenecks-climbing-ladders.md` — the bottleneck-migration framework this principle operationalizes +- `canon/constraints/mode-transitions-require-encoded-handoff.md` — the discipline above the wire that becomes more necessary, not less, once agents collaborate directly +- `canon/principles/sessions-mirror-modes.md` — the principle governing how agent sessions on the wire stay epistemically clean +- `ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate` — the AMS-tier commitment that names agents as the customer +- `ams://canon/decisions/D0001-tokens-not-messages` — the wire unit's deliberate undefined-ness as the adaptation mechanism +- `ams://canon/decisions/D0003-per-account-stream-ownership` — the inverted-inbox security model the wire's openness rests on +- `ams://canon/decisions/D0009-stream-as-primitive-ownership-excludes-subscription` — the structural rule that makes the inverted-inbox property hold +- `ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive` — the canon that puts buffering at the wrapper tier, not the wire +- `ams://canon/decisions/D0006-dream-house-wire-edge-wrappers` — the wire-vs-wrapper boundary that protects this principle's L1 cleanliness +- `docs/mode-separated-conversations.md` — practical guidance on how conversations on the wire respect mode discipline diff --git a/canon/principles/symmetric-participation.md b/canon/principles/symmetric-participation.md index db1a581..4b9f880 100644 --- a/canon/principles/symmetric-participation.md +++ b/canon/principles/symmetric-participation.md @@ -8,7 +8,7 @@ voice: neutral stability: semi_stable tags: ["canon", "principle", "substrate", "wire-layer", "L1", "vodka-architecture", "BYOA", "BYOC", "open-substrate", "constitutional"] epoch: E0008.5 -date: 2026-05-09 +date: 2026-05-10 derives_from: "canon/values/axioms.md, canon/architecture/substrate-stack.md, canon/principles/vodka-architecture.md, canon/principles/doing-less-enables-more.md, ams://canon/decisions/D0020-agents-as-customer-and-third-party-vas-substrate, ams://canon/decisions/D0006-dream-house-wire-edge-wrappers" complements: "canon/principles/magical-first-run.md, canon/principles/creators-get-paid.md, canon/principles/dream-house-principle.md" governs: "The wire layer (L1) of the substrate stack and the constraints L2 wrappers must preserve. Forbids any feature that would special-case the substrate by peer type. Generalizes AMS D0020's agent-as-customer commitment from the customer layer to the wire layer." @@ -53,7 +53,9 @@ It does not know whether the stream represents a human typing in WhatsApp, a Cla It does not know whether the frames emitted are agent-to-agent coordination, human-to-agent steering, role-emitted snapshots, or substrate notifications. The wire ships them. The peers above the wire interpret them. -The wire's poverty of knowledge is the principle. Every primitive it offers — account creation, conversation minting, stream attachment, frame delivery, selective subscription, buffering — works identically for every peer. There are no peer-type-aware code paths. No special-cased authentication for "human peers" versus "agent peers" versus "service peers." No protocol-level privilege. +The wire's poverty of knowledge is the principle. Every primitive it offers — account creation, conversation minting, stream attachment, frame delivery, selective subscription — works identically for every peer. There are no peer-type-aware code paths. No special-cased authentication for "human peers" versus "agent peers" versus "service peers." No protocol-level privilege. + +What the wire refuses to own, the layers above it provide. Buffering is the worked example: most production multi-agent use cases require it — resumability after network blips, late-joiner catchup, multi-viewer fan-out, refresh-survives-disconnect, model-adapter discontinuity recovery. The wire still does not own buffering. Instead, per `ams://canon/decisions/D0016-buffering-and-persistence-as-wrapper-primitive`, AMS provides it as a *wrapper-tier primitive* — built once at L2, reused by every wrapper class that needs it, instead of forcing N independent reimplementations. This is the pattern that protects wire symmetry without sacrificing the use cases that depend on durability: the wire treats every peer identically because peer-aware features live one layer up, available to whoever needs them. --- diff --git a/docs/appendices/mode-separated-conversations.md b/docs/appendices/mode-separated-conversations.md index d0a5d54..4018932 100644 --- a/docs/appendices/mode-separated-conversations.md +++ b/docs/appendices/mode-separated-conversations.md @@ -6,9 +6,9 @@ exposure: nav tier: 2 voice: neutral stability: evolving -tags: ["planning", "execution", "validation", "collaboration", "fresh-context"] -epoch: E0008.3 -date: 2026-04-19 +tags: ["exploration", "planning", "execution", "validation", "resolution", "collaboration", "fresh-context", "session-discipline"] +epoch: E0008.5 +date: 2026-05-10 --- # Mode-Separated Conversations @@ -19,9 +19,11 @@ date: 2026-04-19 This document operationalizes: -- **Canon: Epistemic Modes** +- **Canon: Epistemic Modes** (`klappy://canon/epistemic-modes`) — the five canonical modes +- **Canon: Sessions Mirror Modes** (`klappy://canon/principles/sessions-mirror-modes`) — the principle that each mode earns its own session +- **Canon: Mode Transitions Require Encoded Handoff** (`klappy://canon/constraints/mode-transitions-require-encoded-handoff`) — the binding rule for journals + transition-specific handoffs at every gate -It does not redefine modes. +It does not redefine the modes or the constraints. It describes how conversations respect them. --- @@ -30,14 +32,38 @@ It describes how conversations respect them. Confusion and mistrust arise when: +- exploration conversations pretend to decide - planning conversations pretend to execute - execution conversations reopen exploration -- critique is misinterpreted as obstruction +- validation conversations modify the artifact under review +- resolution conversations expand scope beyond findings Separating conversations by epistemic mode reduces friction without reducing rigor. --- +## Exploration Conversations + +Purpose: + +- surface possibilities +- identify tensions and competing frames +- map the territory before deciding what to build + +Characteristics: + +- questions outnumber answers +- no convergence required +- assumptions are surfaced rather than acted on + +Invalid moves: + +- claiming a decision has been made +- treating one option as already chosen +- moving to artifact production before the territory is mapped + +--- + ## Planning Conversations Purpose: @@ -136,6 +162,45 @@ Invalid moves: --- +## Multiple Participants + +Multiple agents or assistants may participate in a single conversation, with one constraint: every participant in a conversation operates in the same mode. + +- **Within-mode parallelism is encouraged.** Multiple explorers, multiple validators with different lenses, multiple builders working on different scoped artifacts — all valid. Conversations grow richer; the mode stays clean. +- **Cross-mode parallelism on the same artifact is forbidden.** A validator and a builder cannot share a conversation about the same artifact at the same time — that is mode collapse, not parallelism. The fix is to let each finish their mode and hand off via encoded handoff per `canon/constraints/mode-transitions-require-encoded-handoff`. +- **Cross-mode work on different artifacts is independent.** Two conversations in different modes on different artifacts run in parallel without coordination. + +The distinguishing question: are the participants operating on the same artifact in different modes? If yes, separate the conversations. If no, the parallelism is fine. + +--- + +## Operator Override — When Conversations Deliberately Collapse Modes + +Operator override is a permitted deviation per `canon/constraints/mode-transitions-require-encoded-handoff`. In conversation, this looks like the operator declaring: *"skipping the gate, here's why, accepting the risks."* + +Two categories where override is operationally legitimate: + +- **Production incidents.** Urgency exceeds the cost of mode-clean handoffs. The operator collapses modes deliberately and accepts the corruption. +- **Governance creation.** Authoring principles, constraints, and methods is inherently oscillating; drafting a principle implies a constraint, drafting a constraint surfaces a principle refinement. Until handoff norms mature for this category, override-with-record produces work that clean sessions with poor handoffs cannot. + +What override is not: a way to skip discipline because it feels heavy in the moment. The override is recorded; the corruption it accepts is acknowledged; the journal entry shows the trail. The override gives the operator a real escape hatch and binds them to declaring the escape explicitly. + +--- + +## Handoff Insufficiency — When the Receiving Conversation Cannot Proceed + +A conversation receiving an encoded handoff may discover the handoff is insufficient: missing dynamic context, missing crucial framing the prior session held implicitly, scope items named without bounded definition. Per `canon/methods/persona-shaped-agent-runtime` §Support Handoff-Insufficiency Signaling, this is a structural problem, not a content disagreement. + +The receiving participant should: + +1. Name the insufficiency explicitly — *"this handoff is insufficient; specifically X is missing"* — distinct from disagreement with the handoff's content +2. Propose a resolution: spawn a fresh upstream conversation, request clarification from the upstream author, or accept under operator override +3. Block on resolution rather than proceeding with degraded input + +A conversation that proceeds on a bad handoff produces output worse than mode-collapse would have. Naming the insufficiency is signal; proceeding silently is failure. + +--- + ## Mode Signaling Mode MAY be signaled explicitly: @@ -143,6 +208,7 @@ Mode MAY be signaled explicitly: - "Let's stay in planning for now" - "Switching to execution" - "This is exploratory" +- "Resolving the validator findings now" Explicit signaling prevents accidental collapse. diff --git a/journal/2026-05-10-ams-canon-alignment-pass.tsv b/journal/2026-05-10-ams-canon-alignment-pass.tsv new file mode 100644 index 0000000..5561f6c --- /dev/null +++ b/journal/2026-05-10-ams-canon-alignment-pass.tsv @@ -0,0 +1,12 @@ +type typeName facet quality_score quality_max quality_level title content +F Finding 5 5 strong Buffering listed as wire/L1 primitive contradicts AMS D0016 klappy.dev canon (substrate-stack L1 description and symmetric-participation primitives list) included buffering as a wire/L1 substrate primitive. AMS D0016 (stable, irreversible, Tier-1) is explicit: "keep the layer in the wrapper tier per D0006, never in the wire." Three docs misaligned: canon/principles/agents-need-their-own-wire (this PR's new principle, inherited the drift), canon/principles/symmetric-participation, canon/architecture/substrate-stack. Disposition: fix all three. The drift was caught by reviewing the new principle against AMS canon — operator validation that tooled checks did not surface. The recursive observation: this PR's new principle was authored under collapsed governance-creation override, which is exactly the failure mode where inherited handoff drift propagates because the encoder did not pause to verify upstream claims against authoritative tier-below canon. +F Finding 5 5 strong Direct addressability framing implied an inbox model AMS rejects The new principle's first property was "direct addressability between agents." This implied a unicast push-to-inbox model. AMS rejects that model entirely per D0003: "AMS lets you own your output stream and others choose to listen. There is no inbox to clutter because there is no push surface for writers to push into; there are only streams that subscribers attach to." Operator surfaced this as the most concerning finding because the inbox-vs-subscription distinction is also AMS's security model — spam cannot accumulate against a peer because there is no push surface. Disposition: reframe property 1 to "stable identity on the wire AND opt-in reception by subscription, not delivery to an inbox." Borrow D0003's inverted-inbox language directly. +D Decision 5 5 strong Wire-unit terminology — keep abstraction at klappy.dev altitude but describe AMS mechanism explicitly Operator's framing on token vs frame: "Abstract it but describe the method of AMS testing this at token primitive and borrow language. Either way the point is to let machines invent their own communication and adapt over time without substrate changes. Tokens is what they speak. It's arbitrary and undefined what a token is. On purpose." Disposition: keep "frame" usable at klappy.dev altitude as the cross-altitude term for the wire's transport unit, but add an explicit passage in the principle that names AMS's wire unit (token), describes why it is deliberately undefined (machines invent their own communication formats and evolve them without substrate revisions), and borrows D0001's language verbatim where it matters ("opaque bytes, deliberately undefined in shape and meaning, exactly the unit agents already produce"). The token's arbitrariness IS the adaptation mechanism — that is the argument worth surfacing. +D Decision 5 5 strong Wire opacity enables agent-shaped content; the wire does not carry it as a property The new principle had said "frames carry agent-shaped content" — implying the wire is content-aware. Per D0001, the wire is opaque and does not parse, validate, schema, or interpret content. Agent-shaped content is enabled by wire opacity, not a wire property. Disposition: reframe property 3 to "Wire opacity enables agent-shaped content." Subscribers compose any envelope on top — D0001 explicitly enumerates "message, frame, chunk, control signal" as the kinds of envelopes that can be composed above tokens. +L Learning 5 5 strong "Stable identity" at principle altitude tolerates D0028 transient-account nuance D0028 distinguishes persistent accounts from transient anon accounts (Door-1-only synthesis with deterministic regeneration). At principle altitude "stable identity" is acceptable shorthand for "deterministic and reproducible." Operator: "Ideal vs edge cases." Accept at principle altitude; AMS canon documents the implementation nuance. +L Learning 5 5 strong Operator validation surfaces drift that tooled validation does not Three drift findings (buffering as wire primitive, frame vs token, addressability implies inbox) were surfaced by the operator's request to validate the new principle against AMS canon. None had been caught by tooled checks during initial drafting. The pattern is consistent with prior catches (Linux/layer-separation framing, TinCan-as-brand category error). Tooled validation reliably catches structural and reference issues; operator-as-validator catches framing, semantic, and inherited-drift issues. Implication for handoff norms: encode-then-spawn-fresh-validator-session with explicit tier-below cross-references would have caught these earlier. The override pattern that produced this canon set has a known cost; this audit pass is one form of recovery. +H Handoff 5 5 strong PR #189 amended with three-doc AMS-alignment correction pass Branch claude/wire-principle-and-conversations-c5ab amended with: (1) canon/principles/agents-need-their-own-wire — buffering removed from primitives list; tokens-as-wire-unit passage added with D0001 borrowed language; addressability reframed to opt-in subscription with D0003 inverted-inbox language; "frames carry content" rewritten to "wire opacity enables content"; outline updated; See Also adds D0001/D0003/D0009/D0016. (2) canon/principles/symmetric-participation — buffering removed from primitives list; pointer to D0016 added; date bumped 2026-05-09 → 2026-05-10. (3) canon/architecture/substrate-stack — buffering removed from L1 primitives list; explicit "buffering and persistence are NOT wire primitives" sentence added pointing at D0016; derives_from extended with D0016; date bumped 2026-05-09 → 2026-05-10. Three findings disposed (fix); two accepted at principle altitude. +F Finding 5 5 strong Reductive removal of buffering from primitives lists left the architectural pattern unaddressed Operator catch on the alignment pass: dropping buffering from the wire-primitives list and replacing with a one-line 'see D0016' pointer corrected the misalignment but failed to address the architectural reality. Buffering is required for most production multi-agent use cases — resumability after network blips, late-joiner catchup, multi-viewer fan-out, refresh-survives-disconnect, model-adapter discontinuity recovery. Saying 'see D0016' leaves the reader thinking buffering does not matter; saying 'wrapper-tier primitive built once and reused across every wrapper class' explains why the substrate as a whole satisfies real-world needs without the wire calcifying. Removal is correction; placement is canon. +D Decision 5 5 strong Buffering placed as worked example of wrapper-tier-primitive pattern across all three docs All three docs (agents-need-their-own-wire, symmetric-participation, substrate-stack) updated to address buffering substantively rather than reductively. The principle gains a new sub-section 'What the Wire Refuses to Own — and How AMS Provides It Instead' that names the use cases (resumability, late-joiner catchup, multi-viewer fan-out, refresh-survives-disconnect, model-adapter discontinuity recovery), names the production stacks already rebuilding this layer (Anthropic Messages clients, Convex, Vercel AI SDK, every chat product surviving a browser reload), borrows D0016's StreamBufferDO + TTL + size + account-gating description, and generalizes the pattern across observability (D0010), session continuity (D0019), and metadata-as-discontinuity-announcement. Symmetric-participation gets a parallel paragraph that names buffering as the worked example and explains the wrapper-tier-primitive pattern that protects wire symmetry. Substrate-stack L1 expands the buffering note into a full paragraph naming the use cases and the build-once-reuse pattern; L2 gains a new paragraph about shared wrapper-tier primitives with buffering as the reference example, session re-keying as a sibling, archival subscribers as a separate sibling per PATTERNS.md §3. +L Learning 5 5 strong Removal is not the same as placement Two failures of governance fix-it work both produce misaligned canon: (1) listing something where it does not belong (original drift); (2) removing it without explaining where it does belong (the reductive fix). Both leave the reader unable to act correctly. The right pattern is what D0016 itself does: name the concern, name the use cases that justify it, place it in the architecture, explain the pattern that protects the boundary. Operator caught this with a one-line correction that produced ~30 lines of substantive doc edits across three files. The recursive observation: this is the same failure mode as the original drift — the encoder did not pause to verify the surrounding context (in this case, what work the original list was doing and what removing it would leave undone). Verification requires fresh context applied to fixes too, not just to original work. +H Handoff 5 5 strong PR #189 amended again with substantive buffering placement across three docs Branch claude/wire-principle-and-conversations-c5ab amended with: (1) canon/principles/agents-need-their-own-wire — new sub-section 'What the Wire Refuses to Own — and How AMS Provides It Instead' inside AMS-as-Worked-Reference; lists production use cases, borrows D0016 framing for StreamBufferDO + TTL + size + account-gating, generalizes pattern across observability + session continuity + metadata-discontinuity. (2) canon/principles/symmetric-participation — primitives paragraph extended with substantive 'what the wire refuses to own, the layers above it provide' framing; buffering as worked example with use cases named. (3) canon/architecture/substrate-stack — L1 buffering note expanded from one-liner to paragraph naming use cases and build-once-reuse pattern; new L2 paragraph about shared wrapper-tier primitives with buffering as reference, session re-keying as sibling, archival as separate composable subscriber. Three docs now address what is required for most use cases AND where in the layering it lives, not just what the wire does not own. diff --git a/journal/2026-05-10-wire-principle-and-conversations-patch.tsv b/journal/2026-05-10-wire-principle-and-conversations-patch.tsv new file mode 100644 index 0000000..b3173cb --- /dev/null +++ b/journal/2026-05-10-wire-principle-and-conversations-patch.tsv @@ -0,0 +1,7 @@ +type typeName facet quality_score quality_max quality_level title content +D Decision 5 5 strong New Tier-1 principle agents-need-their-own-wire articulates the load-bearing need for the L1 wire klappy://canon/principles/agents-need-their-own-wire — Tier-1 principle naming human-as-relay as the structural failure mode that the Klappy substrate's L1 wire exists to address. Four characteristic costs named: bottleneck (operator availability gates throughput), lossy relay (each copy-paste loses fidelity), O(N²) integration burden (every agent pair needs human relay), human-shaped formats (agents forced to encode for human carrier instead of receiving agent). Architectural answer: direct addressability between agents on an open substrate. AMS named as the canonical reference implementation per substrate-stack L1 + D0020. Symmetric-participation named as the architectural shape; this principle named as the load-bearing need. Both principles work together at L1. +D Decision 5 5 strong Substantive Failure Modes section names what breaks when the wire stops being a wire Six failure modes documented with diagnoses and fixes: (1) wire becomes prose-shaped rather than agent-shaped (rendering surfaces creep into wire); (2) wire access becomes a permission gate (openness erodes); (3) agents on wire produce noise that re-creates operator-as-filter problem; (4) multi-agent coordination produces compounding errors at machine speed (canon discipline above the wire becomes more necessary, not less, once it exists); (5) the wire becomes opinionated about what an outcome means (vodka-architecture violation); (6) some workflows still legitimately need human in relay path (high-stakes, regulated, training contexts) and the principle does not prescribe wire-only collaboration. Diagnosis pattern: when wire stays narrow and primitive, principle holds; when it accumulates opinions/gates/surfaces/special-cases, it stops being the answer. +D Decision 5 5 strong Mode-separated-conversations patched to reflect five modes plus parallelism plus override plus handoff insufficiency docs/appendices/mode-separated-conversations.md updated: (1) frontmatter date bumped to 2026-05-10, epoch E0008.5, tags expanded to include exploration, resolution, session-discipline; (2) Relationship to Canon updated to reference epistemic-modes, sessions-mirror-modes, encoded-handoff constraint; (3) The Core Insight expanded to name five mode-collapse anti-patterns; (4) new Exploration Conversations section (was missing); (5) new Resolution Conversations section (fifth mode); (6) new Multiple Participants section operationalizing the parallelism patterns; (7) new Operator Override section operationalizing the constraint's override provision in conversational form; (8) new Handoff Insufficiency section operationalizing the runtime feature in conversational form; (9) Mode Signaling examples extended with resolution; (10) Reversion and Final Note preserved. +L Learning 5 5 strong The principle and the architectural shape together specify L1 Symmetric-participation already exists at Tier-1 and describes how the wire must look to stay open: every peer treated identically, no peer-type privilege, identity/capability conveyed through metadata above the wire. What was missing: the load-bearing why. Why does this wire need to exist at all? The agents-need-their-own-wire principle fills that gap. Read together at L1: agents-need-their-own-wire = the need; symmetric-participation = the shape that satisfies the need without crowding out the ecosystem. Either principle without the other is incomplete. Together they form L1's full rationale. +L Learning 5 5 strong Existing klappy.dev canon already had three pieces of the diagnosis Search-before-claiming surfaced: (1) writings/copy-paste — the lived experience essay (clipboard convergence as job description); (2) writings/shifting-bottlenecks-climbing-ladders — the bottleneck-migration framework where this principle slots in; (3) docs/planning/oddkit-write-access — practical evidence ("the single largest source of friction in the current workflow is the human carrying files between conversations"). Plus discernment-layer (where human's load-bearing work moves to once relay is gone) and substrate-stack/L1 (the structural map the principle articulates the need for). The principle does not invent the diagnosis; it consolidates the architectural rationale that was implicit across these. +H Handoff 5 5 strong PR scope: new Tier-1 principle agents-need-their-own-wire + mode-separated-conversations patch + journal klappy.dev branch claude/wire-principle-and-conversations-c5ab. Three file changes: (1) NEW canon/principles/agents-need-their-own-wire.md — Tier-1 principle, ~3.3kw, sibling to symmetric-participation; (2) MODIFIED docs/appendices/mode-separated-conversations.md — added Exploration and Resolution conversation types plus Multiple Participants, Operator Override, and Handoff Insufficiency pointer sections; (3) NEW journal/2026-05-10-wire-principle-and-conversations-patch.tsv. Concurrent with PR #187 and PR #188; no dependency between any of them. Sibling/follow-up work flagged: governance-validation-via-agents rename (vendor-naming smell — same as audit-gates was); use-case catalogue method-doc once 3-5 worked multi-agent applications exist; conversational-mode-orchestration consumer-pattern doc once a working orchestrator exists.