Distributed Coordination Architecture

batch: Batch 24

canonical_family: Interfaces, Roles & Interoperability

source_primes: coordination task_interdependence concurrency dependency

related_primes: interoperability decision feedback observability consensus synchronization cooperation autonomy delegation_of_authority accountability boundary coupling resource_management temporal_dynamics goal_congruence_alignment requisite_variety

slug: coordination

slug: concurrency

slug: dependency

slug: interoperability

slug: decision

slug: consensus

slug: synchronization

slug: cooperation

slug: autonomy

slug: boundary

slug: coupling

components: Decision Rights and Local Autonomy Envelope

components: Exception, Escalation, and Conflict Path

components: Coordination Learning and Closure Record

components: Incentive and Externality Alignment Layer

mechanisms: Coordination Decision Rights and Autonomy Matrix

mechanisms: Interface Control Document or Service Contract

mechanisms: Distributed Planning and Reconciliation Session

essence_one_line: Design the outcome, authority, dependencies, interfaces, shared state, timing, commitments, exceptions, and feedback that let independently controlled actors produce a coherent collective result.

compression_statement: Distributed Coordination Architecture converts an under-specified demand for alignment into an explicit operating system for joint action. It starts from a shared outcome and real interdependence, selects an appropriate central, federated, peer, protocol, planning, or event-driven mode, assigns decision rights and autonomy, defines interoperable commitments and minimum shared state, reconciles timing and scarce resources, routes exceptions and conflict, measures coordination health, and reconfigures as the actor network changes. The architecture coordinates only where dependency requires it and preserves local discretion elsewhere.

core_intuition: Independent actors do not become coordinated merely by communicating more or sharing a goal. Coordination becomes reliable when each actor can see how local choices affect a joint outcome, what others have committed to, which state and signals matter, where authority sits, how coupled actions are sequenced, and what happens when plans conflict or conditions change.

canonical_formula: coordination reliability ≈ outcome clarity × dependency fit × commitment visibility × interface interoperability × legitimate authority × exception capacity × feedback / (information overload + decision ambiguity + coupling mismatch + unresolved conflict)

structural_problem: Multiple actors control different actions, resources, information, or decisions that must combine into one outcome, yet no actor can directly command the whole system and no shared architecture reliably translates interdependence into commitments, timing, signals, and resolution paths.

trigger_conditions: Separate actors can each act rationally yet create an incoherent collective result.

trigger_conditions: Dependencies, handoffs, shared resources, or externalities cross authority boundaries.

trigger_conditions: Local plans are individually plausible but jointly infeasible.

trigger_conditions: Actors hold incomplete, delayed, differently interpreted, or confidential information.

trigger_conditions: Coordination demand changes with scale, urgency, uncertainty, or coupling.

trigger_conditions: Normal interaction fails when an exception, conflict, shortfall, or actor exit occurs.

symptoms: Duplicated work and uncovered responsibilities coexist.

symptoms: Actors wait on one another without a visible dependency owner.

symptoms: Commitments change without reaching affected parties.

symptoms: Meetings and messages increase while joint outcomes worsen.

symptoms: Shared dashboards show activity but not decision-relevant state.

symptoms: Local metrics improve while system outcomes degrade.

symptoms: Every exception is escalated centrally or handled through informal power.

symptoms: Interfaces repeatedly break because actors use incompatible definitions, timing, or acceptance rules.

symptoms: Plans assume the same scarce resource or contradictory sequence.

symptoms: After-action reviews identify communication failure without changing architecture.

root_tension: The system needs enough shared structure to make interdependent action coherent, but excessive centralization, synchronization, visibility, or standardization destroys local knowledge, autonomy, speed, privacy, and adaptive capacity.

anti_signatures: One actor legitimately controls all relevant actions and possesses sufficient local information.

anti_signatures: Actions are independent enough that no shared outcome, dependency, resource, or externality requires coordination.

anti_signatures: The primary problem is disagreement over the goal itself rather than coordination around an accepted goal.

anti_signatures: The primary problem is interpersonal trust repair without material task interdependence.

anti_signatures: A one-time bilateral handoff can be repaired by a simple interface clarification.

anti_signatures: The situation requires strict atomic transaction closure already owned by Nested and Distributed Transaction Coordination.

structural_intervention: Create a bounded, adaptive coordination architecture that maps actors and interdependencies to a shared outcome, selects a fitting coordination mode, formalizes interfaces and commitments, partitions decision rights, exposes minimum common state, reconciles timing and capacity, routes exceptions, measures system health, and reconfigures when conditions change.

