PaperlayerView exact revision on arXiv

Source-linked AI summary

GenCoord: Skill-Path Commitments under Private Information

Peng He, Junning Zhu, Haohan Yuan, Jianpeng Liang

arXiv:2608.22055v1cs.AI

TL;DR

Embodied teams can face paired local ambiguity when private task or capability facts determine the actor, handoff, and continuation. GenCoord communicates those task consequences as executable SELF+REQ skill-path commitments, resolves them with bounded feedback, and verifies execution. Across the reported evaluations, the commitments close the paired information gap, improve held-out-template success, and reduce communication and decision costs.

  • Problem

    Private task and capability facts can leave neither agent’s local view sufficient to determine the actor, handoff object, or continuation.

  • Method

    GenCoord uses multi-step SELF+REQ commitments to transmit task consequences, revise routes through bounded capability feedback, and ground resolved paths in verified execution.

  • Results

    50% to 100%: correct capability feedback closes the paired local-information gap; Short DSL also reduces peer traffic by 92.8% and median time-to-commitment by 68.2% at matched closed-loop quality.

  • Takeaways & Limitations

    Executable task consequences serve as the coordination unit connecting distributed local reasoning to verified joint action.

  • Takeaways & Limitations

    The evaluation is limited to bilateral coordination over a shared executable prior in static Minecraft with reliable messaging.

Abstract

from arXiv · show

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.

1 Introduction

GenCoord addresses coordination when private task or capability facts make the correct actor, handoff, and continuation indeterminate from either local view. It communicates those executable task consequences through SELF+REQ commitments and validates their effect in grounded joint execution.

  • Problem: Private facts can change the correct actor, handoff item, and continuation even when one agent’s local input is unchanged.In the crafting-table example, the peer’s workcell capability determines whether planks or the finished table crosses the boundary.
  • Problem: Coordination must reveal who acts, what crosses the handoff boundary, where it goes, and which suffix follows.
  • Approach: GenCoord makes the executable task consequence itself the coordination object, preserving fields that directly determine execution.This contrasts with assembling local contexts or exchanging state, intent, and plans through free-form negotiation.
  • Approach: A sender-local consequence travels forward in a peer request, while a peer-local capability consequence travels back through bounded feedback for requester revision.Both directions use one explicit object whose semantics persist through communication, resolution, and execution.
  • Approach: GenCoord represents sender and peer obligations in one multi-step SELF+REQ object and carries that object through grounded execution.The local model composes role-local paths, while the shared schema preserves the executable commitment.
  • Evidence: 50% to 100%: bounded capability feedback raises paired local success across three independently trained seeds.Counterfactual interventions redirect the resolved route in both directions exactly as the injected task consequence specifies.
  • Evidence: 6.9 points: multi-step commitments improve held-out-template success while reducing model decisions by 32%.
  • Evidence: 92.8% and 68.2%: Short DSL reduces peer traffic and median time-to-commitment relative to controlled free-form communication at matched closed-loop quality.The comparison covers 128 held-out clusters.

4 GenCoord

GenCoord generates and resolves executable role-local skill paths around an inter-agent handoff. Its schema makes obligations, dependencies, and capability-conditioned revisions explicit before deterministic validation and compilation.

  • Local proposal generation: The model maps local context and shared task structure to an initial SELF plan and peer REQ containing the proposed role-local paths.The input includes the decision agent, observation, history, incoming messages, peer, and shared task prior.
  • Commitment composition: GenCoord composes a feasible joint path by selecting actors, grounding objects and destinations, and placing a task-dependent cut between role-local paths.The resulting object records local steps before the boundary, the peer obligation, and the dependencies connecting both.
  • Forward resolution: Forward resolution lets the receiver generate a downstream SELF path from the sender’s request, then canonically joins the complementary obligations.The resolver checks role, path, handoff, and dependency conditions.
  • Feedback resolution: Feedback resolution maps peer-local capability to Accept, Reject, or Counter, after which the requester produces a revised proposal.The bounded response can change the transformation actor, handoff object, and continuation while holding the requester view and initial proposal fixed.
  • Short DSL: SELF+REQ uses ordered typed skill paths with explicit actor, skill, object, quantity, destination, binding, and dependency fields.Variable-length paths express acquisition, transformation, handoff, and deposit in one commitment.
  • Grounded execution: The resolved object is parsed, schema-checked, canonically materialized, compiled to Mineflayer skills, and verified by handoff inventory and terminal-world state.The checker validates identities, skills, arguments, quantities, bindings, destinations, and predecessor constraints before compilation.

