Paper deep dive
GenCoord: Skill-Path Commitments under Private Information
Peng He, Junning Zhu, Haohan Yuan, Jianpeng Liang
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 93%
Last extracted: 8/25/2026, 7:57:47 AM
Summary
The paper introduces GenCoord, a framework for multi-agent coordination under private information, specifically within Minecraft environments. It utilizes a local Qwen3.5-0.8B model to generate executable 'skill-path commitments' via a Short DSL, allowing agents to coordinate by exchanging structured SELF and REQ messages. This approach resolves local ambiguities by making task consequences explicit, leading to improved success rates and reduced communication overhead compared to free-form methods.
Entities (6)
Relation Signals (5)
GenCoord → evaluatedin → Minecraft
confidence 95% · We evaluate on the official Minecraft Java 1.21.4 server
GenCoord → uses → Qwen3.5-0.8B
confidence 95% · A local Qwen3.5-0.8B model emits a multi-step SELF plan and peer REQ
GenCoord → solves → Private Information
confidence 93% · GenCoord: Skill-Path Commitments under Private Information
GenCoord → uses → Short DSL
confidence 92% · Short DSL is the peer-facing executable interface for this canonical schema.
GenCoord → compilesto → Mineflayer
confidence 90% · compiled to Mineflayer skills
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Suppose one embodied agent knows what must be built, while its teammate alone knows which transformation its workcell can perform. Neither local view determines who should act, what should be handed off, or how the joint task should continue. We introduce GenCoord, which turns the task consequence of such private facts into an executable skill-path commitment. A local Qwen3.5-0.8B model emits a multi-step SELF plan and peer REQ; bounded feedback conditions route revision when the deciding capability is peer-local. The resolved commitment is parsed, checked, canonically materialized, compiled to Mineflayer skills, and verified by handoff and terminal state. Counterfactual interventions that hold the world, call schedule, and executor unchanged make requester revision and receiver execution follow the injected task consequence in both directions. Across three independently trained seeds, correct capability feedback closes the paired local-information gap from 50% to 100%. Multi-step commitments improve held-out-template success by 6.9 points while reducing model decisions by 32%. At matched closed-loop quality on 128 held-out semantic clusters, Short DSL reduces peer traffic by 92.8% and median time-to-commitment by 68.2% relative to controlled free-form communication. These results identify executable task consequences as the coordination unit connecting distributed local reasoning to verified joint action.
Tags
Links
- Source: https://arxiv.org/abs/2608.22055v1
- Canonical: https://arxiv.org/abs/2608.22055v1
Trouble viewing inline? Open PDF directly →
Full Text
98,782 characters extracted from source content.
Expand or collapse full text
GenCoord: Skill-Path Commitments under Private Information Peng He ∗ Tsinghua University Beijing, China hepeng@tsinghua-wx.org Junning Zhu ∗ Beijing Normal-Hong Kong Baptist University Zhuhai, China t330025113@mail.bnbu.edu.cn Haohan Yuan University of North Carolina at Charlotte Charlotte, United States hyuan3@charlotte.edu Jianpeng Liang University of California San Diego San Diego, United States jil652@ucsd.edu Abstract Suppose one embodied agent knows what must be built, while its teammate alone knows which transformation its workcell can per- form. Neither local view determines who should act, what should be handed off, or how the joint task should continue. We introduce GenCoord, which turns the task consequence of such private facts into an executable skill-path commitment. A local Qwen3.5-0.8B model emits a multi-stepSELFplan and peerREQ; bounded feedback conditions route revision when the deciding capability is peer-local. The resolved commitment is parsed, checked, canonically materi- alized, compiled to Mineflayer skills, and verified by handoff and terminal state. Counterfactual interventions that hold the world, call schedule, and executor unchanged make requester revision and receiver execution follow the injected task consequence in both directions. Across three independently trained seeds, correct capa- bility feedback closes the paired local-information gap from 50% to 100%. Multi-step commitments improve held-out-template success by 6.9 points while reducing model decisions by 32%. At matched closed-loop quality on 128 held-out semantic clusters, Short DSL reduces peer traffic by 92.8% and median time-to-commitment by 68.2% relative to controlled free-form communication. These re- sults identify executable task consequences as the coordination unit connecting distributed local reasoning to verified joint action. CCS Concepts • Computing methodologies→Multi-agent systems; Natural language generation. Keywords multi-agent coordination, embodied agents, semantic communica- tion, language-model agents, Minecraft 1 Introduction Imagine two Minecraft agents fulfilling an order for a crafting table. Agent퐴sees the order; agent퐵alone knows whether its workcell can transform oak planks or can only receive the finished table. In the first case,퐴should hand off planks and퐵should craft. In the second, 퐴 must craft first and hand off the table. Agent 퐴 receives the same local input in both cases, yet the correct actor, handoff item, and continuation all change. ∗ Equal contribution. This small example captures a general problem in embodied teams. Goals, tools, workcells, inventories, and execution condi- tions are distributed across agents. The team can have a well-defined joint route even when no individual view determines it. Coordina- tion must reveal the task consequence of a private fact: who acts, what crosses the handoff boundary, where it goes, and which suffix follows. Centralized planning can reveal that consequence by assembling local contexts; free-form negotiation can reveal it through repeated state, intent, and plan exchange. GenCoord instead makes the con- sequence itself the coordination object, preserving the fields that directly determine execution. The path-determining fact may reside at either endpoint of an edge. A sender-local consequence travels forward inside a peer request, after which the receiver generates its downstream skill path. A peer-local capability consequence travels back through bounded feedback, after which the requester revises the division of work. Both directions require one explicit object whose semantics survive communication, resolution, and execution. GenCoord turns that object into an executable skill-path com- mitment. Its primary backend uses a local Qwen3.5-0.8B model [19] to compose goals, capabilities, objects, history, received messages, and shared task structure into variable-length role-local paths. The sender jointly emits a multi-step self-plan and peer request: SELF resource.obtain(q=4,item=oak_planks) > resource.deliver(q=4,item=oak_planks,to=agent_b) REQ agent_b craft.item(q=1,input=oak_planks, item=crafting_table) > resource.deliver(q=1,item=crafting_table, dst=order_chest) Short DSL is the peer-facing executable interface for this canonical schema. Before resolution it carries a proposedSELF+REQroute; after resolution the same schema carries the role-local obligations that enter execution. In the main forward route, the receiver condi- tions onREQand generates its downstreamSELFpath. In the paired capability diagnostic, a transparent Accept/Reject/Counter re- sponse conditions requester revision. The resolved object follows a deterministic grounded path: parse, schema check, canonical materialization, skill compilation, Mine- flayer execution [18], verified handoff, and terminal-state readback. Figure 1 summarizes the two directions and their shared execution closure. Across three independently trained seeds, bounded capability feedback raises paired local success from 50% to 100%, and counter- factual interventions in both directions redirect the resolved route 1 arXiv:2608.22055v1 [cs.AI] 22 Aug 2026 Agent A (Steve) Agent B (Alex) SENDER-LOCAL FACT task consequence carried in REQ SELF+REQ SCHEMA SELF: role-local path REQ: peer request path Proposal before resolution; role-local obligations after resolution SELF A: obtain 4 oak_planks→ deliver to B REQ B: craft 1 crafting_table→ deposit in order_chest same initial proposal across paired workcell modes REQ rᵗᵢ→ⱼ SHARED EXECUTABLE PRIOR K (shared by both agents) task structure · skill ontology · typed arguments · grounding constraints PEER-LOCAL CAPABILITY B workcellmode Raw processor Can transform oak_planks ─ vs ─ Finished receiver Can only receive crafting_table delivered REQrequested suffix peer-local capability FORWARD RESOLUTION LANE Receiver learned call conditioned on xᵗⱼ⊕ rᵗᵢ→ⱼand K xᵗⱼ⊕ rᵗᵢ→ⱼ, K → uᵗⱼ Canonical resolver combines proposal qᵗᵢ with downstream SELF uᵗⱼ Resolve → (qᵗᵢ, uᵗⱼ) → Cᵢⱼ→,ᵗ C forward- resolved commitment FEEDBACK RESOLUTION LANE BOUNDED RESPONSE ACCEPT · REJECT · COUNTER(α) transparent policy; no model call ACCEPT / COUNTER(α) REQUESTER RESOLUTION second learned call conditioned on qᵗᵢ⊕ ρᵗⱼ→ᵢ C feedback- resolved commitment REJECT → no commitment CAPABILITY-CONDITIONED REWRITE same requester view and initial proposal ResponseActorHandoff itemPeer suffix ACCEPT B4 oak_planks B crafts → deposits COUNTER (α) A 1 crafting_table B deposits only Destination unchanged: order_chest RESOLVED SELF+REQ COMMITMENT C→ or C← complete role-local obligations GROUNDED EXECUTION (SHARED CLOSURE) 1234PARSE + CHECK validated typed commitment MATERIALIZE + COMPILE canonical dispatch → Mineflayercalls EXECUTE in-world action + handoff VERIFY inventory + terminal predicate ✓ →, t ij ←, t ij Figure 1: OneSELF+REQschema carries sender-local task consequences forward and peer-local capability consequences back before shared grounded execution. exactly as the injected task consequence specifies. Multi-step com- mitments improve held-out-template success by 6.9 points while reducing model decisions by 32%. Across 128 held-out clusters, Short DSL matches JSON and controlled free-form communication in closed-loop quality while reducing peer traffic by 92.8% and me- dian time-to-commitment by 68.2% relative to free-form. We make three contributions: • Private information. We characterize paired local ambigu- ity and show how the executable consequence of a private fact crosses the agent boundary, forward in a request or back through bounded feedback. • Executable commitments. GenCoord represents sender and peer obligations in one multi-stepSELF+REQobject; Short DSL preserves that object from proposal and resolu- tion through grounded execution. •Mechanism and systems evidence. Counterfactual in- terventions establish a content-to-route causal link in both directions; horizon, communication-surface, and backend experiments show how the same grounded object can be extended, encoded, and formed efficiently. 2 Related Work Commitments and task allocation. Joint-intention theory, Shared- Plans, and STEAM model teamwork through shared goals, partial plan knowledge, and communication decisions [7,12,22]. Contract Net, multi-robot task allocation, and consensus-based auctions co- ordinate through bids, utilities, contracts, or assignments [5,10,20]. Azorus combines formal commitments, information protocols, and BDI programming [6]. We use commitment operationally: a re- solvedSELF+REQobject assigns sender and peer task obligations that are discharged by verified handoff and terminal completion. Embodied and Minecraft collaboration. Voyager builds an exe- cutable code-skill library for open-ended single-agent learning in Minecraft [23]. RoCo uses LLM dialogue for multi-robot task and waypoint planning, with feedback from a motion planner [17]. MindCraft examines situated theory-of-mind dialogue [1]; MindA- gent evaluates coordination and scheduling [11]; TeamCraft pro- vides multimodal collaborative tasks [16]; and MINDcraft intro- duces the MineCollab benchmark for natural-language, action- by-action collaboration [25]. VillagerAgent and CausalMACE or- ganize longer execution through graph-structured dependencies and causal planning [2,8]. Gated Coordination decides when local events should escalate to shared coordination [14], while Ticking- Collab studies time-sensitive complementary collaboration [26]. GenCoord studies what crosses the coordination boundary: a multi- step task object that binds local evidence to peer execution and handoff consequence. Communication content and representation. Differentiable com- munication and bottleneck objectives learn task-specific channels end to end [9,21,24]. Alternative formats can improve LLM rea- soning and communication [3]; Optima jointly optimizes communi- cation quality and cost [4]; and OPTiMACS learns task-aware mes- sage representations [13]. AgenticCache removes repeated planning from the critical path through reusable transitions [15]. These lines study when agents communicate and how messages are encoded; GenCoord isolates what the peer must receive: an inspectable task 2 consequence whose execution can be intervened on and verified end to end. 3 Coordination under Private Information 3.1 Local Contexts LetA=푎 1 , . . .,푎 푛 be a team. At coordination round푡, agent푎 푖 has local context 푥 푡 푖 =(표 푡 푖 ,ℎ 푡 푖 ,푚 푡 푖 ), where표 푡 푖 is its observation,ℎ 푡 푖 its execution history, and푚 푡 푖 received task messages. Agents share an executable priorKcontaining a skill ontology, task structure, typed arguments, and grounding constraints. Instance goals, capabilities, inventories, and bindings remain local until their task consequences cross a coordination boundary. 3.2 Paired Ambiguity Let푧denote a task instance andΠ ★ (푧;K) ⊆Π(K)the feasible goal-reaching paths allowed by the shared prior. A coordinator must form some ˆ 휋 ∈Π ★ (푧;K)from information distributed across local contexts. The path-determining fact induces an execution- relevant binding훽(푧)over the fields that select actor, handoff object, destination, and continuation. Under the fixed priorKand canon- ical schema used here, a cross-boundary object is coordination- sufficient when it identifies a resolved route inΠ ★ (푧;K). GenCoord communicates훽(푧)together with the role-local paths that discharge it. Proposition 1 (Paired local ambiguity). Consider equiprob- able instances푧 1 ,푧 2 and an agent푎 푖 with identical model-visible contexts푥 푖 (푧 1 )= 푥 푖 (푧 2 ). Let퐹 푘 :=Π ★ (푧 푘 ;K). If퐹 1 ∩ 퐹 2 =∅, then any푎 푖 -local policy whose output distribution is identical under the two views has pairwise expected success at most 1/2. Proof sketch. Let휇be the common output distribution. Since퐹 1 ∩퐹 2 = ∅,휇(퐹 1 ) + 휇(퐹 2 ) ≤1, and the equiprobable success is at most 1 2 휇(퐹 1 )+ 1 2 휇(퐹 2 ) ≤ 1 2 . Deterministic policies are point-mass special cases. The proposition characterizes whichever endpoint lacks the path- determining fact. In the main forward suites, the receiver cannot recover the active binding from its local view by construction. In the Goal×Capability diagnostic, paired requester views are identical while the peer capability changes the feasible actor, handoff object, and suffix. 3.3 Commitment Object and Resolution A grounded task is a tuple휏=(푎,푘,v,ℓ,푃)containing an actor푎, skill푘, typed argumentsv, grounding locationℓ, and predecessor set푃. LetT ∗ K denote finite sequences supported byK. A sender proposes 푞 푡 푖 =(푠 푡 푖 ,푟 푡 푖→푗 ), 푠 푡 푖 ,푟 푡 푖→푗 ∈ T ∗ K , where푠 푡 푖 is its proposed self path and푟 푡 푖→푗 the requested peer path. The same canonical schema supports two resolution directions. Forward resolution. When the sender holds the deciding fact, the receiver observes the delivered request and generates a down- stream self path푢 푡 푗 . The joint object is 퐶 →,푡 푖푗 = Resolve → (푞 푡 푖 ,푢 푡 푗 ). Resolve → returns a commitment only when the receiver identity and normalizedSELFsuffix realize the request, handoff fields align, and predecessor links admit an acyclic merge. Feedback resolution. When the peer holds the deciding ca- pability, it returns휌 푡 푗→푖 ∈ Accept, Reject, Counter(훼), with훼 selected from bounded executable alternatives. The requester then produces a revised proposal 푞 푡 푖|휌 =(푠 푡 푖|휌 ,푟 푡 푖→푗|휌 ), and 퐶 ←,푡 푖푗 = Resolve ← 푞 푡 푖 ,휌 푡 푗→푖 ,푞 푡 푖|휌 . Accept requires the revision to preserve the requested branch, Counter requires it to realize the selected alternative, and Reject yields no commitment. Missing or conflicting obligations also yield no resolved object. Resolution aligns role, route, and handoff across the initial and revised proposals; the checker validates typed fields and the materializer instantiates the dispatch plan. 4 GenCoord 4.1 Local Proposal Generation A local autoregressive model퐺 휃 receives푥 푡 푖 andK, generates a string ˆ 푦 푡 푖 , and parses it into the initial proposal: ˆ 푦 푡 푖 =퐺 휃 (푥 푡 푖 ,K), 푞 푡 푖 = Parse( ˆ 푦 푡 푖 ) ∈ Q∪⊥. The input explicitly identifies the decision agent, local observa- tion, history, incoming messages, peer, and shared task prior. The model maps local semantics to the task consequence훽(푧), binds ac- tive objects and destinations, composes multi-step paths, allocates transformations, and chooses the inter-agent cut represented by SELF+REQ. 4.2 Generative Task-Path Composition The shared prior supplies legal skills and coarse dependencies; the learned backend instantiates the current path. For a bilateral episode, write a feasible joint path as a sender prefix, an inter-agent handoff, and a receiver suffix. GenCoord selects the participating actor for each transformation, grounds objects and destinations, and places the cut between role-local paths. This cut is task dependent: Destination changes where the suffix terminates; Recipe changes the transformation and handoff object; Allocation changes the actor and residual work; Active Branch changes the continuation released after handoff. The resulting object carries more than an atomic assignment. It records the local steps required before the boundary, the peer obligation activated at the boundary, and the dependencies that connect both. A sender-local fact selects and transmits the suffix directly. A peer-local capability consequence can move the cut, changing which prefix the requester must complete before handoff. Both cases therefore use the same semantic operation—composition of complementary role-local paths around an explicit coordination edge. 4.3 Resolution across the Agent Boundary Forward resolution. This is the main protocol used by the request, horizon, representation, and factor experiments. The sender gen- erates푞 푡 푖 =(푠 푡 푖 ,푟 푡 푖→푗 ) . After receiving푟 푡 푖→푗 , the receiver makes the 3 Table 1: Capability-conditioned commitment rewrite. The matched rows share the requester view and initial proposal; the counterfactual condition injects the paired response. Peer mode / response Actor Handoff item Peer suffix Raw processor / Accept 퐵oak planks craft table→ deposit Finished receiver / Counter 퐴crafting table deposit crafting table second learned call: ˆ 푦 푡 푗 =퐺 휃 (푥 푡 푗 ⊕ 푟 푡 푖→푗 ,K), 푢 푡 푗 = Parse( ˆ 푦 푡 푗 ), where푢 푡 푗 contains the receiver’s downstreamSELFpath. The canon- ical resolver joins sender and receiver obligations into퐶 →,푡 푖푗 under the role, path, handoff, and dependency conditions above. Feedback resolution. The Goal×Capability diagnostic uses the reverse information direction. A transparent capability policy maps the requested suffix and peer-local capability to Accept, Reject, or Counter(훼)without a model call. For accepted or countered proposals, the requester performs a second learned call: ˆ 푦 푡 푖|휌 =퐺 휃 (푥 푡 푖 ⊕ 푞 푡 푖 ⊕ 휌 푡 푗→푖 ,K), 푞 푡 푖|휌 = Parse( ˆ 푦 푡 푖|휌 ). The resolver then forms퐶 ←,푡 푖푗 from the initial proposal, response, and revised proposal under the conditions in Section 3.3. The bounded response communicates the capability consequence for the current request and can move the inter-agent cut by changing the transformation actor, handoff object, and continuation. Because the response is explicit, counterfactual feedback can be injected while the requester view, initial proposal, executable world, and two-call schedule remain fixed. Table 1 shows the affected fields. 4.4 Short DSL The peer-facing grammar is SELF <task> [ > <task> ...] REQ <agent> <task> [ > <task> ...] where each task is a hierarchical skill path with typed arguments. Short DSL has four properties. Role completeness. A sender output couples its proposed self path with the requested peer contribution; a receiver output records the downstream obligation it accepts. Semantic sufficiency. Actor, skill path, object, quantity, desti- nation, binding, and dependency order are explicit because they determine executable behavior. Compositional horizon. Variable-length paths express acqui- sition, transformation, handoff, and deposit in one commitment, allowing the model to compose multi-step paths before acting. Deterministic grounding. For every legal object under the fixed prior and canonical schema, parsing yields a canonical object and the codec preserves task semantics: Decode K (Encode K (푞)) ≡ sem 푞, 푞 ∈ Q valid (K). Here≡ sem denotes equality of normalized ordered tasks, roles, typed arguments, bindings, destinations, and dependencies. The schema carries a proposal before resolution and role-local obligations after- ward, with dynamic arguments attached to the consuming skill. Operational commitment semantics. A resolved object as- signs role-specific obligations with observable discharge: the sender prefix closes at verified handoff, and the peer suffix closes at termi- nal completion. Accept preserves the division of work; Counter changes its task fields. 4.5 Commitment Backends Direct Short DSL predicts the complete role-local path at both learned stages. Factor-Code + Rule instead predicts one stage- specific binding code at the sender and one at the receiver; a de- terministic composer expands those codes through the shared task structure into the same canonical Short DSL object. Both backends use the same model-visible context, two-stage forward schedule, peer-facing interface, and grounded execution stack. When a code identifies one branch of the task structure, composition recovers its actor, path, object, destination, and dependency fields. Exact target-field names appear in the supplement. 4.6 Grounded Execution The resolved commitment follows generate→ parse→ schema check→ materialize → compile→ execute→ verify. The checker validates the resolved commitment against a typed execution schema: agent identity, skill availability, arguments, quan- tities, bindings, destinations, and predecessor constraints. A pass- ing object is a validated commitment. The selected binding and shared task structure then canonically materialize an equivalent dispatch plan, which the compiler lowers to Mineflayer skills while preserving dependency order. In the running example, validation preserves the selected actor and either the oak-planks or crafting- table handoff before materialization. Handoff succeeds only when the recipient inventory reflects the intended item and quantity; the episode succeeds only when the terminal world predicate holds. Figure 2 shows this runtime closure. 5 Experimental Setup 5.1 Environment and Tasks We evaluate on the official Minecraft Java 1.21.4 server with Mine- flayer 4.37.1. Each episode contains two agents, local observations, a shared skill ontology and task prior, and a mandatory in-world handoff. The environment is static and communication reliable, isolating how distributed task facts enter a joint plan. Four families vary distinct commitment fields: Destination changes the target location; Recipe changes the transformation and handoff item; Al- location changes the actor and remaining work; Active Branch changes the downstream continuation. Each family contains two templates. Figure 3 summarizes the coverage; complete schemas and bindings appear in the supplement. 4 1 RESOLVED COMMITMENT 2 CHECK + MATERIALIZE 3 COMPILE + EXECUTE 4 VERIFY Resolved SELF+REQ Commitment SELF agent_a resource.obtain(q=4,item=oak_planks) → resource.deliver(q=4, item=oak_planks,to=agent_b) REQ agent_b craft.item(q=1,input=oak_planks, item=crafting_table) → resource.deliver(q=1, item=crafting_table, dst=order_chest) agent_a agent_b order_chest Schema Check ✓ agent identity ✓ skill availability ✓ typed arguments + quantity ✓ binding + destination ✓ predecessor constraints Canonical dispatch plan Dispatch plan Mineflayer skill calls In-world execution AB 4× agent_a (Steve) agent_b (Alex) Verification Handoff agent_binventory += 4 oak_planks ✓ Terminal order_chest contains 1 crafting_table ✓ Figure 2: Grounded closure from a schema-validated commitment through canonical materialization to verified execution. Four Task Families and Their Locally Underdetermined Commitment Fields AgentTraversal / stepActionable thinking (a.o.)Real prefix / dependency Candidate branches 1. DESTINATION2. RECIPE3. ALLOCATION4. ACTIVE BRANCH WHERE should the path terminate? A₁ Chest A A₂ Chest B Binding game: Chest A/B · Role: Steve A/B Field: Destination WHAT transformations are licensed (here)? B₁PLANKS (×4) B₂CRAFT STICK Binding game: Planks/Sticks · Chest/Crafting Table Field: Transformation + Hand/Turn WHO should do which work? E₁ Actor:A1 Remaining work: Deposit E₂ Actor:A2 Remaining work: Build Binding game: Deposit/Build · Rock/Wall Field: Actor + remaining work WHICH continuation remains active? ? branch-marking prefix here D₁ STORAGE branch D₂ WORK branch Binding game: Storage/Work · Depot/Marker Field: Downstream continuation Figure 3: Four Minecraft families vary the task consequence carried across the agent boundary. 5.2 Data and Training Targets are generated programmatically from task templates, sam- pled local facts, and canonical task specifications. Public Minecraft resources inform the ontology and scenario design. We use no language-model teacher or manually annotated reciprocal requests. Forward records contain two learned stages: a sender-local context paired with itsSELF+REQtarget, and a receiver context augmented with the deliveredREQpaired with its downstreamSELFtarget. The Goal×Capability diagnostic uses a separate requester-initial, transparent-response, and requester-revision dataset. Task templates yield 480 semantic training clusters under two role permutations and 1,920 forward rows: 960 sender-proposal rows and 960 receiver-after-request rows. Training uses two epochs and 240 optimizer steps; full optimization settings appear in the supplement. Input tokens are masked from the causal-LM loss. The single-step control adds 960 intermediate sender rows, for 2,880 rows and 360 optimizer steps. Controlled free-form receives 2,400 rows and 300 optimizer steps under the same two-epoch schedule. Main learned conditions use three independent seeds. The submission-scale representation pool contains 128 held- out semantic clusters—16 per template—with both role permuta- tions and three seeds, yielding 768 views per representation and 2,304 closed-loop episodes across the three communication surfaces. Mechanism evaluations use 160 clusters for request interventions, 80 held-out-template clusters for commitment horizon, and 60 un- seen binding combinations. The Goal×Capability suite contains 40 semantic clusters—two goals, two workcell modes, and ten world variants—organized as 20 matched capability-counterfactual pairs. A-only planning, correct feedback, counterfactual feedback, and centralized full information each evaluate all 40 clusters under two role permutations and three independently trained seeds: 240 episodes per condition and 960 total. The counterfactual condition injects the bounded response from the paired workcell mode while preserving the requester input, initial proposal, and executable 5 world. Semantic cluster remains the independent unit, with seed and role as repeated observations; the supplement additionally re- ports a 20-pair block-bootstrap sensitivity. A separate 128-cluster pool supports the matched backend comparison. The pools separate distinct transfers: new bindings within known templates, held-out templates, unseen factor cross-products, and unseen transform-order motifs. Each retains its own independent cluster count. 5.3 Comparators The representation comparison matches the Qwen3.5-0.8B base model, semantic clusters, canonical task fields, two-epoch bud- get, skill interface, checker, materializer, executor, and verifier. GenCoord–DSL emits Section 4.4’s grammar; GenCoord–JSON se- rializes the same fields; controlled multi-turn free-form expresses the same bilateral task semantics in natural language until a shared extractor recovers the commitment. It is a communication-surface comparator under the same model, task, and executor; MINDcraft and MineCollab remain system-level related work. Mechanism conditions removeREQ, replace it with an executable same-template alternative, inject counterfactual feedback from the paired capability mode, or shorten the commitment horizon. Rule- Minimal-Reqest forwards the sender’s private binding with zero model calls and uses the public composer to materialize both agents’ paths. The Explicit-Factor Composer receives canonical factors directly. Factor-Code + Rule uses the same 1,920 rows, three seeds, two epochs, 240 steps, and forward stages as Direct Short DSL. In this structured suite, model-visible private-fact labels align one-to- one with the shared binding codebook; generated target length is the measured representation difference. Each comparison changes one scientific layer. Request interven- tion changes delivered task content while preserving schedule and surface validity. Horizon changes whether the joint route is com- mitted before execution or regenerated at an intermediate state. Short DSL versus JSON is a serialization comparison over the same canonical fields, two learned stages, and execution stack. Controlled free-form is an end-to-end communication-surface comparison un- der the same base model, task, and executor; it also changes turn structure, context growth, commitment extraction, calls, and train- ing budget. Backend comparison changes the learned target while preserving the peer-facing Short DSL message. Centralized full information changes where local contexts are assembled. 5.4 Metrics and Statistics Terminal success requires the world-state goal predicate after the complete episode. Raw validity records parsing. Commitment va- lidity checks actors, skills, arguments, bindings, and dependencies against the canonical task schema and, when present, the deliv- ered request or feedback. In feedback interventions this validity is response-conditioned; terminal success separately tests consis- tency with the unchanged true-world capability. Verified handoff requires the intended inventory transfer. Online metrics are model calls, input/output tokens, peer-directed wire bytes, and time-to- commitment (TTC). For structured methods, wire bytes count the inter-agentREQpayload; for controlled free-form, they sum all agent-to-agent dialogue before commitment extraction. Complete episode time ends at terminal readback and is reported descriptively. Calls, tokens, wire bytes, and TTC are measured on a 40-cluster same-card sample with hot batch-1 models on an NVIDIA RTX 4090D, totaling 720 episode runs and 1,560 model calls. Semantic cluster is the independent unit; seed and role views are repeated ob- servations. Paired comparisons use cluster-bootstrap 95% intervals, and all-success pools receive exact binomial lower bounds. 6 Results Private information creates a 50% ambiguity ceiling; task content selects the resolved path in both directions of the edge; and a longer commitment horizon removes online replanning. Under this mecha- nism chain, Table 2 reports the quality-matched headline result: all three communication surfaces complete 128/128 held-out clusters, while Short DSL has the lowest online coordination cost. 6.1 Feedback Content Selects Requester Revision The Goal×Capability suite contains 40 semantic clusters arranged as 20 matched capability-counterfactual pairs. Within each pair, the requester’s model-visible input and initial proposal are byte- identical while the peer’s private workcell mode changes the fea- sible actor, handoff object, and suffix. Four conditions evaluate all 40 clusters under two role permutations and three independently trained seeds, yielding 240 episodes per condition and 960 total: A- only planning, correct bounded feedback, counterfactual feedback, and centralized full information. Every seed reproduces the 50/100/0/100 profile with descriptive seed-level SD 0.0. All 960 runs are parse-valid, planning-complete, and fallback-free. Correct feedback and centralized full informa- tion each succeed on 240/240. A-only succeeds on 120/240 and chooses the wrong craft actor on the remaining 120. In the feed- back conditions, every resolved commitment is valid relative to the injected response: correct feedback also matches the true workcell, whereas counterfactual feedback is inconsistent with it and fails all 240 episodes with the wrong actor. Cluster-bootstrap effects are +50.0 points over A-only (95% CI[35,65]),+100.0 over counter- factual feedback (95% CI[100,100]), and 0.0 versus centralized full information (95% CI [0, 0]). The intervention isolates feedback semantics. With the requester view, initial proposal, executable world, and two-call schedule un- changed, final commitments follow counterfactual feedback in 240/240 episodes: craft actor, handoff item and count, and peer suffix match the paired workcell mode, while goal fields remain fixed. The bounded capability consequence therefore causally con- trols the inter-agent cut in this diagnostic. Centralized planning uses one call and aggregates a mean 956 B of state; feedback reso- lution uses two local calls and a mean 103 B response (p95 118 B). Figure 4(a) summarizes the causal and full-information references. 6.2 Delivered Binding Determines Peer Execution On 160 semantic clusters, the true multi-step request reaches 100% terminal success. RemovingREQwhile retaining the sender self- plan yields 50%; each template contains two balanced admissible 6 CorrectCFCentral.A-only 0 50 100 Terminal success (%) 100 0 100 50 Δ 100 pΔ 50 p (a) Feedback TrueAlt.RuleRemoved 100 0 100 50 Δ 100 pΔ 50 p (b) Request OverallDest.RecipeAlloc.Branch 0 50 100 Held-out success (%) +6.9 +9.2 +18.3 (c) Commitment horizon Single-stepMulti-step SingleΔMulti 0 1 2 3 Decisions / ep. 2.91 1.98 −0.93 −32% (d) Decision cost Figure 4: Mechanism evidence: feedback content selects requester revision, request content selects peer execution, and longer commitments reduce online decisions. bindings, making this a construction-level ambiguity ceiling. Re- placing the request with the executable alternative from the same template—the request that would be correct under the other private fact—preserves message presence, protocol schedule, schema, ap- proximate length, and call count, yet success falls to 0%. The paired gains are+50.0 points over request removal (95% CI[42.5,57.5]) and +100.0 points over the same-template alternative (95% CI[100,100]). A sender-local deterministic rule also reaches 100% with zero model calls by forwarding the correct private binding; the public composer materializes the two role-local paths. Under template shift, the rule remains at 100% while GenCoord reaches 98.1%, a paired difference of−1.9 points with 95% CI[−4.2,−0.2]. Receiver execution follows the delivered binding one-to-one whenever an executable plan is formed: same-template alternatives redirect all 960 confirmatory seed-role episodes and all 471 executable held-out episodes to the alternative path. GenCoord’s nine held-out fail- ures all occur before executable-plan formation, with zero wrong- binding failures. Within this intervention, the delivered binding is the causal control variable for peer execution; the backend and protocol surface determine whether a complete executable commit- ment is formed. Figure 4(b) summarizes the four conditions. 6.3 Multi-Step Commitments Reduce Online Decisions Under their respective closed-loop training protocols, multi-step commitments reach 98.1% held-out template success, compared with 91.3% for the separately trained single-step controller; the paired difference is 6.9 points with a 95% interval of[2.9,10.8]. Multi-step uses 1.98 model decisions per episode versus 2.91, a 32% reduction; the paired difference (multi-step minus single-step) is −0.931 with 95% CI[−0.971,−0.892]. The advantage persists even though the single-step model receives 2,880 supervision rows and 360 optimizer steps, compared with 1,920 rows and 240 steps for multi-step, including an explicit intermediate sender-after-obtain stage. The gain concentrates where the hidden fact changes actor or continuation: Allocation improves from 83.3% to 92.5%, and Active Branch from 81.7% to 100%, while both variants reach 100% on Destination and Recipe. The result identifies commitment horizon as an online control variable: committing farther both improves transfer and removes a replanning stage. Figure 4(c) summarizes success and online decisions. 6.4 Quality-Matched Coordination Cost Across 2,304 closed-loop episodes, Short DSL, JSON, and controlled free-form each complete 128/128 held-out semantic clusters with 100% raw validity, commitment validity, and verified handoff and with no repair or fallback. The exact-binomial 95% lower bound is 0.972, and role-swap success differs by 0.0 for every surface. This pool locks closed-loop quality before comparing online represen- tation cost. Table 2 separates the 128-cluster quality and episode measurements from the 40-cluster same-card online-cost sample. With closed-loop quality fixed, Short DSL improves on controlled free-form on every reported online cost. Free-form receives 2,400 training rows and 300 updates, versus 1,920 and 240 for Short DSL; Short DSL reduces calls by 20%, output tokens by 70.4%, wire bytes by 92.8%, median TTC by 68.2%, and descriptive median episode time by 17.4%. Relative to JSON, it reduces output tokens by 70.6%, wire bytes by 74.9%, median TTC by 67.9%, and descriptive median episode time by 17.0%. The structured rows share sender-proposal and receiver-after-request calls and canonical fields, isolating seri- alization cost. Free-form measures the full surface, including multi- turn context, extraction, calls, and training budget. Median per-call latency is 1.14 seconds for Short DSL, 3.53 for JSON, and 3.27 for free-form; the shared executor takes approximately 22.6 seconds. 6.5 Specialized Commitment Backends Composition reference. On 60 unseen binding cross-products, an enumerated case table reaches 0%, while the Explicit-Factor Composer and Direct Short DSL each reach 100%, confirming factor- wise construction beyond memorized complete cases. Matched model backends. Direct Short DSL predicts complete role-local paths; Factor-Code + Rule predicts stage-specific bind- ing codes and delegates path materialization to the deterministic composer. Both complete 128/128 semantic clusters (768/768 seed- role views) with perfect parsing, commitment validity, and verified handoff. On the separate 40-cluster same-card subset, Factor-Code + Rule uses slightly longer input context but reduces mean output by 75.5% and TTC p50 from 2.453 to 0.824 seconds. Both transmit the same 76.6-byte peer request. Table 3 reports the matched profile. 7 Table 2: Quality-matched communication surfaces. Quality and episode time use 128 held-out clusters; online cost uses the 40-cluster same-card subset. Wire counts the peer request for structured methods and all inter-agent dialogue for free-form. MethodSuccess↑Calls↓Input tok.↓Output tok.↓Wire (B)↓TTC p50/p95 (s)↓Episode p50/p95 (s)↓ GenCoord–DSL128/1282.00949.178.676.32.27 / 2.6224.86 / 27.06 GenCoord–JSON128/1282.001154.7267.6303.47.07 / 7.8629.94 / 31.82 Controlled free-form128/1282.501585.2265.81061.17.13 / 7.8630.09 / 31.92 Table 3: Matched model backends for the same peer-facing commitment interface. Quality uses 128 clusters; cost uses a separate 40-cluster same-card subset. MetricDirect Short DSL Factor-Code + Rule Success↑128/128128/128 Input tok.↓948.9980.2 Output tok.↓79.119.4 Wire (B)↓76.676.6 TTC p50/p95 (s)↓2.453 / 2.7230.824 / 0.997 The byte-identical peer payload separates the coordination in- terface from its model-side realization: the latency gain comes from shortening the autoregressive target while preserving the same validated commitment. 6.6 Task-Structure Visibility Across 96 diagnostic clusters, Full DAG and Skeleton views each preserve the familiar post-handoff motif at 100%; Skeleton removes instance-specific predecessors and edges while retaining coarse stages. Node-only additionally removes stage cues and changes node arrangement, reducing familiar-motif success to 18.2%. Both unseen transform-order motifs remain at 0% under all views. Coarse order therefore supports familiar path composition without the complete instance DAG, while new transformation orders remain the structural boundary; the full matrix appears in the supplement. 7 Discussion Task consequence as the coordination primitive. The two interven- tion families expose the same content-to-route causal link in op- posite directions: replacingREQredirects receiver execution, while counterfactual feedback changes requester actor, handoff object, and suffix. The zero-call rule reproduces the content effect, iden- tifying the binding as the cross-boundary control variable in the current task families; GenCoord couples it to the executable paths and discharge conditions that realize the joint route. Commitment horizon as online control. A skill-path commitment fixes both who acts and how far the route proceeds before an- other model decision.SELF+REQexposes the sender prefix, handoff boundary, peer suffix, typed arguments, and dependencies. Multi- step commitments remove an intermediate deliberation stage and improve template-shift success despite the single-step controller’s additional supervision, linking horizon directly to online replan- ning. Stable semantics, optimized realization. Tables 2 and 3 expose two orthogonal layers. Surface compression replaces JSON or di- alogue with Short DSL; formation compression replaces full-path decoding with a stage code and deterministic composition. Rule, factor, and direct backends all terminate at the same peer-facing interface. At that boundary, the typed checker produces a validated commitment, materialization instantiates the dispatch plan, and world predicates verify discharge. Explicit task fields therefore sup- port causal intervention, modular backend replacement, and failure localization without changing coordination semantics. Shared structure and information interfaces. Coarse stages pre- serve a familiar handoff motif after instance-specific edges are removed, whereas new transform orders remain unresolved. Let 푏(푧)be serialized byte length,푢 푡 푖 uploaded local state,푑 푡 푖 dispatched decision,퐸 푡 active coordination edges,훾 푡 푖푗 an edge exchange, and 푅 푐 ,푅 푙 the respective round counts: 퐵 central = 푅 푐 ∑︁ 푡=1 푛 ∑︁ 푖=1 [푏(푢 푡 푖 )+푏(푑 푡 푖 )], 퐵 local = 푅 푙 ∑︁ 푡=1 ∑︁ (푖,푗)∈퐸 푡 푏(훾 푡 푖푗 ). Centralized traffic follows synchronized state volume, participating agents, and rounds; local traffic follows active edges, commitment size, and local rounds. Both interfaces resolve all 40 Goal×Capabil- ity clusters across three seeds, while exposing different information flows. Limitations. The evaluation covers bilateral coordination over a shared executable prior in static Minecraft with reliable messaging. Dynamic multi-edge consistency and open-ended task decomposi- tion remain outside the current evidence. 8 Conclusion Joint skill paths become ambiguous when their determining facts are distributed across agents. GenCoord carries each fact’s exe- cutable consequence in aSELF+REQcommitment: requests transmit sender-local bindings, while bounded feedback returns peer-local capability consequences. Counterfactual interventions make re- ceiver execution and requester revision follow the delivered task consequence in their respective directions. Multi-step commitments reduce online decisions and improve held-out-template success. At matched closed-loop quality, Short DSL lowers every reported on- line cost relative to controlled free-form communication, while a factor-coded backend accelerates the same peer-facing interface. Skill-path commitments thus connect local generative reasoning to verified multi-agent action. 8 References [1]Cristian-Paul Bara, Sky CH-Wang, and Joyce Chai. 2021. MindCraft: Theory of Mind Modeling for Situated Dialogue in Collaborative Tasks. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 1112–1125. doi:10.18653/v1/2021.emnlp-main.85 [2]Qi Chai, Zhang Zheng, Junlong Ren, Deheng Ye, Zichuan Lin, and Hao Wang. 2025. CausalMACE: Causality Empowered Multi-Agents in Minecraft Coopera- tive Tasks. In Findings of the Association for Computational Linguistics: EMNLP 2025. Association for Computational Linguistics, 14410–14426. doi:10.18653/v1/ 2025.findings-emnlp.777 [3]Weize Chen, Chenfei Yuan, Jiarui Yuan, Yusheng Su, Chen Qian, Cheng Yang, Ruobing Xie, Zhiyuan Liu, and Maosong Sun. 2024. Beyond Natural Language: LLMs Leveraging Alternative Formats for Enhanced Reasoning and Communi- cation. In Findings of the Association for Computational Linguistics: EMNLP 2024. Association for Computational Linguistics, 10626–10641. doi:10.18653/v1/2024. findings-emnlp.623 [4] Weize Chen, Jiarui Yuan, Chen Qian, Cheng Yang, Zhiyuan Liu, and Maosong Sun. 2024. Optima: Optimizing Effectiveness and Efficiency for LLM-Based Multi-Agent System. arXiv preprint arXiv:2410.08115 (2024). [5]Han-Lim Choi, Luc Brunet, and Jonathan P. How. 2009. Consensus-Based De- centralized Auctions for Robust Task Allocation. IEEE Transactions on Robotics 25, 4 (2009), 912–926. doi:10.1109/TRO.2009.2022423 [6] Amit K. Chopra, Matteo Baldoni, Samuel H. Christie V, and Munindar P. Singh. 2025. Azorus: Commitments over Protocols for BDI Agents. In Proceedings of the 24th International Conference on Autonomous Agents and Multiagent Systems. International Foundation for Autonomous Agents and Multiagent Systems, 490– 499. https://w.ifaamas.org/Proceedings/aamas2025/pdfs/p490.pdf [7]Philip R. Cohen and Hector J. Levesque. 1991. Teamwork. Noûs 25, 4 (1991), 487–512. doi:10.2307/2216075 [8] Yubo Dong, Xukun Zhu, Zhengzhe Pan, Linchao Zhu, and Yi Yang. 2024. Vil- lagerAgent: A Graph-Based Multi-Agent Framework for Coordinating Complex Task Dependencies in Minecraft. In Findings of the Association for Computational Linguistics: ACL 2024. Association for Computational Linguistics, 16290–16314. doi:10.18653/v1/2024.findings-acl.964 [9]Jakob Foerster, Ioannis Alexandros Assael, Nando de Freitas, and Shimon White- son. 2016. Learning to Communicate with Deep Multi-Agent Reinforcement Learning. In Advances in Neural Information Processing Systems, Vol. 29. [10]Brian P. Gerkey and Maja J. Matarić. 2004. A Formal Analysis and Taxonomy of Task Allocation in Multi-Robot Systems. The International Journal of Robotics Research 23, 9 (2004), 939–954. doi:10.1177/0278364904045564 [11] Ran Gong, Qiuyuan Huang, Xiaojian Ma, Yusuke Noda, Zane Durante, Zilong Zheng, Demetri Terzopoulos, Li Fei-Fei, Jianfeng Gao, and Hoi Vo. 2024. MindA- gent: Emergent Gaming Interaction. In Findings of the Association for Compu- tational Linguistics: NAACL 2024. Association for Computational Linguistics, 3154–3183. doi:10.18653/v1/2024.findings-naacl.200 [12]Barbara J. Grosz and Sarit Kraus. 1996. Collaborative Plans for Complex Group Action. Artificial Intelligence 86, 2 (1996), 269–357. doi:10.1016/0004-3702(95) 00103-4 [13]Shashwat Gupta, Anson Bastos, Mayukh Das, Supriyo Ghosh, Nagarajan Natara- jan, Chetan Bansal, and Saravan Rajmohan. 2026. Learning Optimal Message Representations for Agentic Communication. In Findings of the Association for Computational Linguistics: ACL 2026. Association for Computational Linguistics, 28849–28879. doi:10.18653/v1/2026.findings-acl.1441 [14]HuaDong Jian, Chenghao Li, Haoyu Wang, Jiajia Shuai, Jinyu Guo, Yang Yang, and Chaoning Zhang. 2026. Gated Coordination for Efficient Multi-Agent Col- laboration in Minecraft Game. arXiv preprint arXiv:2604.18975 (2026). https: //arxiv.org/abs/2604.18975 [15]Hojoon Kim, Yuheng Wu, and Thierry Tambe. 2026. AgenticCache: Cache-Driven Asynchronous Planning for Embodied AI Agents. In Proceedings of Machine Learning and Systems, Vol. 8. [16] Qian Long, Zhi Li, Ran Gong, Ying Nian Wu, Demetri Terzopoulos, and Xiaofeng Gao. 2024. TeamCraft: A Benchmark for Multi-Modal Multi-Agent Systems in Minecraft. arXiv preprint arXiv:2412.05255 (2024). https://arxiv.org/abs/2412. 05255 [17]Zhao Mandi, Shreeya Jain, and Shuran Song. 2024. RoCo: Dialectic Multi-Robot Collaboration with Large Language Models. In 2024 IEEE International Conference on Robotics and Automation (ICRA). IEEE, 286–299. doi:10.1109/ICRA57147.2024. 10610855 [18]PrismarineJS. 2026. Mineflayer: Create Minecraft Bots with a High-Level JavaScript API. Software repository. Version 4.37.1 used in the project; ac- cessed 2026-08-08. https://github.com/PrismarineJS/mineflayer [19]Qwen Team. 2026. Qwen3.5-0.8B. Hugging Face model card. Accessed 2026-08-08. https://huggingface.co/Qwen/Qwen3.5-0.8B [20] Reid G. Smith. 1980. The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver. IEEE Trans. Comput. C-29, 12 (1980), 1104–1113. doi:10.1109/TC.1980.1675516 [21]Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. 2016. Learning Multia- gent Communication with Backpropagation. In Advances in Neural Information Processing Systems, Vol. 29. [22] Milind Tambe. 1997. Towards Flexible Teamwork. Journal of Artificial Intelligence Research 7 (1997), 83–124. doi:10.1613/jair.433 [23] Guanzhi Wang, Yuqi Xie, Yunfan Jiang, Ajay Mandlekar, Chaowei Xiao, Yuke Zhu, Linxi Fan, and Anima Anandkumar. 2023. Voyager: An Open-Ended Embodied Agent with Large Language Models. arXiv preprint arXiv:2305.16291 (2023). https://arxiv.org/abs/2305.16291 [24]Rundong Wang, Xu He, Runsheng Yu, Wei Qiu, Bo An, and Zinovi Rabinovich. 2020. Learning Efficient Multi-agent Communication: An Information Bottleneck Approach. In Proceedings of the 37th International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 119). PMLR, 9908–9918. [25] Isadora White, Kolby Nottingham, Ayush Maniar, Max Robinson, Hansen Lille- mark, Mehul Maheshwari, Lianhui Qin, and Prithviraj Ammanabrolu. 2025. Col- laborating Action by Action: A Multi-agent LLM Framework for Embodied Rea- soning. arXiv preprint arXiv:2504.17950 (2025). https://arxiv.org/abs/2504.17950 [26]Juheon Yi, Jinglu Wang, Xiaoyi Zhang, and Yan Lu. 2026. Multi-agent Framework for Time-Sensitive Complementary Collaboration in Minecraft. arXiv preprint arXiv:2606.15684 (2026). https://arxiv.org/abs/2606.15684 9 GenCoord / Supplementary Material1 Supplementary Material GenCoord: Skill-Path Commitments under Private Information Reader map. Protocol definitions and exact resolution appear in Sections S1 and S4; causal feedback evidence appears in Section S10; the grounded trace and cost results appear in Sections S4 and S5; backend formation and naturalized private-fact results appear in Section S8; reproducibility materials appear in Section S11. S1 Protocol Lifecycles and Stage Attribution Takeaway. Forward request resolution and bounded feedback resolution use the same executable commitment object while carrying task-relevant consequences of local information in opposite directions. Figure S1 gives the protocol-level reading order for the two routes. Table S1 aligns each route with its learned stages and transparent operations, while Table S2 fixes the symbols used by Algorithms S1–S2. Forward request / bounded feedback Two left-to-right protocol lanes terminate at the same checked commitment interface. Forward request resolution sender-local binding / delivered REQ / one checked object 01 02 sender private binding request bytes cross the wire delivered REQ + learned suffix contract compatibility verifi ed executable commitment CALL 01 SELF resource.obtain(q=8,item=oak_planks) > resource.deliver(q=8,item=oak_planks,to=agent_b) REQ agent_b craft.item(bind=WORK_BRANCH,q=1,input=oak_planks,item=crafting_table) Bounded feedback resolution ACCEPT / COUNTER trigger call 02; REJECT closes the candidate 01 02 initial learned SELF + REQ peer-local workcell mode ACCEPT / COUNTER bounded response revised learned SELF + REQ contract compatibility checked commitment Parser-valid records FORWARD SELF resource.obtain(q=8,item=oak_planks) > resource.deliver(q=8,item=oak_planks,to=agent_b) REQ agent_b craft.item(bind=WORK_BRANCH,q=1,input=oak_planks,item=crafting_table) COUNTER counter_offer_id=CRAFT_AT_REQUESTER_HANDOFF_FINISHED SELF craft.item(q=1,input=oak_planks,item=crafting_table) > resource.deliver(q=1,item=crafting_table,to=agent_b) REQ agent_b resource.deliver(q=1,item=crafting_table,dst=order_chest) Written books mark learned commitment records; the name tag marks the bounded symbolic response identifier. Figure S1. Forward and bounded-feedback lifecycles ending in the same contract-validated commitment interface. The protocol result type is the tagged union R = (SUCCESS×C×D) ⊎ (NO_COMMITMENT×E ) ⊎ (FAIL×F ). We write its values as Success(C,D), NoCommitment(e), and Fail(f ). GenCoord / Supplementary Material2 Table S1. Lifecycle stages and learned-call attribution. Goal–Capability uses two learned calls on the evaluated Ac- cept/Counter branches; Reject terminates after the first call. For the factor backend,active_binding_idis emitted at sender_initial and accepted_binding_id at receiver_after_request. SettingFirst learned output / stage Boundary objectSecond learned output / stage Deterministic / non-learned operation Learned calls Main forward route sender_initial delivered REQ receiver_ after_request canonical joint resolution2 Goal– Capability requester_ initial bounded capability response requester_ after_response ACCEPT/COUNTER policy2 Single-step route sender_initial request and state transition sender_after_ obtain, then receiver task transitionepisode- dependent Factor backend active_ binding_id (sender) delivered REQ accepted_ binding_id (receiver) deterministic composer2 Table S2. Core notation used by Algorithms S1–S2. SymbolMeaning and domain A =a 1 ,...,a n ; i,j ∈1,...,n agent team and indices; protocol roles are written as snd, rcv, req, and peer K = (S,G, Θ, Γ)reusable executable prior: skill catalog S, public task DAG G, typed schema Θ, and grounding/checker contract Γ ξ pub , ω t , x t i public episode instantiation, current executable world state, and agenti’s model-visible local context at round t; ω t is visible only to the runtime verifier ˆy snd ,q snd ; ˆy rcv ,q rcv raw model strings and parsed sender/receiver proposals; q =⊥ denotes parse failure r snd→rcv , u rcv requested peer path and receiver-local realization suffix c peer , ρ, αpeer capability, bounded response, and selected counter_offer_id N path K , N prop K , Actorize canonical normalization for paths/proposals and explicit instantiation of an implicit task actor C, D, E, Fspaces of resolved commitments, dispatch plans, no-commitment reasons, and protocol/runtime failure codes Algorithm S1 Forward resolution Require: sender context x snd , receiver context x rcv , prior K, public episode instantiation ξ pub , executable world ω t 1: ˆy snd ← Generate(x snd ,K,ξ pub )▷ SELF+REQ 2: q snd ← Parse(ˆy snd ) 3: if q snd =⊥ then 4:return Fail(PARSE_FAILURE) 5: if ¬ContractCheck(q snd ,x snd ,K,ξ pub ) then 6:return Fail(CONTRACT_REJECT) 7: if |q snd .peer_requests|̸= 1 or q snd .peer_requests[0].requested_plan = [] then 8:return Fail(CONTRACT_REJECT) 9: r snd→rcv ← q snd .peer_requests[0]; deliver r snd→rcv 10: ˆy rcv ← Generate(x rcv ,K,ξ pub ,r snd→rcv ) 11: q rcv ← Parse(ˆy rcv ) 12: if q rcv =⊥ then 13:return Fail(PARSE_FAILURE) 14: if ¬ContractCheck(q rcv ,x rcv ,K,ξ pub ) or q rcv .self_plan = [] or q rcv .peer_requests̸= [] then 15:return Fail(CONTRACT_REJECT) 16: C ← Resolve → (q snd ,q rcv ,K,ξ pub ) 17: if C =⊥ then 18:return Fail(RESOLUTION_CONFLICT) 19: D ← Materialize(C,K,ξ pub ) 20: if D =⊥ then 21:return Fail(MATERIALIZATION_FAILURE) 22: status← ExecuteAndVerify(D,ω t ) 23: if status̸= SUCCESS then 24:return Fail(status) 25: return Success(C,D) GenCoord / Supplementary Material3 Algorithm S2 Bounded feedback resolution Require: requester context x req , peer capability c peer , prior K, public episode instantiation ξ pub , executable world ω t 1: ˆy 0 ← Generate(x req ,K,ξ pub ) 2: q 0 ← Parse(ˆy 0 ) 3: if q 0 =⊥ then 4:return Fail(PARSE_FAILURE) 5: if ¬ContractCheck(q 0 ,x req ,K,ξ pub ) then 6:return Fail(CONTRACT_REJECT) 7: if |q 0 .peer_requests|̸= 1 or q 0 .peer_requests[0].requested_plan = [] then 8:return Fail(CONTRACT_REJECT) 9: r req→peer ← q 0 .peer_requests[0] 10: ρ← ResponsePolicy(r req→peer ,c peer ,K,ξ pub ) 11: if ¬ResponseValid(ρ,r req→peer ,K,ξ pub ) then 12:return Fail(CONTRACT_REJECT) 13: if ρ = Reject then 14:return NoCommitment(ρ.reason_code) 15: ˆy 1 ← Generate(x req ,K,ξ pub ,q 0 ,ρ)▷ ACCEPT or COUNTER 16: q 1 ← Parse(ˆy 1 ) 17: if q 1 =⊥ then 18:return Fail(PARSE_FAILURE) 19: if ¬ContractCheck(q 1 ,x req ,K,ξ pub ) then 20:return Fail(CONTRACT_REJECT) 21: if |q 1 .peer_requests|̸= 1 or q 1 .peer_requests[0].requested_plan = [] then 22:return Fail(CONTRACT_REJECT) 23: if q 1 .peer_requests[0].target̸= r req→peer .target then 24:return Fail(CONTRACT_REJECT) 25: C ← Resolve ← (q 0 ,q 1 ,ρ,K,ξ pub ) 26: if C =⊥ then 27:return Fail(RESOLUTION_CONFLICT) 28: D ← Materialize(C,K,ξ pub ) 29: if D =⊥ then 30:return Fail(MATERIALIZATION_FAILURE) 31: status← ExecuteAndVerify(D,ω t ) 32: if status̸= SUCCESS then 33:return Fail(status) 34: return Success(C,D) The response policy selects among admissible alternatives from the grounded skill hierarchy. A response isρ∈ Accept, Reject, Counter(α). The bounded alternativeαis serialized in the E1/E2 artifact ascounter_offer_id; its observed counter value isCRAFT_AT_REQUESTER_HANDOFF_FINISHED.ACCEPTretains the proposed branch without an alternative,COUNTERnames exactly one admissible alternative, andREJECTcloses the candidate without a second generation or dispatch. Accepted and countered proposals both condition a second requester call. The transparent policy contributes zero learned calls and exposes the bounded capability consequence explicitly; Table S3 gives the complete response contract. The world stateω t remains outside the model and response-policy inputs and is accessed by execution and verification. Algorithms S1–S2 keep parsing, contract validation, resolution, materialization, and world discharge distinct. The terminal verifier returns one ofSUCCESS,EXECUTION_FAILURE,HANDOFF_FAILURE, orTERMINAL_FAILURE; earlier stages return the failure codes shown in the algorithms. S1.1 Resolver semantics As in the main paper, a grounded task isτ= (a,k,v,ℓ,P): actora, skill identifierk, typed argumentsv, grounding location ℓ, and predecessor set P. A resolved commitment has the common operational form C = (S i ,S j ,b,P C )∈C, whereS i andS j are the two normalized role-local paths,bis the selected binding identifier from the public codebook, andP C is the merged predecessor relation. Protocol-specific proposals, responses, and realization records remain in the trace; C contains only the operative obligations that enter materialization. The functionActorize(z,a) instantiates every implicit actor in pathzasa. We useN path K for canonical path normalization andN prop K for proposal normalization; both canonicalize aliases, typed defaults, grounded references, bindings, actors, and predecessor semantics. GenCoord / Supplementary Material4 Table S3. Finite response schema and stage-local failure codes. Decision / stage Valid fields or conditionProtocol consequence Acceptreason code; no counter_offer_idsecond requester call preserves the normalized initial branch Counter(α)reason code and exactly one admissible counter_offer_id=α second requester call realizes the selected bounded branch Rejectreason code; no counter alternative candidate closes; no second generation, commitment, or dispatch Invalid response unknown decision, forbidden field, missing alternative, or inadmissible ID CONTRACT_REJECT Parseraw string cannot be decoded PARSE_FAILURE Contractschema, role, skill, argument, target, or response check fails CONTRACT_REJECT Resolutionrealization, boundary fields, branch, or dependency merge conflicts RESOLUTION_CONFLICT Materialization validated commitment cannot instantiate a dispatch MATERIALIZATION_FAILURE World discharge runtime action, inventory handoff, or terminal predicate fails EXECUTION_FAILURE, HANDOFF_FAILURE, or TERMINAL_FAILURE Forward resolution. Define S snd = N path K (Actorize(q snd .self_plan, snd)), R rcv = N path K (Actorize(r snd→rcv .requested_plan, rcv)), U rcv = N path K (Actorize(q rcv .self_plan, rcv)). Within the evaluated canonical contract, the receiver realizes the request exactly when Realizes K (U rcv ,R rcv ) ⇐⇒ U rcv = R rcv .(S1) This equality preserves ordered task count, skills, typed values, bindings, actors, locations, and dependency semantics after normalization. Textual argument order and accepted aliases may differ. Canonical realization contains exactly the requested model-owned tasks; deterministic executor bookkeeping is added after resolution. LetHandoffCompatible K,ξ pub (S i ,S j ) denote compatibility of the producing/receiving actors, item, quantity, source/destination references, and boundary dependency under the public episode instantiation.Resolve → re- turns C → = (S snd ,U rcv ,b,P C ) only when (i) the receiver identity equals the request target; (i)q rcv has a nonemptySELFsuffix and no outbound request; (i) Equation S1 holds; (iv)HandoffCompatible K,ξ pub (S snd ,U rcv ) holds; and (v)byields a complete acyclic predecessor mergeP C . The merge preserves each role-local order, retains public predecessors on the selected branch, and adds a cross-agent dependency from the contract-validated handoff producer to the first consuming receiver node. The handoff becomes verified only after execution. Missing fields, incompatible handoffs, multiple selected branches, or cycles yield ⊥. Feedback resolution. LetB K be the public branch set,B:Q legal → B K ∪⊥extract the normalized branch selected by a proposal, andAltBranch K,ξ pub :I alt →B K ∪⊥map an admissible alternative identifier to its unique branch. The response-conditioned branch is B resp K,ξ pub (ρ,q 0 ) = B(q 0 ),ρ = Accept, AltBranch K,ξ pub (α), ρ = Counter(α), ⊥,ρ = Reject. For Accept, the second record may use accepted surface variants while preserving the normalized operative branch, target peer, and requester goal fields ofq 0 . ForCounter(α),q 1 preserves the requester goal fields and target peer, replaces the initial branch with the selected alternative, and realizes that branch in its operative peer request.Reject closes the candidate after the first call. For accepted and countered proposals, define S req = N path K (Actorize(q 1 .self_plan, req)), GenCoord / Supplementary Material5 R peer = N path K (Actorize(q 1 .peer_requests[0].requested_plan, peer)). The response itself is the peer-side resolution record, and the route proceeds directly to requester revision.Resolve ← requires B(q 1 ) = B resp K,ξ pub (ρ,q 0 ), HandoffCompatible K,ξ pub (S req ,R peer ), and a complete acyclic merge P C , then returns C ← = (S req ,R peer ,b,P C ). The protocol trace retainsq 0 andρas provenance, whileC ← contains only the resolved operative paths. The materializer constructs D = Materialize(C,K,ξ pub ). It preserves the complete high-level obligation set while instantiating validated actors, locations, task-instance identifiers, dependencies, and checker attachments. The compiler then adds deterministic navigation, inventory-transfer mechanics, timeouts, claims, and runtime metadata required to realize D as Mineflayer calls. S2 Task Suite and Programmatic Supervision Takeaway. Four forward-request task families place the path-determining binding in the sender’s local view; the delivered request disambiguates the receiver’s two admissible branches. Table S4 enumerates the eight templates and the commitment field changed by each balanced binding. Table S5 then shows how every template produces reciprocal sender-proposal and receiver-realization supervision. Table S4. Complete inventory of the eight core task templates and the commitment field varied by each binding. Family TemplateSource material Balanced bindingsBinding- dependent request path Changed field DestinationBuild Site A/Boak planks SITE_A/SITE_B build.component destination Destination Chest A/Bcobblestone CHEST_A/CHEST_B resource.deliver destination RecipeChest/Crafting Table oak planks CHEST/ CRAFTING_TABLE craft.itemtransform; handoff item RecipePlanks/Sticks oak planks PLANKS/ STICKS craft.item/ resource.deliver transform; handoff item Allocation Deposit/Build cobblestone BUILD/DEPOSIT build.component/ resource.deliver actor and remaining work Allocation Dual Buildoak planks ROOF/WALL build.component actor and component Active branch Active Order oak planks STORAGE/WORK craft.itemdownstream continuation Active branch Remaining Terminal oak planks DEPOT/ MARKER build.component/ resource.deliver downstream continuation Each template has two equally represented admissible bindings. The active binding appears in the sender-local private field and is absent from the receiver-local view. Paired binding worlds keep the receiver’s decision context matched until the request arrives, so removing the delivered request leaves the receiver unable to distinguish the two executable branches and produces the constructive 50% ceiling. Every instance requires a verified material handoff and a binding-specific terminal world-state predicate. Table S5. Programmatic supervision records for the forward route. Record stage Target objectRows Sender proposal multi-step SELF plus peer REQ960 Receiver after request downstream SELF; empty REQ960 Intermediate sender (single-step) next local action after obtain960 GenCoord / Supplementary Material6 Targets are instantiated from task-template specifications, sampled local facts, and canonical task objects. Public Minecraft resources support ontology and scenario design; the reciprocal targets come from the executable template contract. The data builder writes the model-visible context and target separately, then validates that each target maps back to the intended binding and terminal predicate. S3 Training and Checkpoint Provenance Takeaway. The checkpoint inventory makes stage coverage and optimization budget explicit. Multi-step training uses 1,920 rows and 240 updates per seed, while single-step receives an additional intermediate stage, 2,880 rows, and 360 updates. Tables S6 and S7 report the matched model configuration, stage counts, update budgets, data hashes, and checkpoint identities. Table S6. Training budgets and stage coverage per random seed. Model or condition Rows Stage countsEpochsSteps Seeds Multi-step / direct / surface 1,920 960 sender + 960 receiver2240 3 Self-plan-only1,920 960 sender + 960 receiver2240 3 Matched-SFT free-form 2,400 1,200 sender + 1,200 receiver2300 3 Single-step2,880 960 sender + 960 intermediate sender + 960 receiver2360 3 Factor backend1,920 960 sender code + 960 receiver code2240 3 Table S7. Shared training configuration and horizon-model provenance. FieldMulti-stepSingle-step (a) Common configuration Base modelQwen3.5-0.8B [Qwen Team(2026)]; tree 1ba0a4ab... OptimizerAdamW; LR 10 −5 ; weight decay 0.01; cosine schedule; warm-up 0.03; grad-norm 1.0 Batch / precisionmicro 4; accumulation 4; effective 16; bfloat16 on A100 40GB Length / decoding maximum 2,048; deterministic decoding; structured cap 256 tokens Objective / selection target-and-EOS causal loss; final-step checkpoint; DEV reserved for implementation checks (b) Model-specific data and checkpoint identity Training rows / updates 1,920 / 2402,880 / 360 Training-data SHA-256 prefix f31ba0b5 8bdbf220 Config SHA-256 prefix d965b3e7 d965b3e7 Seed IDs 2026073101–03 2026073101–03 Final checkpoint prefixes 66e1f8c0, 4b99b075, 48df1656 9c0bd589, f82d702f, 42705cf5 The project-side training record stores the complete data-manifest hash, configuration hash, base-model tree hash, seed, runtime versions, token exposure, checkpoint identity, and final checkpoint tree hash. The public arXiv artifact retains the scientific configuration and content hashes while removing host, scheduler, process, and private-path identifiers. S4 Commitment Schema and Grounded Runtime Takeaway. The model emits a compact symbolic commitment. A typed checker validates its semantics, a canonical materializer instantiates the dispatch plan, and the compiler lowers that plan to Mineflayer skills. S4.1 Short DSL grammar program ::= self_line NEWLINE req_line self_line ::= "SELF -" | "SELF " path GenCoord / Supplementary Material7 req_line ::= "REQ -" | "REQ " agent " " path path ::= task (" > " task)0,4 task ::= skill "(" [args] ")" args ::= arg ("," arg)* arg ::= key "=" value key ::= ident value ::= json_string | json_number | "true" | "false" | "null" | atom skill ::= control.wait | resource.obtain | resource.deliver | craft.item | transform.supply_input | transform.supply_fuel | transform.collect_output | build.component ident ::= [A-Za-z][A-Za-z0-9_]* agent ::= atom atom ::= [A-Za-z0-9_.:/+-]+ json_number ::= JSON numeric literal json_string ::= RFC 8259 double-quoted string The displayed BNF defines the canonical serializer output. Value recognition follows the displayed priority: a leading double quote starts a JSON string; a complete JSON number is recognized next; the three reserved literals precede the unquoted atom fallback. A quoted string is scanned atomically, so escaped quotes, commas, parentheses, and backslashes inside it do not terminate an argument or task. Standard JSON escapes are decoded before type checking, and unquoted atoms remain restricted to the ASCII class shown above. The canonical serializer emits exactly two LF-separated lines with normalized ASCII spacing and no leading or trailing whitespace; parser-tolerated noncanonical whitespace is outside the serializer invariant. The serializer emits the compact keysq,item,input,to,dst,bind,site,from,dst_role,loc, andstation. The parser also accepts their expanded compatibility names, includingcount/quantity,target_agent_ref/to_agent_id, destination,destination_role,from_agent_id,location_ref, andbinding_id, then canonicalizes them before checking. Syntactic parsing accepts identifier-shaped keys and primitive JSON values; the skill-specific contract checker rejects unknown keys, invalid types, unknown agents, inadmissible bindings, and missing required fields. The codec rejects duplicate keys, paths outside the evaluated catalog, invalid atoms, trailing text, and an empty requested plan. The parser requires exactly two lines and permits one to five ordered tasks per nonempty path. Quantities are positive integers;tonames a peer;dst,site,loc, andstationidentify grounding references;bindselects an admissible branch from the public codebook. The separator>encodes commitment precedence; compilation expands the validated path into low-level action calls.REQ -is a legal record whose parsedpeer_requestsvalue is the empty list; ⊥ is reserved for parse failure, while contract rejection is represented separately by CONTRACT_REJECT. LetY parse be syntactically admissible strings,Q parsed parsed proposal objects, andQ legal (K,ξ pub ) the subset satisfying the typed contract. Define Parse :Y parse →Q parsed ∪⊥,ContractCheck K,ξ pub :Q parsed →true, false. The legal-string domain is Y legal (K,ξ pub ) = y ∈Y parse : Parse(y)̸=⊥, ContractCheck K,ξ pub (Parse(y)) = true . Let Y canon (K) be canonical serializer outputs. For legal strings, the semantic decoder and encoder are Decode K,ξ pub (y) = N prop K (Parse(y)), y ∈Y legal (K,ξ pub ), Encode K :Q legal (K,ξ pub )→Y canon (K). For legal DSL strings y 1 ,y 2 , y 1 ≡ sem y 2 ⇐⇒ Decode K,ξ pub (y 1 ) = Decode K,ξ pub (y 2 ).(S2) For Q∈Q legal (K,ξ pub ), the tested codec invariant is Decode K,ξ pub (Encode K (Q)) = N prop K (Q).(S3) The invariant is defined and verified over the fixed schema, evaluated task families, and shared executable prior used in this study. Within that contract, the decoded object retains the ordered self path, target peer, ordered requested path, typed arguments, bindings, actors, grounding references, and dependency semantics required to determine the resolved route. GenCoord / Supplementary Material8 SELF resource.obtain(q=8,item=oak_planks) > resource.deliver(q=8,item=oak_planks,to=agent_a) REQ agent_a craft.item(bind=WORK_BRANCH,q=1, input=oak_planks,item=crafting_table) Table S8 separates the checks that establish a valid commitment from the post-materialization and post-execution evidence that discharges it. Table S8. Checks across parsing, materialization, and live verification. PhaseCheckAccepted condition Pre- materialization Syntax and identity two-line grammar; actors and peer match the role instance Skill and arguments catalog path, required keys, types, and quantities are valid Binding and handoff branch is admissible; item, quantity, sender, and receiver agree Dependency merge selected predecessor graph is complete and acyclic Post- materialization Static plan consistency resolved actors, fields, handoff edge, and checker attachment match the validated commitment Post-execution World verification handoff event and declared terminal predicate both pass The live route is generate→ parse→ contract check → canonical materialize→ compile → execute→ verify. Once the model-generated semantics equal the selected canonical task object, the materializer combines the selected binding with the shared task structure. Mineflayer 4.37.1 [PrismarineJS(2026)] then executes the compiled skills against the official Minecraft Java server 1.21.4. Figure S2 follows one retained episode from learned records to terminal world state; Table S9 reports the exact calls, actions, inventory deltas, and wall-clock time for the same trace. Table S9. Representative live episode accounting. Event or stateObserved value Selected bindingWORK_BRANCH Learned model calls2 Executor actions13 Sender oak planks, before → after8→ 0 Receiver oak planks, before → after0→ 8 Terminal crafting tables1 Wall-clock episode time22.36 s Handoff / terminal verificationpass / pass Figure S2 uses role instanceGCP-PAPER-REP-ACTIVE-ORDER-BRANCH-0015-R1. The trace records inventory snap- shots around the handoff, all issued skills, the terminal inventory, and the server-side checker result. S5 Full Quality and Communication Results Takeaway. At matched terminal quality, the three communication surfaces differ sharply in generated length, message size, and time-to-commitment while sharing the same executor. Table S10 establishes the quality lock and reports the exact online costs. Figure S3 makes the resulting cost profile visually comparable, and Table S11 separates same-card call latency from quality-pool reliability. The same-card timing pool contains 40 clusters, two role views, and three checkpoints per surface. Models run sequentially on the same device. TTC ends when the executable bilateral commitment is available; executor time begins after commitment and remains near 22.6 s p50 across surfaces. GenCoord / Supplementary Material9 ONE LIVE EPISODE · WORK_BRANCH 2 learned calls · 13 executor actions · 22.36 s TWO LOCAL RECORDS SENDER B SELF obtain(planks×8) › deliver(×8,to=A) REQ A craft(table×1) bind=WORK_BRANCH RECEIVER A SELF craft(table×1) bind=WORK_BRANCH REQ – CHECKED COMMITMENT · WORK_BRANCH parse · ground · actorize B obtain ×8 B→A handoff ×8 A craft ×1 canonical actor path GROUNDING IN THE LIVE WORLD inventory deltas + server-side checker ×8 B inventory 8 planks · obtain ×8 verified handoff ×8 · B 8→0 · A 0→8 terminal verified 1 table + 4 planks go obtain_block ×8 go give go craft COMPILED EXECUTION · 13 ACTIONSno fallback handoff: B 8→0 · A 0→8 terminal: table×1 + planks×4 ×8 Figure S2. One grounded episode from bilateral Short DSL records to a checked commitment, verified handoff, and terminal world state. Table S10. Matched-quality representation results. Success uses the 128-cluster quality pool; calls, token counts, protocol- specific Agent-to-Agent payload bytes, and TTC use the separate 40-cluster same-card timing pool. MethodSuccessCallsInput tok. Output tok. Wire B TTC p50 TTC p95 Short DSL GenCoord (0.8B)100.0% 2.0 949.178.676.3 2.266 s 2.616 s JSON GenCoord (0.8B)100.0% 2.0 1,154.7 267.6 303.4 7.067 s 7.864 s Controlled free-form + structured commit (0.8B)100.0% 2.5 1,585.2 265.8 1,061.1 7.132 s 7.857 s 0 1.5 3 2.02.0 1.00× 2.5 1.25× (a) MODEL CALLS calls 0 1k 2k 949 1,155 1.2× 1,585 1.7× (b) INPUT tokens 0 160 320 79 268 3.4× 266 3.4× (c) OUTPUT tokens 0 625 1.25k 76 303 4.0× 1,061 13.9× (d) WIRE bytes 0 4 8 2.27 2.62 7.07 7.86 7.13 7.86 (e) TIME TO COMMITMENT seconds · dark median / light 95th QUALITY LOCK128 / 128 semantic clusters passed for every interface cost pool: 40 clusters · two roles · three seeds · same card Short DSLJSONControlled free-form Figure S3. Quality-matched coordination costs on independent physical-unit axes. All three interfaces pass the 128-cluster quality pool; costs use the separate 40-cluster same-card timing pool. In the TTC panel, dark bars end at p50 (the median) and pale extensions end at p95 (the 95th percentile). GenCoord / Supplementary Material10 Table S11. Same-card latency and quality-pool reliability. The two panels retain their separate 40- and 128-cluster denominators. (a) Call latency: 40-cluster same-card pool Surfacep50p95 Short DSL call latency1.143 s 1.660 s JSON call latency3.531 s 5.941 s Controlled free-form call latency3.274 s 3.746 s (b) Reliability and symmetry: 128-cluster quality pool Strict successful clusters, each surface128/128 Exact-binomial 95% lower bound0.972 Role-swap success difference0.0 p Missing / fallback rows0 / 0 S6 Request Semantics and Strong Baselines Takeaway. The delivered binding is causally active: removing it restores the paired 50% ceiling, while replacing it with the other executable option drives the receiver to the paired world-state branch. Table S12 holds message presence, protocol schedule, schema, and learned-call count fixed while changing only the delivered task content; the deterministic row supplies an exact binding-selection ceiling for the enumerable library. Table S12. Request intervention and deterministic binding reference on 160 clusters. Learned rows contain three seeds (960 episodes); the seedless deterministic rule runs once per role view (320 episodes). Paired differences are true request minus the listed condition. Bytes are canonical request-object JSON, distinct from the protocol-specific Short DSL request-line bytes in Table S10. ConditionEpisodes Success Calls Req.- object JSON B True − condi- tion Mechanism readout True learned request 960 100.0%2.0 304.40.0 p reference success Request removed / self-plan-only 960 50.0%2.00.0 +50.0 p [42.5,57.5] paired ambiguity exposed Same-template executable alternative 9600.0%2.0 304.4+100.0 p [100, 100] receiver follows delivered alternative Deterministic correct binding 320 100.0%0.0 304.40.0 p exact binding ceiling The alternative intervention selects the other executable request from the same template option set and preserves message presence, schedule, schema, approximate length, and learned-call count. The receiver follows the delivered alternative in 960/960 CONFIRM episodes and 471/471 executable held-out cases. Every executable held-out output preserves the delivered binding; the nine residual losses occur before an executable plan is formed. S7 Commitment Horizon and Template Shift Takeaway. Under the corresponding closed-loop training protocols, multi-step commitments improve held-out success and reduce online decisions; the gain concentrates in allocation and active-continuation templates. Table S13 reports the paired aggregate effects and family decomposition; Figure S4 shows where the success gain appears and how much online burden remains. The comparison evaluates complete systems under their corresponding training protocol. Multi-step training uses 1,920 rows and 240 optimizer updates per seed. Single-step training uses 2,880 rows, 360 updates, and an additional sender_after_obtainstage. This design gives the single-step system explicit intermediate-state supervision; the measured difference therefore combines commitment horizon with each protocol’s online control pattern. The deterministic correct-binding rule supplies an exact binding-selection ceiling on the same held-out pool: 100.0% versus 98.1% for multi-step GenCoord, a paired GenCoord-minus-rule difference of−1.9 p (95% CI [−4.2,−0.2]). GenCoord preserves the correct binding in every executable output; its nine residual losses arise before plan formation. The comparison therefore separates exact binding sufficiency from learned commitment formation while retaining the same executable interface. GenCoord / Supplementary Material11 Table S13. Held-out-template horizon results across 80 independent clusters. Every difference is multi-step minus single-step. Family rows are descriptive; confidence intervals are reported for the aggregate paired comparisons. Family / metric Multi- step Single- step ∆ 95% CIInterpretive feature Destination100.0% 100.0% 0.0 p —destination binding Recipe100.0% 100.0% 0.0 p —transformation binding Allocation92.5% 83.3% 9.2 p —actor / remaining workload Active branch 100.0% 81.7% 18.3 p —downstream continuation Overall success 98.1% 91.3% 6.9 p [2.9, 10.8] pppaired cluster bootstrap Decisions / episode 1.981 2.913 −0.931 calls / ep. [−0.971,−0.892] calls / ep. online coordination cost Input tokens / episode 1,146.5 1,689.1 −542.6 tok./ep. [−567.8,−517.6] tok./ep. repeated context avoided 7580859095100 Terminal success (%) Destination Recipe Allocation Active branch 100.0 100.0 0.0 100.0 100.0 0.0 83.3 92.5 +9.2 81.7 100.0 +18.3 Δ p (a) TASK-FAMILY SUCCESS 050%100% Multi-step share of single-step budget Model calls single-step = 100% 2.91 → 1.98 Input tokens single-step = 100% 1,689 → 1,147 Output tokens single-step = 100% 271 → 265 (b) ONLINE BURDEN 68% 68% 98% HELD-OUT COMMITMENT HORIZON 98.1% multi-step 91.3% single-step +6.9 p [2.9, 10.8] 80 paired semantic clusters Multi-stepSingle-step paired mean · dark cap = 95% CI Figure S4. Paired commitment-horizon comparison over 80 held-out semantic clusters. (a) Task-family terminal success. (b) Multi-step online burden as a share of the corresponding single-step mean; dark caps map the paired absolute-difference confidence intervals from Table S13 onto that observed denominator. S8 Backend and Composition Analyses Takeaway. For the enumerable task library, a learned binding code plus deterministic rule is a faster quality-matched backend. Direct Short DSL retains an explicit executable path as its model output. Table S14 isolates backend formation while holding the peer-facing commitment fixed. Table S15 then separates complete-case lookup from field-wise construction on unseen binding cross-products. Table S14. Quality-matched direct and factor-code backends. Fresh success uses 128 clusters (two roles, three seeds); token counts and TTC use a separate 40-cluster same-card planning pool. MetricFactor + rule Direct DSL Fresh success768/768 768/768 Input tokens980.2948.9 Output tokens19.479.1 Protocol-specific peer payload76.6 B76.6 B TTC p500.824 s2.453 s TTC p950.997 s2.723 s The factor target is the sender binding ID before delivery and the receiver accepted-binding ID after delivery. Both models receive the same model-visible information. A deterministic composer recovers actor, path, object, destination, dependencies, and the same peer-facing Short DSL request from the selected code. GenCoord / Supplementary Material12 Table S15. Composition reference on 60 unseen binding cross-products. MethodTerminal success Complete-case table0/60 Explicit-factor composer60/60 Direct Short DSL60/60 The composition reference separates exact case lookup from field-wise construction. Explicit factor composition and Direct Short DSL recover all 60 tested cross-products, while exact complete-case lookup covers the observed cases only. Table S14 further shows that, when a public codebook uniquely determines the branch, factor-code generation provides a lower-latency path to the same peer-facing commitment. S8.1 Naturalized private facts without binding IDs The active binding field is next replaced by naturalized private-fact descriptions while the same 16 semantic task cells, public prior, and grounded executor are retained. Table S16 reports one Minecraft closed-loop condition with test-only syntactic recombinations and two stronger planning-only surface shifts. Table S16. Naturalized private-fact formation after removing the active binding field. C1 is Minecraft closed-loop evaluation on held-out syntactic recombinations; C2 and C3 are planning-only lexical-paraphrase and paraphrase-plus-distractor conditions. Learned rows aggregate three seeds (960 episodes per condition); seedless model-free rows use 320 episodes. Formation methodC1 live C2 planning C3 planning Direct Short DSL (0.8B)100.0%65.8%64.8% Learned factor + rule (0.8B)100.0%79.1%80.1% Frozen factor parser rule100.0%0.0%0.0% TF–IDF nearest-neighbour rule100.0%59.4%62.5% Complete surface table0.0%0.0%0.0% Oracle factors + rule100.0%100.0%100.0% Under C1, both learned backends and the two stronger non-LLM semantic mappings retain 100% closed-loop success, while exact-string lookup covers the training surfaces only. The commitment interface therefore remains executable after the active answer field is replaced by test-only naturalized descriptions. Under stronger surface shifts, learned factor formation reaches 79.1% and 80.1%, exceeding TF–IDF by +19.7 p (95% CI [11.8,27.9]) and +17.6 p ([9.2,26.5]), respectively; Direct Short DSL reaches 65.8% and 64.8%. The result strengthens the interface/backend separation: compact factor prediction is the more robust realization under stronger lexical change. S9 Task-Structure Visibility Takeaway. Full and Skeleton views preserve the familiar post-handoff branch; the analysis cleanly separates that recovered motif from transformation-order motifs that require additional structural generalization. Figure S5 reports the full 3-method × 3-view × 3-motif matrix with exact percentages in every cell. Full DAG exposes the public nodes, typed fields, coarse stages, predecessor lists, and edges; its symbolic reference follows a topological ordering. Skeleton removes predecessor lists and edges while retaining coarse stage, and its symbolic reference uses that stage information. Node-only removes stages and edges, applies a stable answer-independent node arrangement, and uses a fixed task-path priority. The three views are categorical projections with distinct answer-independent ordering policies. Across 96 clusters, two role views, and three frozen checkpoints, the matrix shows that Direct Short DSL preserves the familiar post-handoff branch under Full and Skeleton views, while the two transformation-order motifs remain at 0%. The symbolic rule’s non-monotone Node-only recovery reflects its fixed task-path priority under a different projection. S10 E1/E2: Feedback Causality and Centralized Reference Takeaway. Across 40 Goal–Capability semantic clusters (20 matched counterfactual pairs) and three independently trained seeds, requester-local planning reaches 50%, correct feedback reaches 100%, counterfactual feedback reaches 0%, and centralized full information reaches 100%. S10.1 Paired construction and matched training The evaluation crosses two private goals, two peer-local workcell modes, and ten world variants, producing 2×2×10 = 40 semantic clusters. Table S17 records the matched training contracts; Table S18 reports the four-condition outcome GenCoord / Supplementary Material13 Full Skeleton Node-only Full Skeleton Node-only Full Skeleton Node-only Short DSL Controlled free-form Factorized rule Familiar post-handoff branchUnseen post-handoff transformUnseen pre-handoff transform 100%100%18.2%0%0%0%0%0%0% 100%97.4%35.9%0%0%0%24.5%16.7%0.5% 100%100%100%100%46.9%78.1%100%62.5%100% 0255075100% 32 semantic clusters per motif · 2 role views × 3 seeds · hatching preserves low/mid bands in grayscale Figure S5. Annotated task-structure robustness matrix. Columns pair each topology motif with Full, Skeleton, and Node-only projections; cells show exact terminal success. profile; Table S19 isolates the fields controlled by feedback; and Figure S6 traces the capability-conditioned routes and intervention. Holding goal and world variant fixed while changing the workcell mode creates 20 matched counterfactual pairs. Within each pair, the requester’s model-visible input and initial proposal are byte-identical; the peer-local mode changes the feasible craft actor, handoff object, and downstream suffix. Each condition evaluates all 40 clusters under two role permutations and three training seeds, yielding 240 episodes per condition and 960 episodes overall. The primary analysis averages the six role–seed observations within semantic cluster and resamples 40 clusters. A pair-block sensitivity analysis additionally averages both capability worlds within each goal–world pair and resamples the 20 matched pair blocks. Table S17. Training contracts for the Goal–Capability models. Train-token occurrences sum tokenized prompt, target, and EOS across all epochs. ModelVisible informationRows Epochs Updates Train-token occurrences Seeds Distributed requester320 initial local + 320 after-response local 640280868,7203 Centralized full information merged current local views320480970,0803 The distributed data contain 320 initial local records and 320 local records after the bounded response. The centralized data contain 320 joint-plan records. Both models use Qwen3.5-0.8B, effective batch size 16, learning rate 10 −5 , maximum length 2,048, and final-step checkpoints, with DEV reserved for implementation checks. Matching optimizer updates gives the centralized model 1.117 times the distributed train-token occurrences. The reported totals include prompt, target, and EOS tokens over all sample occurrences; every row remains below the 2,048-token truncation limit. S10.2 E1: feedback-content intervention Table S18. E1/E2 outcomes on 40 semantic clusters, arranged as 20 matched counterfactual pairs. Intervals are primary cluster-bootstrap 95% CIs. Strict success requires all six role–seed observations of a cluster to succeed; the final column names the measured boundary component rather than total architecture traffic. ConditionSeeds Epis. Success 95% CI Strict Calls Measured boundary component Requester-local (A-only)3 240 50.0% [35, 65] 20/40 1.0 0 B cross-boundary payload Correct bounded feedback3 240 100.0% [100, 100] 40/40 2.0 response: mean 103 B Counterfactual feedback3 2400.0%[0, 0]0/40 2.0 injected response: mean 103 B Centralized full information3 240 100.0% [100, 100] 40/40 1.0 state aggregation: mean 956 B Correct feedback improves success over requester-local planning by +50.0 percentage points (primary 40-cluster 95% CI [35,65]). Replacing only the response with the paired counterfactual workcell mode changes the same two-call protocol from 100% to 0% (paired difference +100.0 points, 95% CI [100,100]). The 20-pair block sensitivity gives +50.0 points [50,50] and +100.0 points [100,100], respectively. Every seed reproduces the 50/100/0 profile with descriptive seed-level SD 0.0. All 720 distributed episodes are parse-valid, condition-specific contract-valid, planning-complete, and GenCoord / Supplementary Material14 fallback-free. Counterfactual commitments remain internally valid under the injected response, while the unchanged executable world provides an independent terminal check. Table S19. Commitment fields under the counterfactual-feedback intervention. FieldMatches injected Matches true world Observed behavior Craft actor240/2400/240 rewritten Handoff item240/2400/240 rewritten Handoff count240/2400/240 rewritten Peer suffix240/2400/240 rewritten Goal item240/240240/240 invariant Goal count240/240240/240 invariant The intervention preserves the requester input, initial proposal, executable world, model checkpoints, decoding contract, and two-call schedule. Counterfactual feedback controls the final commitment in all 240 episodes: craft actor, handoff item, handoff count, and peer suffix follow the injected capability consequence, while goal item and goal count remain unchanged. Each complete commitment therefore reaches the actor selected by the injected response, and the unchanged world rejects that counterfactual actor at terminal verification. Fixed request × private capability The peer-local workcell determines which side of crafting receives the handoff. Fixed requester record SELF resource.obtain(q=2,item=oak_planks) > resource.deliver(q=2,item=oak_planks,to=agent_b) REQ agent_b craft.item(q=4,input=oak_planks,item=stick) > resource.deliver(q=4,item=stick,dst=order_chest) same request / same prompt hash a7f300f3... peer workcell mode changes actor assignment and the handoff side of crafting same request B can process raw material local workcell can process planks ACCEPT LOCAL_WORKCELL_ CAN_PROCESS raw handoffB receivesB crafts sticks x4 order chest 20 / 20 B requires the finished item raw processing blocked; finished item required COUNTER alt_id CRAFT_AT_REQUESTER_ HANDOFF_FINISHED A keeps rawA crafts sticks x4 finished handoff order chest 20 / 20 CROSSED RESPONSE | REQUEST + WORLD FIXED 40 clusters | 20 pairs 20 / 40 requester-local 40 / 40 correct feedback 0 / 40 counterfactual feedback 40 / 40 centralized E1 swaps only the bounded response; requester input, executable world, checkpoints, and the two-call schedule remain fi xed. Figure S6. Capability-conditioned commitments and the counterfactual-feedback intervention with requester input and executable world held fixed. Figure S6 illustrates a correct-feedback pair that shares one requester prompt hash. ARAW_PROCESSORpeer accepts the raw-material handoff. AFINISHED_RECEIVERpeer counters withCRAFT_AT_REQUESTER_HANDOFF_FINISHED; the requester moves crafting into its own path and hands off the finished item. Both correct routes reach the terminal GenCoord / Supplementary Material15 checker. The E1 intervention injects the matched counterfactual response while keeping the requester input, initial proposal, and executable world fixed. S10.3 E2: three-seed centralized reference Centralized full information succeeds in 240/240 episodes across the same three seeds and 40 clusters, matching correct feedback with a paired difference of 0.0 points (95% CI [0,0]). It assembles the two current local views before one learned call. The distributed route keeps the views separate and uses a bounded response with mean 103 B and p95 118 B before its second learned call. The centralized state-aggregation component has mean 955.5 B and p95 963 B (rounded to 956 B in Table S18). The 103 B value measures the bounded response, while 955.5 B measures centralized state aggregation. The architecture-level equations below account for every application message and make the component boundaries explicit. For architecture accounting, letA t ⊆ Abe the participating agents at roundt, letE t ⊆ A×Abe the directed active-edge set, and letM t ij be the complete sequence of application messages sent on directed edge (i,j). The function b(m) counts canonical UTF-8 payload bytes, including any application wrapper present inmbut excluding transport framing. Letm t i,↑ andm t i,↓ denote centralized upload and download payloads. WithR c centralized rounds andR l local rounds, B central = R c X t=1 X i∈A t b(m t i,↑ ) + b(m t i,↓ ) ,(S4) B local = R l X t=1 X (i,j)∈E t X m∈M t ij b(m).(S5) Feedback sent in the reverse direction belongs to the corresponding edge (j,i). These equations define total interface accounting and are distinct from the component measurements above. Both architectures depend on coordination rounds; local communication also depends on active-edge density and messages per active edge. S11 Reproducibility Notes Pre-release validation checks the bundled compact data, method identities, pool denominators, non-null horizon means, paired-difference direction, confidence intervals, bootstrap seeds, and 10,000 resamples. It also checks the corrected single-step inventory of 2,880 rows, three stage counts of 960, and 360 optimizer updates per seed. For E1/E2, the arXiv ancillary data contain twelve evaluation lanes and 960 episode metrics stripped of host, scheduler, process, and private-path identifiers, including all 240 counterfactual-feedback control episodes. The deterministic table builder regenerates Tables S17–S19 from the canonical analysis and matched training-budget files. Earlier representation, request, horizon, and visibility results are reconstructed from the bundled aggregate analyses and fixed paired-comparison records; E1/E2 additionally include de-identified episode-level metrics. Statistical procedure. Representation, request, horizon, visibility, and the primary E1/E2 analyses use the semantic cluster as the independent unit. Where role views or training seeds repeat a cluster, their outcomes are averaged within cluster before inference. Paired effects use cluster-aligned differences. Reported bootstrap intervals use 10,000 percentile resamples with fixed analysis seeds; E1/E2 condition intervals use seeds 8901–8904 and primary paired-difference intervals use 8911–8914. The E1/E2 sensitivity aggregates both capability clusters within each goal–world pair and resamples 20 pair blocks with seeds 8921–8924. Exact-binomial intervals are two-sided 95% Clopper–Pearson intervals. Seed-level standard deviations summarize training-run stability, while cluster bootstrap intervals provide inferential uncertainty. Table S20 links every reader-facing result family to its compact canonical source. Packaged sources. The arXiv package contains the bibliography, canonical Supplement source, compact ancillary source data, final vector figure exports, and deterministic E1/E2 table builder. Reader-facing paths are package-relative. Experimental runtime dependencies include Qwen3.5-0.8B, Mineflayer 4.37.1, Node.js, Python, PyTorch, Transformers, and the official Minecraft Java server 1.21.4; each is governed by its upstream license or terms. Build sequence. Regenerate the E1/E2 tables with: python3 anc/scripts/build_e1e2_tables.py \ --analysis anc/source_data/e1e2_analysis.json \ --training anc/source_data/e1e2_training_budget.json \ --tables-dir tables --data-dir anc/source_data Then compilesupplement.texwith the bundled bibliography. Final vector figure PDFs are included underfigures/; editable authoring sources, render caches, and contact sheets are intentionally excluded from the arXiv upload package. GenCoord / Supplementary Material16 Table S20. Claim-to-artifact map for the compact arXiv ancillary bundle. Result familyCanonical bundle artifact Evidence-suite and task inventory anc/source_data/evidence_suites.csv; anc/source_data/task_templates.csv Representation quality and cost anc/source_data/representation_cost.csv Request intervention anc/source_data/request_intervention.csv Commitment horizonanc/source_data/horizon_summary.json; anc/source_data/horizon_family.csv; anc/source_data/paired_comparisons.json Structure visibility anc/source_data/visibility_motifs.csv; anc/source_data/visibility_overall.csv Grounded runtime trace anc/source_data/runtime_trace.json; anc/source_data/trace_registry.csv E1/E2 outcomes and field fidelity anc/source_data/e1e2_episode_metrics.jsonl; anc/source_data/e1e2_analysis.json; anc/source_data/e1e2_field_fidelity.csv; anc/source_data/e1e2_config.json Training budgets and runs anc/source_data/e1e2_training_budget.json; anc/source_data/training_runs.csv Backend and composition references anc/source_data/backend_comparison.csv; anc/source_data/composition_reference.csv Naturalized private-fact formation anc/source_data/naturalized_private_fact_summary.csv; anc/source_data/naturalized_private_fact_paired.csv; anc/source_data/naturalized_private_fact_scope.json Table regeneration anc/scripts/build_e1e2_tables.py References [PrismarineJS(2026)]PrismarineJS. 2026. Mineflayer: Create Minecraft Bots with a High-Level JavaScript API. Software repository. Version 4.37.1 used in the project; accessed 2026-08-08.https://github.com/PrismarineJS/ mineflayer [Qwen Team(2026)]Qwen Team. 2026. Qwen3.5-0.8B. Hugging Face model card. Accessed 2026-08-08.https: //huggingface.co/Qwen/Qwen3.5-0.8B