action_logic: Define the collective outcome and the local-global constraints it must satisfy.

action_logic: Map independently controlled actors, their actual authority, and their legitimate autonomy.

action_logic: Map task, resource, information, temporal, and risk interdependencies and identify where coordination is genuinely required.

action_logic: Select a coordination mode whose centralization, synchronicity, formalization, and information demands fit those dependencies.

action_logic: Specify interfaces, commitments, acknowledgment, change, and breach behavior between actors.

action_logic: Establish the minimum shared state and signal policy needed for affected decisions, with freshness, provenance, uncertainty, and access boundaries.

action_logic: Partition decision rights into local, consultative, joint, notification, approval, and escalation classes.

action_logic: Reconcile sequencing, synchronization, shared capacity, and mutually constrained plans.

action_logic: Create legitimate exception, conflict, deadlock, safety-stop, and emergency pathways.

action_logic: Instrument coordination health, review failures at interfaces, and reconfigure the architecture rather than merely asking actors to try harder.

action_logic: Close episodes with evidence, transfer residual obligations, and retain reusable learning.

decision_rules: Coordinate at the narrowest boundary that contains the dependency and externality.

decision_rules: Use local autonomy by default when actions are reversible and externalities are bounded.

decision_rules: Increase shared planning or authority only as coupling, irreversibility, urgency, or collective risk increases.

decision_rules: Prefer stable protocols and interfaces for recurring predictable interactions; prefer facilitated planning for novel tightly coupled work.

decision_rules: Use synchronous checkpoints only when actors must share readiness at the same transition.

decision_rules: Publish a signal only when a recipient can identify the decision or safeguard it supports.

decision_rules: Treat a changed commitment as a state transition requiring notice to every affected dependent.

decision_rules: Escalate conflicts by material consequence and decision horizon, not by organizational status alone.

decision_rules: Reconfigure the coordination mode when health signals show recurrent waiting, rework, overload, hidden work, or unresolved exceptions.

target_invariants: The shared outcome remains distinguishable from any actor's local metric.

target_invariants: Actors retain legitimate local authority outside explicitly coupled decisions.

target_invariants: Every material dependency and commitment has an identifiable owner and affected party.

target_invariants: Shared state carries freshness, provenance, uncertainty, and access boundaries.

target_invariants: Exceptions have a safe interim action and legitimate time-bounded resolution route.

target_invariants: Coordination costs remain proportional to actual interdependence.

target_invariants: No actor can silently impose externalities through an undefined interface.

target_invariants: Safety, consent, due process, privacy, and dissent protections survive urgency.

target_invariants: Architecture changes preserve continuity and communicate new commitments.

expected_outcomes: Joint plans become feasible across actor constraints and shared resources.

expected_outcomes: Handoffs and dependencies fail less often and recover faster.

expected_outcomes: Local decisions remain fast where collective approval adds no value.

expected_outcomes: Affected actors learn about material state and commitment changes in time to act.

expected_outcomes: Conflicts and exceptions reach legitimate decision paths before cascading.

expected_outcomes: Coordination meetings and message volume can fall even as reliability rises.

expected_outcomes: Collective outcomes improve without suppressing local adaptation.

expected_outcomes: The system can change coordination modes as scale, uncertainty, or coupling changes.

prose_essence:
Distributed Coordination Architecture is the pattern for making independently controlled action add up. It applies when no actor can simply issue a complete plan, yet the actions of several actors share dependencies, scarce resources, timing constraints, externalities, or a collective outcome. The intervention is not “communicate more.” It is the deliberate design of the outcome, authority, interfaces, shared state, commitments, sequencing, exception paths, and learning that turn partial local control into reliable joint action.

The archetype’s central move is architectural: diagnose what must be coordinated, choose a coordination mode that fits, and preserve local discretion everywhere else. Some dependencies justify stable protocols. Some require shared planning. Some need a hub, integrator, or incident cell. Others work best through peer adjustment or event-driven signals. The correct design may mix modes and change them over time.

The target is coherent collective performance, not uniform behavior. Actors may retain different goals, expertise, systems, identities, and internal processes. Coordination succeeds when their boundary interactions and consequential choices remain compatible enough for the shared outcome.

prose_when_to_use:
Use the archetype when several legitimate centers of control must combine their actions and none possesses enough authority, information, variety, or capacity to direct the whole system. Typical triggers include cross-functional work, multi-agency response, supply networks, federated software, care pathways, public-private partnerships, ecological stewardship, and any setting where handoffs, shared resources, timing, or externalities cross organizational boundaries.