5 Experimental Setup

GenCoord evaluates executable commitments in a controlled Minecraft setting spanning distinct task consequences, transfer conditions, communication surfaces, and execution checks. The experiments isolate scientific layers while measuring closed-loop validity, terminal success, communication, and timing.

  • Environment and Tasks: The evaluation uses two-agent Minecraft Java 1.21.4 episodes with local observations, a shared skill ontology and task prior, reliable communication, and a mandatory in-world handoff.The static environment isolates how distributed task facts enter a joint plan.
  • Environment and Tasks: Four task families vary Destination, Recipe, Allocation, and Active Branch commitment fields, with two templates per family.These fields respectively change target location, transformation and handoff item, actor and remaining work, or downstream continuation.
  • Data and Evaluation Pools: The study separates transfers across new bindings within known templates, held-out templates, unseen factor cross-products, and unseen transform-order motifs.Each transfer retains its own independent cluster count.
  • Comparators: The representation comparison holds the base model, semantic clusters, canonical task fields, training budget, skill interface, checker, materializer, executor, and verifier fixed.It compares Short DSL, JSON, and controlled multi-turn free-form communication surfaces.
  • Mechanism Evaluations: Mechanism interventions independently alter delivered task content, commitment horizon, or communication representation while preserving the other specified experimental layers.Request intervention preserves schedule and surface validity; horizon changes when the joint route is committed; serialization compares the same canonical fields and execution stack.
  • Metrics and Statistics: Terminal success requires the complete episode to satisfy the world-state goal predicate, while commitment validity checks actors, skills, arguments, bindings, and dependencies against the canonical schema.Raw validity records parsing, and feedback-intervention validity is response-conditioned.
  • Metrics and Statistics: Calls, tokens, wire bytes, and time-to-commitment are measured on a 40-cluster same-card sample covering 720 episode runs and 1,560 model calls.Semantic cluster is the independent unit; paired comparisons use cluster-bootstrap 95% intervals, with exact binomial lower bounds for all-success pools.

6 Results

GenCoord resolves private-information ambiguity by making executable task consequences determine requester revision, peer execution, and commitment horizon. Across mechanism, horizon, communication, and backend evaluations, it preserves closed-loop quality while improving success or reducing coordination cost.

  • Feedback and execution: Counterfactual feedback redirects the resolved route in 240/240 episodes while holding the requester view, initial proposal, world, and call schedule unchanged.Craft actor, handoff item and count, and peer suffix follow the injected capability consequence, while goal fields remain fixed.
  • Feedback and execution: 100% terminal success requires the true multi-step request; removing REQ yields 50%, while an executable same-template alternative yields 0%.These interventions preserve message presence, protocol schedule, schema, approximate length, and call count, isolating request content as the determinant of peer execution.
  • Commitment horizon: 6.9 points: Multi-step commitments reach 98.1% held-out-template success versus 91.3% for a separately trained single-step controller.Multi-step commitments also use 1.98 versus 2.91 model decisions per episode, a 32% reduction; allocation and active-branch cases show the largest gains.
  • Communication and backend costs: 100%: Short DSL, JSON, and controlled free-form each complete 128/128 held-out semantic clusters with valid commitments, verified handoffs, and no repair or fallback.At matched quality, Short DSL reduces wire bytes by 92.8% and median time-to-commitment by 68.2% relative to controlled free-form.
  • Communication and backend costs: 100%: Factor-Code + Rule and Direct Short DSL both complete 128/128 semantic clusters, while the factorized backend reduces mean output by 75.5% and TTC p50 from 2.453 to 0.824 seconds.Both backends transmit the same 76.6-byte peer request, separating the peer-facing interface from model-side realization.

7 Discussion

GenCoord treats the task consequence of private information as the control variable that determines executable routes in either communication direction. Its commitment horizon and communication interfaces preserve shared semantics while reducing online coordination costs, within a bounded evaluation scope.

  • Counterfactual interventions show that replacing REQ redirects receiver execution, while bounded feedback changes requester actor, handoff object, and route suffix.The zero-call rule reproduces the content effect under unchanged world, schedule, and executor conditions.
  • Multi-step commitments expose sender prefixes, handoff boundaries, peer suffixes, typed arguments, and dependencies before another model decision.This removes an intermediate deliberation stage and links commitment horizon to online replanning.
  • Short DSL and formation backends optimize realization while terminating at the same typed, checked, materialized, and executable commitment interface.Surface compression changes communication form, while formation compression replaces full-path decoding with stage codes and deterministic composition.
  • Both centralized and local information interfaces resolve all 40 Goal × Capability clusters across three seeds while exposing different information flows.Centralized traffic follows synchronized state, participating agents, and rounds; local traffic follows active edges, commitment size, and local rounds.
  • The evidence is limited to bilateral coordination over a shared executable prior in static Minecraft with reliable messaging.Dynamic multi-edge consistency and open-ended task decomposition remain outside the current evidence.

