Guild Stack

Harness developers

Build host adapters without inventing a second workflow.

Capabilities, fallbacks, and durable receipts make host differences inspectable while the lifecycle contract stays in one place.

Read architectureSee host support

Page evidence

Operational mapChoose the strongest path. Record every drop.
Execution substrate
  1. tmux teamparallel lanes
  2. host-nativenative delegation
  3. subagentbounded delegation
  4. serial classavailable, not wired
Adapter surface
  1. nativefull primitive
  2. wrappedverified wrapper
  3. bridgedtranslated capability
  4. emulatedrecorded substitute
  5. degradedexplicit loss

Host, substrate, and reviewer remain separate axes. The selected lower rung becomes a receipt.

Host, substrate, and reviewer are separate axes before an adapter reaches its detailed schema.

Contract crosswalk

One neutral adapter interface, with a readable boundary.

Start with the three runtime moments that every adapter must preserve. The complete crosswalk stays available when you need the implementation detail.

  1. 01
    Bootstrap

    Declare host capabilities and install the host-facing command surface.

  2. 02
    Run

    Resolve the available substrate, then dispatch the shared lifecycle without changing its meaning.

  3. 03
    Receipt

    Collect and validate a durable handoff so the next decision can reopen the evidence.

Open the complete 11-concern adapter crosswalk

Adapter contract

HostAdapter, 10 operations + the guild-run wrapper

capabilities()
Advertise what the host can do; the router reads this, never the host name.
bootstrap()
Install the package or inject the AGENTS.md instruction tree.
preflight()
Run-start hook, or the best available fallback rung when there is no native hook.
dispatch()
Run a lane on the selected substrate.
collect()
Read back and validate the lane result.
renderCommandSurface()
Expose /guild:* or the host-equivalent action surface.
renderPackage()
Emit host-native package metadata and install files.
renderPermissionDecision()
Render deny / ask / allow to the host UI or the file bus.
resolveModelParams()
Map cheap / mid / powerful tiers to host-native model params.
memory()
Reach guild-memory and guild-telemetry over a supported transport, or filesystem fallback.
bin/guild-run
The wrapper / bin bootstrap, the 11th concern beside the 10 operations.

The 10 operations plus the guild-run wrapper are the 11-concern contract (crosswalked to the 8 ADR adapter surfaces). Unknown hosts fail closed to an unavailable or explicit degraded path, never a guessed Claude path. The dedicated serial backend exists but is not selected by production code yet.

Runtime evidence

A manifest selects capability. A file bus leaves the receipt.

The capability manifest describes the host before routing. Lanes coordinate through local files, so an operator can inspect the result without needing the source host API.

Capability manifest

.guild/hosts/<host-id>/capability.json, guild.host_capability.v1

The runtime descriptor a host writes at bootstrap. It resolves model tiers from settings and probes the host for the primitives below; the cross-host router reads it to route lanes. It describes the host, it never routes anything itself.

tool_support.subagent
Can a subagent be spawned.
tool_support.agent_team
Native agent-team support.
tool_support.independent_agents
Independent parallel agents, or serial only.
tool_support.tmux
Probed at write time for the tmux dispatch rung.
tool_support.mcp
MCP transport for memory / telemetry, or filesystem fallback.

The router reads the manifest; the manifest does not route work by itself.

Durable receipt

The lane result stays portable because the receipt is a file.

Durable handoff receipt

.guild/runs/<id>/handoffs/<specialist>-<task-id>.md, guild.handoff_receipt.v1

A completed lane writes a durable Markdown receipt. It is distinct from guild.handoff.v2, the in-flight envelope the receipt embeds.

task_id
The lane this receipt answers.
tier
The resolved cost tier the lane ran at.
status
ok / escalate / blocked.
summary
Capped result summary.
artifacts[]
Files the lane produced.

The file bus is the portable host boundary. The launcher validates a receipt after the lane returns.

Operational mapAssignments go out. Typed receipts come back.
Lead
  1. lane assignment
  2. review packet
  3. gate decision
Specialist
  1. focused context
  2. bounded work
  3. handoff receipt
.guild/runs/
  1. task
  2. handoff
  3. review result

Files carry authority, evidence, and recovery state. Chat is not the durable bus.

Specialists write receipts. The lead reopens the files.
Static diagram behavior

Reduced motion: All artifact states stay visible without animation.

Recorded degradation

Take the strongest available path, then write down the drop.

The selected substrate is frozen at run start. When a host lacks a stronger primitive, the lower rung and its effect are part of the durable record.

  1. Rung 1

    tmux team

    Visible panes, one per specialist plus an orchestrator pane.

  2. Rungs 2-3

    in-process agent

    Host-native Agent / subagent dispatch when tmux is absent.

  3. Rung 4

    serial floor

    Conceptual universal floor. The SerialBackend class ships, but no production caller selects it yet.

  4. Cross-host

    remote (SSH)

    Runs a lane or reviewer on another box; selected by a separate routing block.

Support posture

A support label is not the same as public evidence.

Keep presentation support and receipt-derived public state separate, especially when a route uses a weaker host primitive.

Operational mapAvailability and evidence answer different questions.
  1. Resolve hostcapability manifest
  2. Name pathsupport label
  3. Verify routeoperator receipt
  4. Publish stateevidence-backed only
The label remains readable without claiming universal parity.

Public extension points

Use the shared contract, then verify the host result.

The architecture documents define the adapter boundary. The Hosts page carries the complete support matrix and the evidence behind each public state.
Open architectureOpen full host matrix