The strongest signal is a local-global gap. Each actor may be competent and locally rational, yet the system still produces gaps, duplication, delay, conflict, overload, unsafe coupling, or incompatible commitments. Another signal is coordination inflation: more meetings, status requests, dashboards, and messages are added while the joint outcome remains unreliable. That usually means the system lacks an architecture, not effort.

Apply it when coordination demand varies. Routine interactions may be protocol-mediated and asynchronous; novel or tightly coupled episodes may require shared planning and synchronous readiness; crises may justify temporary integrator-led authority. The archetype provides the rule for moving among these forms.

Do not apply it merely because several people are involved. If one legitimate actor controls the work, ordinary planning and delegation may suffice. If actions are independent, coordination can be waste. If the dispute concerns the legitimacy of the collective goal, governance or conflict resolution must come first. If the problem is atomic multi-participant commit, phased restart, consensus formation, or shared interpretation alone, the accepted specialized neighbor should own the intervention.

prose_structural_problem:
Coordination problems arise from distributed control plus consequential interdependence. Different actors see different state, control different resources, operate on different clocks, answer to different authorities, and optimize against different local measures. No one has a complete or current picture. A changed commitment in one place becomes an unanticipated constraint elsewhere. A local exception propagates through interfaces that were never designed to carry it.

The absence of command is not itself a defect. Distributed control preserves local knowledge, specialization, legitimacy, resilience, and speed. The defect is leaving the relationships among local decisions implicit. When dependencies are hidden, actors cannot distinguish work they may conduct independently from work requiring notification, consultation, joint decision, synchronization, or escalation.

Three mismatches commonly compound. First, the coordination topology does not fit the dependency topology: all-to-all meetings serve a network that needs stable interfaces, or a central hub serves work that requires peer adaptation. Second, information structure does not fit decision structure: actors receive too much irrelevant state and too little timely exception information. Third, authority structure does not fit consequence: local actors need central approval for reversible choices while irreversible cross-boundary choices escape joint review.

Coordination also fails when success is measured locally. Each actor can meet its target while the collective result degrades through waiting, rework, exclusion, duplicated capacity, unsafe transitions, or shifted externalities. Without a shared outcome contract and system-level health signals, local reports can conceal coordination failure.

prose_intervention_logic:
Start by defining the joint result. State what must become true at the collective level, which constraints cannot be traded away, and what would count as a locally attractive but collectively unacceptable outcome. This outcome becomes the reference for authority, interfaces, information, and metrics.

Next, map the actor system as it actually operates. Identify who controls which actions, who can make commitments, who bears effects, who may override, and which authority is formal, informal, delegated, technical, professional, or community-based. Preserve the difference between convening, recommending, deciding, executing, reviewing, and remedying.

Map interdependence before choosing a mechanism. Classify pooled resources, sequential handoffs, reciprocal adjustment, temporal barriers, shared state, interface compatibility, risk propagation, and externalities. Tight, irreversible, or safety-critical dependencies require stronger coordination than reversible local choices.

Select a mode. A central hub reduces pairwise complexity but risks overload and capture. Federated liaisons preserve authority but can deadlock. Peer adjustment is adaptive but needs observable state, bounded externalities, and escalation. Protocol mediation scales recurring interactions but can ossify. Shared planning handles novelty but is expensive. Event-driven signals support asynchronous response but cannot resolve complex conflict. Mixed architectures are often correct.

Operationalize the mode through interface and commitment contracts, minimum shared state, decision-rights partitions, sequencing rules, capacity reconciliation, and targeted signals. Then design the abnormal path: how actors declare an exception, contain harm, resolve incompatible commitments, stop unsafe action, assign interim authority, appeal, and return to normal operation.

Finally, instrument and adapt the architecture. Measure dependency failure, stale state, conflicting commitments, waiting, rework, unresolved exceptions, coordination load, and collective outcomes. When failure repeats, change the topology, protocol, authority, or state model rather than merely exhorting actors to collaborate.

prose_key_components:
### Shared Outcome Contract

The shared outcome contract makes the collective result testable. It must be intelligible to every actor while remaining independent of any actor’s local task. It names acceptance conditions, safety and equity constraints, and local wins that would damage the whole. Without it, coordination collapses into activity alignment or obedience to the most powerful actor’s metric.

### Actor Autonomy and Authority Map

This map records actual control, not titles. It distinguishes authority to commit, decide, execute, veto, stop, review, and remedy. It shows where autonomy is legitimate and where local choices create collective consequence. The map prevents both shadow hierarchy and fictitious decentralization.

### Interdependence and Handoff Map