8 Conclusion

The conclusion frames GenCoord as a shared executable commitment object for carrying private task consequences through forward requests or bounded feedback. The protocol separates proposal, resolution, validation, materialization, execution, and verification while preserving operative obligations.

  • 8 Conclusion: GenCoord carries sender-local bindings forward in requests and peer-local capability consequences backward through bounded feedback.Both routes use the same executable commitment object and connect local generative reasoning to verified multi-agent action.
  • Protocol lifecycle: Forward and bounded-feedback protocol lanes terminate at one contract-validated commitment interface.Figure S1 presents the two routes as distinct lifecycles sharing the checked interface.
  • Resolver semantics: The protocol result distinguishes successful commitments, no-commitment outcomes, and failures through a tagged union.Its values are Success(C, D), NoCommitment(e), and Fail(f).
  • Resolver semantics: Forward resolution actorizes sender and receiver paths, while feedback selects Accept, Counter, or Reject before requester revision and operative-path construction.Counter preserves requester goal fields and target peer while replacing the initial branch with one admissible alternative; Reject closes the candidate.
  • Execution closure: A resolved commitment preserves ordered tasks, typed values, bindings, actors, locations, and dependencies before materialization and compilation to Mineflayer calls.The checker validates execution-schema fields, the materializer instantiates the dispatch plan, and the compiler adds runtime mechanics.

S2 Task Suite and Programmatic Supervision

The task suite tests whether sender-local private bindings can disambiguate receiver execution across balanced executable templates. Programmatic supervision separates local context from targets and validates each target against its intended binding and terminal predicate.

  • Task suite: Four forward-request task families place the path-determining binding in the sender’s local view, leaving the receiver unable to distinguish two executable branches before the request.The families vary destination, recipe, allocation, and active branch.
  • Task suite: Eight templates vary one commitment field per balanced binding, with Table S5 providing reciprocal sender-proposal and receiver-realization supervision.Each template contains two equally represented admissible bindings.
  • Task suite: The paired binding worlds produce a constructive 50% ceiling when the delivered request is removed.Receiver decision contexts remain matched until the request arrives, and every instance requires verified material handoff and a binding-specific terminal state.
  • Programmatic supervision: Targets are built from template specifications, sampled local facts, and canonical task objects, then checked against the intended binding and terminal predicate.The data builder writes model-visible context and target separately.

S3 Training and Checkpoint Provenance

The supplementary protocol fixes training provenance, a compact canonical serializer, and deterministic checks that connect model outputs to verified execution. The resulting pipeline preserves commitment semantics from parsing through live terminal-state evidence.

  • Training provenance: Multi-step training uses 1,920 rows and 240 updates per seed, while single-step training uses 2,880 rows and 360 updates.The single-step configuration receives an additional intermediate stage; Tables S6 and S7 record matched budgets and provenance.
  • Execution verification: The typed checker validates a commitment before materialization, and the compiler lowers the resulting plan to Mineflayer skills while preserving dependency order.Table S8 separates parsing, materialization, and live-verification checks.
  • Canonical serializer: The canonical DSL contains SELF and REQ lines with ordered paths of one to five tasks and typed JSON-compatible arguments.The grammar supports task separators, peer identifiers, grounding keys, and skills including resource, craft, transform, and build operations.
  • Canonical serializer: Parsing accepts compatibility names but canonicalizes aliases, typed defaults, grounded references, bindings, actors, and predecessor semantics before contract checking.The serializer emits compact keys, while the checker rejects unknown keys and invalid types.
  • Execution verification: A representative retained episode records issued skills, inventory changes, terminal inventory, server-side checking, and wall-clock accounting.Figure S2 and Table S9 trace one episode from learned records to terminal world state.

S5 Full Quality and Communication Results