This component exposes why coordination is necessary. It records dependency type, direction, criticality, timing, shared resources, handoff evidence, and failure propagation. A map of tasks without relations is insufficient; the purpose is to identify the exact interfaces where one actor’s state changes another actor’s feasible action.

### Coordination Mode Selection Rule

The selection rule converts dependency conditions into architecture choices. It compares centralization, synchronicity, formalization, information load, urgency, scale, actor capability, and reversibility. It also includes switching triggers, because the correct routine mode may fail during novelty, crisis, growth, or actor turnover.

### Interface and Commitment Contract

An interface contract defines exchanged objects, semantics, quality, timing, acknowledgment, change, and failure behavior. A commitment contract adds who can promise, who depends on it, what fulfillment means, and what happens when it changes. Together they reduce continuous negotiation without erasing internal freedom.

### Shared State and Situation Model

Coordination needs minimum common state, not total common knowledge. The model identifies authoritative fields, ownership, freshness, provenance, uncertainty, and access. It may be centralized or federated. Its standard is decision usefulness: every shared field should support a named choice, safeguard, or dependency.

### Decision Rights and Local Autonomy Envelope

This envelope separates local, consultative, joint, approval, notification, and escalation decisions. Local discretion should be wide for reversible actions with bounded externalities. Stronger joint control is warranted as coupling, irreversibility, scarcity, and risk rise. The envelope should include emergency and good-faith safety exceptions.

### Sequencing and Synchronization Rule

The rule defines precedence, readiness, barriers, timeouts, and asynchronous allowance. It synchronizes only where dependencies require shared readiness. Excessive lockstep creates waiting and brittleness; insufficient sequencing creates race conditions and premature transitions.

### Information and Signal Policy

This policy answers who needs which signal, for which decision, by when, at what confidence, and under what privacy boundary. More communication is not the goal. Targeted, meaningful signals reduce both blindness and overload. Exceptions and changed commitments often matter more than continuous raw state.

### Exception, Escalation, and Conflict Path

Normal protocols never cover every case. The exception path defines triggers, containment, interim authority, time limits, review, appeal, and return. It must preserve dissent and safety while preventing indefinite deadlock. Informal escalation based on status alone is not a substitute.

### Resource and Capacity Reconciliation

Independent plans can be logically compatible yet jointly infeasible because they assume the same people, space, funding, route, compute, inventory, or time. Reconciliation exposes demand, reservations, priorities, substitutes, and shortfall rules so the collective plan is executable.

### Commitment and Dependency Register

The register provides durable coordination memory. It links commitments to owners, affected dependents, conditions, status, change history, risks, and closure evidence. It should federate where necessary rather than forcing all local work into one central tracker.

### Coordination Health Signal Set

Health signals measure the interfaces and the joint result: rejected handoffs, stale state, contradictory commitments, wait time, rework, unowned exceptions, overload, and externalized cost. Meeting attendance and message volume are activity measures and can increase as coordination deteriorates.

### Adaptation and Reconfiguration Cadence

Dependencies, actors, authority, scale, and uncertainty change. This cadence reviews whether the mode, interfaces, state, and escalation still fit. It includes migration and rollback so the architecture can change without losing continuity.

### Coordination Learning and Closure Record

Closure records which commitments were fulfilled, which obligations remain, how exceptions were resolved, and what architecture changes follow. It transfers residual duties and prevents coordination debt from disappearing when a temporary coalition or episode ends.

prose_common_mechanisms:
### Joint Operating Agreement

A joint operating agreement binds the coordination model into a versioned document. It is useful when actors can legitimately commit to shared outcome, roles, interfaces, escalation, and revision. It fails when it is ceremonial, inaccessible, or detached from actual authority.

### Decision Rights Matrix

A decision-rights matrix distinguishes local action, consultation, joint decision, approval, notification, and escalation by decision class. It should be tested against edge cases and actual authority. A generic RACI chart without decision semantics is too weak.

### Dependency and Interaction Map

This artifact combines workflow evidence, actor knowledge, and incident history into a graph of handoffs, shared resources, signals, timing, and failure propagation. Keep it bounded and current; a decorative system map adds little.

### Shared Coordination Board

The board exposes coordination-relevant outcome, state, commitments, dependencies, capacity, exceptions, and decisions. Each field needs an owner, freshness, confidence, and access rule. The board supports coordination but cannot resolve authority or conflict by itself.

### Liaison and Integrator Role

A liaison translates across boundaries; an integrator also reconciles dependencies and convenes decisions. The role needs enough access and legitimacy to work, but its authority must be bounded to avoid shadow command and knowledge centralization.

### Synchronization Checkpoint

A checkpoint verifies shared readiness before a coupled transition. It should be dependency-triggered and able to release, hold, or replan. Universal gates and ceremonial green status are failure modes.

### Interface Control Document or Service Contract

This mechanism stabilizes recurring exchanges through explicit semantics, performance, acknowledgment, change, and failure behavior. It is especially useful across organizational or technical boundaries. Versioning and compatibility policy prevent hidden breaking changes.

### Commitment and Dependency Register

A register turns promises into stateful, addressable objects. Changes notify affected dependents, and closure requires evidence. The register must not become a duplicate tracker for independent local tasks.

### Exception and Escalation Protocol

This protocol handles thresholds where normal rules fail. It declares the exception, contains harm, names interim authority, routes a decision, preserves review, and closes the exception. Emergency authority should be time-limited.

### Distributed Planning and Reconciliation Session

Actors prepare local plans, expose constraints and dependencies, reconcile scarce resources, identify decisions, and publish feasible commitments. This is not a status meeting; it must change plans or surface unresolved authority.

### Event-Driven Coordination Channel

The channel routes meaningful changes and exceptions to actors whose decisions depend on them. Stable event semantics, subscriptions, priority, acknowledgment, duplicate handling, and missed-event recovery prevent alert flood and silent failure.

### Coordination Health Review and After-Action Coordination Review

Health reviews operate during standing coordination; after-action reviews close episodes. Both examine the architecture and interfaces rather than assigning individual blame. Their output is owned structural change, not a lesson list.

prose_failure_modes:
**Coordination theater** appears when organizations add meetings, dashboards, plans, or roles without specifying dependencies, authority, commitments, or exception behavior. Audit every mechanism against a decision or interface it must improve.

**Overcoordination** subjects independent work to joint approval and shared cadence. It destroys speed and ownership. Shrink the boundary until only consequential dependencies remain.

**Undercoordination** leaves irreversible or externally consequential choices local. Map externalities, shared resources, and failure propagation, then strengthen the mode proportionally.

**Integrator bottleneck and shadow hierarchy** occur when one role accumulates information and de facto command. Bound authority, distribute state, add capacity and succession, preserve direct interfaces, and record overrides.

**False shared state** occurs when a dashboard is stale, ambiguous, overaggregated, or strategically curated. Require authoritative ownership, freshness, provenance, uncertainty, and decision relevance.

**Commitment ambiguity** appears when a promise lacks authority, acceptance, dependents, change notice, or closure. Model commitments as stateful objects with acknowledgment.

**Coordination overload** results from all-to-all messaging, excessive cadence, too many metrics, and nested approval. Target signals, stabilize interfaces, reduce pairwise links, and measure load.

**Distributed deadlock** follows incompatible commitments, symmetric vetoes, or unclear authority. Use time-bounded escalation, interim rules, and appeal.

**Protocol ossification** preserves an interface after actors, dependencies, scale, or risks change. Establish review triggers, compatibility migration, and rollback.

**Emergency capture** converts temporary integration into permanent power. Sunset emergency authority, retain minimum rights, publish reasons, and require reauthorization.

**Consensus substitution** delays action until full agreement where a legitimate decision rule would suffice. State which decisions require consensus and which require only input or notice.

**Learning without change** records lessons but assigns no architecture repair. Link every material lesson to a component, mechanism, owner, deadline, and verification signal.

prose_neighbor_distinctions:
**Coordination and Synchronization Across Reentry Phases** owns the choreography of separated parts returning in waves with readiness, capacity, pause, and rollback. Distributed Coordination Architecture applies before, during, and after reentry and selects broader operating modes.

**Nested and Distributed Transaction Coordination** owns transaction boundaries, participant commit states, atomicity objectives, timeout and partition behavior, compensation, replay, and closure. The current archetype does not guarantee atomic outcomes and spans nontransactional joint action.

**Hub-and-Spoke Coordination** is one topology: interactions route through a central hub. The parent can select a hub, federated liaisons, peer adjustment, protocols, planning, events, or a mixture. It also includes switching and health logic.

**Shared Mental Model Alignment** aligns understanding of roles, system, risk, and plan. Shared understanding is often required, but actors can understand one another and still lack feasible commitments, authority, capacity, interfaces, and exception paths.

**Task Interdependence Mapping** reveals dependency structure and suggests communication and handoffs. It is a diagnostic input; the current archetype uses it to choose and operate a system.

**Consensus Convergence** moves divergent views toward sufficient agreement. Coordination does not always require consensus. Actors can coordinate under bounded disagreement through decision rights, standards, contracts, and appeal.