The communication surfaces achieve matched closed-loop quality while differing substantially in communication cost and time-to-commitment. Short DSL preserves the executable commitment interface while reducing peer-facing overhead relative to controlled free-form communication.

  • Communication costs: At matched terminal quality, the three communication surfaces share the same executor but differ in generated length, message size, and time-to-commitment.The comparison holds the executor fixed while evaluating the communication surfaces.
  • Timing protocol: The same-card timing pool contains 40 clusters, two role views, and three checkpoints per surface.Models run sequentially on the same device, and executor time begins after commitment.
  • Execution verification: A grounded episode proceeds from bilateral Short DSL records to a checked commitment, verified handoff, and terminal world state.The commitment is evaluated through the handoff and resulting world state rather than communication alone.
  • Quality: 128 / 128 semantic clusters passed for every interface cost pool.The quality pool uses 128 clusters, while cost measurements use a separate 40-cluster same-card timing pool.

S6 Request Semantics and Strong Baselines

GenCoord treats the delivered task binding as causally active in request semantics and compares multi-step commitments with a strongly supervised single-step protocol. The reported gains combine commitment horizon with each protocol’s online control pattern.

  • Request semantics: Removing the delivered binding restores the paired 50% ceiling, while the alternative executable option drives the receiver to the paired world-state branch.The intervention changes task content while holding message presence, schedule, schema, and learned-call count fixed.
  • Counterfactual binding: 100.0% of receivers follow the delivered alternative in CONFIRM episodes, compared with 471/471 executable held-out cases.Every executable held-out output preserves the delivered binding; residual losses occur before executable plan formation.
  • Commitment horizon: Multi-step commitments improve held-out success and reduce online decisions, with the gain concentrated in allocation and active-continuation templates.Single-step training receives explicit intermediate-state supervision, so the measured difference combines horizon and online control pattern.
  • Strong baseline: The deterministic correct-binding rule reaches 100.0% versus 98.1% for multi-step GenCoord on the same held-out pool.The paired GenCoord-minus-rule difference is −1.9 pp, separating binding sufficiency from learned commitment formation.
  • Commitment horizon: +6.9 pp is the aggregate held-out-template success difference between multi-step and single-step commitments across 80 paired semantic clusters.The comparison evaluates complete systems under their corresponding training protocols.

HELD-OUT COMMITMENT HORIZON

The held-out horizon and backend analyses test whether executable commitments remain effective across task structures, binding combinations, and naturalized private-fact descriptions. Results favor multi-step commitments and factor-based realization while documenting the capability-conditioned route intervention.

  • Commitment horizon: 98.1% multi-step success exceeds 91.3% single-step success by +6.9 pp across 80 paired semantic clusters.The comparison is the aggregate held-out-template horizon result.
  • Backend formation: Explicit factor composition and Direct Short DSL recover all 60 tested unseen binding cross-products.Complete-case lookup covers observed cases only, whereas factor composition constructs fields across unseen combinations.
  • Naturalized private facts: Under stronger surface shifts, learned factor formation reaches 79.1% and 80.1%, exceeding TF–IDF by +19.7 pp and +17.6 pp, respectively.Direct Short DSL reaches 65.8% and 64.8% under the same two shifts.
  • Capability feedback: Across 40 Goal–Capability clusters, requester-local planning reaches 50%, correct feedback 100%, counterfactual feedback 0%, and centralized full information 100%.The suite contains 20 matched counterfactual pairs evaluated across three independently trained seeds.
  • Counterfactual intervention: +50.0 percentage points is the improvement from correct feedback over requester-local planning, while the paired counterfactual intervention changes success from 100% to 0%.The intervention holds requester input, initial proposal, and executable world fixed while changing the response.

S11 Reproducibility Notes

The reproducibility materials package canonical sources, ancillary data, validation checks, and build instructions for regenerating the reported analyses. Statistical procedures use semantic clusters as the independent unit with fixed-seed bootstrap intervals.

  • Validation: Pre-release validation checks data integrity, method identities, pool denominators, horizon means, paired-difference direction, confidence intervals, and bootstrap seeds.It also checks the corrected single-step inventory of 2,880 rows, three stage counts of 960, and 360 optimizer updates per seed.
  • Statistical procedure: Semantic clusters are the independent unit for representation, request, horizon, visibility, and primary E1/E2 analyses.Repeated role views and seeds are averaged within cluster before inference, and paired effects use cluster-aligned differences.
  • Packaged sources: The arXiv package contains the bibliography, canonical Supplement source, compact ancillary data, vector figures, and the deterministic E1/E2 table builder.Runtime dependencies include Qwen3.5-0.8B, Mineflayer 4.37.1, Node.js, Python, PyTorch, Transformers, and Minecraft Java server 1.21.4.
  • Build sequence: The E1/E2 tables can be regenerated with the bundled build_e1e2_tables.py script and the supplied training and analysis source files.The supplement is then compiled with the bundled bibliography.
Loading 2608.22055v1…