**Self-Organization Enablement** creates conditions for decentralized order without centrally specifying every role. The current archetype can choose self-organizing peer modes, but it also specifies when stronger protocol, integration, shared planning, or authority is required.

**Whole-System Alignment** corrects local optimization and incentive misalignment. Distributed actors may already share incentives and still fail because of hidden dependencies, stale state, incompatible timing, or ambiguous commitment.

**Structured Sensemaking** produces shared interpretation under uncertainty. It ends before the operational architecture of authority, resources, commitments, interfaces, and closure.

**Coupling Calibration** tunes how strongly parts depend on one another and how propagation risk is contained. This archetype coordinates the coupling that remains after calibration.

**Alignment Governance and Dispute Resolution** provides legitimate forums and ruling paths for misalignment. It becomes relevant when normal coordination conflict cannot be handled through the parent’s bounded exception path.

**Bridge Insertion** creates one cross-boundary connection. A bridge may be a useful mechanism while leaving outcome, authority, state, commitments, and adaptation undefined.

prose_cross_domain_examples:
**Cross-functional launch.** Product, engineering, security, legal, operations, and support share a launch outcome but retain different authority. The architecture maps dependencies, defines local and joint decisions, versions interface commitments, sets readiness checkpoints, routes exceptions, and measures unresolved cross-functional risk. It reduces meetings by moving routine exchanges into stable contracts and targeted events.

**Care pathway.** Hospitals, primary care, pharmacies, transport, social services, patients, and families coordinate referral, medication, diagnostics, discharge, and follow-up. Minimum shared state carries consent, status, urgency, ownership, capacity, and uncertainty. Rejected handoffs enter a timed escalation path; patient continuity rather than provider throughput anchors the outcome.

**Federated software platform.** Autonomous services retain deployment freedom inside interface and risk envelopes. Schema and capacity commitments are versioned. Events reach affected dependencies. Joint checkpoints are used only for tightly coupled migrations. Incident mode temporarily strengthens integration and later returns to distributed operation.

**Humanitarian response.** Agencies, local government, community organizations, logistics firms, and donors share outcome and resource dependencies but have different mandates. A bounded coordination cell reconciles capacity and safety conflicts, while local partners retain delivery authority. Data sharing is purpose-limited, and emergency decisions sunset.

**Watershed governance.** Landowners, utilities, agencies, Indigenous communities, farms, and conservation groups coordinate monitoring and intervention across ecological and jurisdictional boundaries. The architecture combines local action envelopes, shared indicators, cross-boundary commitments, scarcity rules, and legitimate dispute escalation.

**Supply network disruption.** Routine coordination uses interface contracts and events. When a critical source fails, the architecture switches to integrator-led reconciliation of inventory, transport, substitutions, customer priority, and safety. Changes are visible to dependents, and temporary authority closes after stabilization.

**Distributed biological stewardship.** Local monitoring teams and habitat managers share only decision-relevant ecological state, coordinate migration corridors and thresholds, and adapt action as feedback arrives. The pattern transfers without pretending biological actors sign literal contracts; commitments translate into stable interaction rules and stewardship obligations.

prose_non_examples:
A coordination meeting is not the archetype. Without outcome, dependency, authority, commitments, and exceptions it is a cadence mechanism and may worsen overload.

A shared dashboard is not the archetype. It can expose state but cannot decide what must be common, who may act, how commitments change, or how conflict resolves.

A RACI matrix is not the archetype. It may record roles, but ordinary RACI labels do not specify decision classes, autonomy, dependency, or escalation semantics.

A central command structure imposed on independent actors without legitimate authority is not coordination architecture; it is unacknowledged domination and will often produce evasion or nominal compliance.

A consensus workshop is not the archetype. Consensus is one decision mechanism and can be actively harmful where urgency or legitimate delegated authority requires action.

An atomic distributed commit protocol belongs to Nested and Distributed Transaction Coordination. Its closure and consistency objectives are narrower and stronger than general coordination.

A phase-gated restart plan belongs to Coordination and Synchronization Across Reentry Phases when reactivation, readiness, overload, and rollback are decisive.

A trust-building exercise is not enough. Trust may enable truthful signaling, but it does not define dependencies, interfaces, capacity, decision rights, or failure behavior.

A single manager assigning tasks within one controlled team usually needs planning and delegation, not a distributed coordination architecture.

prose_tradeoffs:
Explicit coordination improves reliability but consumes attention, negotiation, documentation, and governance capacity. The design question is not whether cost exists, but whether it is lower than the waiting, rework, risk, and externality of implicit coordination.

Central hubs reduce many pairwise links and create a common view. They also concentrate power, information, and failure. Federated or peer systems preserve autonomy and resilience but demand stronger interface semantics and can struggle with system-wide tradeoffs.

Shared state improves coherence and can also enable surveillance, gaming, or coercive performance management. Minimum necessary state, role-based access, aggregation, and purpose limitation are architectural requirements, not afterthoughts.

Standardization makes recurring interactions cheaper. It can also exclude unusual actors, suppress valuable local variation, and privilege incumbent capabilities. Exception pathways and revision governance keep interoperability from becoming uniformity.

Participation increases legitimacy and relevant knowledge, but every actor does not need equal involvement in every decision. Separating voice, consent, expertise, authority, execution, review, and appeal allows participation to fit the decision.

Synchronous coordination creates rapid shared awareness but interrupts deep work and can become performative. Asynchronous protocols scale but lose nuance and may delay conflict discovery. Mixed modes are usually more robust.

prose_invariants_to_preserve:
Preserve the distinction between the collective outcome and local performance. If the joint result cannot discipline local choices, the system is aligned only in name.

Preserve legitimate autonomy outside the dependency boundary. Coordination is not a license to centralize every decision or expose every local state. The burden of proof lies with the coupling or externality that requires shared control.

Preserve ownership and affected-party visibility for material commitments. A promise that cannot be traced to an authorized owner, dependent actor, acceptance condition, and state change is not a reliable coordination object.

Preserve minimum shared-state quality. Freshness, provenance, uncertainty, and access boundaries should survive aggregation and urgency. A false common operating picture is often worse than acknowledged partial knowledge.

Preserve safe exception handling. Actors need a legitimate way to stop unsafe action, declare infeasibility, challenge an instruction, and escalate deadlock without retaliation. Emergency powers require explicit scope, time limit, and review.

Preserve proportionality. Coordination cost should track real interdependence and consequence. Independent work should remain independent; tightly coupled irreversible work should not rely on goodwill alone.

Preserve continuity during reconfiguration. New interfaces, authority, state models, and commitments must migrate deliberately. Architecture change that silently invalidates existing dependencies creates the failure it intended to fix.

prose_target_outcomes:
A successful architecture produces jointly feasible plans, fewer failed handoffs, faster exception resolution, more timely state changes, and clearer decisions. Local actors should spend less time discovering dependencies and renegotiating recurring semantics.

Reliability should improve without a proportional rise in coordination activity. Meeting load, broadcast traffic, approval steps, and central queue length may decline because stable interfaces and targeted signals replace continuous negotiation.

The distribution of burden should become visible. Smaller or less powerful actors should not absorb all reporting, adaptation, waiting, or risk while dominant actors retain flexibility. Shared outcomes and health signals should surface these asymmetries.

The architecture should also become adaptive. As actors become more capable, routine coordination may decentralize. As coupling or crisis rises, temporary integration may increase. The system should change mode through declared triggers rather than political improvisation.

Long-term success is a capability: actors can diagnose coordination demand, select modes, make commitments, handle exceptions, and learn. The result is not dependence on one heroic coordinator.

prose_parameter_dimensions:
**Centralization.** Move from peer adjustment to federated coordination, bounded integration, or central command as coupling, urgency, irreversibility, and system-wide externality rise. Centralization should fall again when local knowledge, scale, legitimacy, and bottleneck risk dominate.

**Synchronicity.** Use asynchronous state and events for independent or loosely coupled action. Add synchronous planning, negotiation, or readiness only where timing or shared transition requires it. Every recurring meeting should name the dependency it serves.

**Formalization.** Stable, high-volume, cross-boundary interactions benefit from explicit protocols and versioned interfaces. Novel, low-frequency, ambiguous work needs richer dialogue and provisional commitments. Formalization should increase after patterns stabilize, not before learning.

**Information breadth and resolution.** Share enough state for affected decisions, but no more. Tune aggregation, freshness, confidence, provenance, exception thresholds, confidentiality, and recipient scope. Total transparency is neither feasible nor safe.

**Autonomy envelope.** Expand local discretion when actions are reversible, capabilities are high, and externalities are bounded. Narrow it for shared scarce resources, irreversible transitions, safety, legal duties, or systemic risk. Use risk tiers rather than one blanket rule.

**Interface strictness.** Tight contracts improve interoperability and predictability but can exclude unusual cases and freeze poor design. Pair standards with exception paths, compatibility windows, and revision governance.

**Coordination cadence.** Cadence should match the rate at which relevant state, dependencies, and commitments change. Too slow creates stale plans; too fast creates noise and administrative work. Event-triggered review often complements scheduled review.

**Redundancy and fallback.** Hubs, liaisons, state stores, and event channels can become single points of failure. Tune deputies, distributed copies, fallback direct channels, manual modes, and recovery exercises to consequence.

**Participation and closure.** Broader participation improves legitimacy and information but can exceed the action horizon. Separate input, consultation, decision, review, and appeal roles, and publish closure rules before deliberation begins.

**Architecture switching threshold.** Define evidence for changing mode: overload, new scale, recurring exception, degraded trust, actor capability growth, crisis, or new legal authority. Switching too late preserves failure; switching too often destroys learning and continuity.

prose_variants_and_near_names:
**Integrator-led coordination** uses a bounded integrator to maintain interfaces and reconcile dependencies without absorbing all local authority. Preserve it as a variant when integrator capacity and bottleneck risk materially shape implementation.

**Federated liaison coordination** distributes cross-boundary work among empowered representatives and a joint forum. It fits legitimate autonomous institutions that reject or cannot sustain a central hub.

**Peer mutual-adjustment coordination** relies on capable actors observing shared state, publishing commitments or events, and adjusting locally within externality and escalation boundaries. It is not rule-free self-organization.

**Protocol-mediated coordination** embeds recurring interaction in stable interfaces, event semantics, acknowledgment, and exception rules. Protocols remain mechanisms unless their governance changes the full intervention lifecycle.

The frozen target names `coordination_mechanism` and `coordination_mechanisms` route to the parent only when they refer to the designed architecture family. A single checklist, meeting, dashboard, role, protocol, or matrix should route to its component or mechanism record instead.

Accepted Hub-and-Spoke Coordination, Self-Organization Enablement, Consensus Convergence, transaction coordination, and reentry coordination are not variants. Each has a distinct objective, component family, and failure model and remains a neighbor.

Integrator-Led Coordination

short_definition: Uses a bounded integrator to reconcile dependencies and convene joint decisions while actors retain local authority.

distinctive_feature: An integrator carries interface work without absorbing every local decision.

distinct_from_parent: Selects a role-centered architecture rather than the parent's general mode-selection lifecycle.

still_same_parent_because: It uses the same outcome, actor, dependency, interface, state, authority, exception, and feedback components.

use_when: No actor naturally owns the joint outcome

use_when: Central command would be illegitimate or overloaded

domain: healthcare

example: A care coordinator integrates providers without taking their clinical authority.

failure_modes:
Shadow command
Integrator bottleneck

Federated Liaison Coordination

short_definition: Coordinates autonomous units through reciprocal liaisons, shared contracts, and federated decision forums.

distinctive_feature: Coordination responsibility is distributed across boundary-spanning representatives.

distinct_from_parent: Selects a federated liaison topology.

still_same_parent_because: The parent supplies the shared outcome, interfaces, state, escalation, capacity, and adaptation logic.

source_primes: coordination autonomy

use_when: Actors have legitimate independent authority

use_when: A single hub would be fragile or politically unacceptable

example: Municipal agencies coordinate through empowered liaisons and a joint exception forum.

failure_modes:
Liaison lacks authority
Federated veto deadlock

Peer Mutual-Adjustment Coordination

short_definition: Lets capable peers adjust plans through shared state, commitments, signals, and local negotiation rather than a central scheduler.

distinctive_feature: Local reciprocal adjustment is the primary coordination engine.

distinct_from_parent: Selects a decentralized operating mode.

still_same_parent_because: It preserves the parent's authority, interface, exception, health, and reconfiguration controls.

source_primes: coordination cooperation

use_when: Interactions are frequent and locally resolvable

example: Services publish capacity and dependency events and adjust routing within declared envelopes.

failure_modes:
Local oscillation
Hidden externality
Coordination storm

Protocol-Mediated Coordination

short_definition: Coordinates actors primarily through stable interface, commitment, event, acknowledgment, and exception protocols.

distinctive_feature: A protocol carries coordination that would otherwise require repeated negotiation.

distinct_from_parent: Selects a contract-and-signal-heavy implementation family.

still_same_parent_because: Protocols instantiate the parent's broader architecture and cannot choose outcomes, authority, or adaptation alone.

source_primes: coordination interoperability

use_when: Actors need internal implementation freedom

example: Suppliers coordinate through versioned interface requirements, change notices, and exception handling.

failure_modes:
Protocol ossification
Semantic mismatch
Undocumented exception channel