Run several AI coding sessions against one codebase and a familiar pattern appears quickly: the human becomes the message bus. State moves through copied terminal output, markdown files, JSON, shared directories, SQLite, or an improvised coordinator. These techniques can be useful transports. But transport is not the same thing as causality.

The important question is not only “did Task B receive a message from Task A?” It is “can B prove that this state came from the right logical operation, is still current, and satisfies the conditions that authorize B to proceed?”

A message is weaker than a handoff.

Consider a migration workflow. A producer emits migration_complete. Before the consumer acts, another session changes the schema again. The event is genuine, but the state it represented is stale.

operation→execution→state/evidence digest→dependency gate→consumer execution

A useful handoff therefore needs more than an event name. A minimal record could bind:

Candidate causal fields

1

logical_operation_id — stable across retries and re-drives.

2

execution_id — one concrete attempt.

3

state/evidence digest — immutable reference to what was actually produced.

4

outcome + invariants — what completed and what was verified.

5

dependency conditions — what must still be true before the consumer may run.

Retries should not invent new intent.

If an execution times out and a scheduler re-drives it, the new attempt should normally receive a new execution_id while preserving the same logical_operation_id. That separation prevents recovery from being misread as a second independent semantic operation.

logical_operation_id: migrate_schema_17

execution_001 → timeout
execution_002 → success
                   ↓
              verified handoff
                   ↓
              deploy_api_18

Receipt should not equal permission.

The consumer rule can stay deliberately small:

handoff valid ∧ producer outcome accepted ∧ invariants satisfied ∧ state current ∧ dependency conditions true

If any term fails, the downstream action should not silently proceed.

The transport can stay boring.

JSONL, SQLite WAL mode, append-only files, queues, named pipes, or native agent messaging can all carry the record. The proposal is transport-agnostic. The extra layer is the semantic contract above the transport: atomic publication, immutable evidence binding, freshness checks, retry identity, and explicit dependency gates.

Where this model should be attacked.

The useful next step is not to declare a protocol finished. It is to pressure-test the causal spine against production failure modes: partial writes, conflicting agents, stale state, duplicate delivery, crash recovery, revocation, concurrent valid producers, and long-running consumers that outlive the state they were bootstrapped from.

The Open Question

What breaks this model first?

If you run multi-agent coding workflows in production, which edge case would defeat this minimal causal handoff?

  • retry after ambiguous completion;
  • partial or torn handoff write;
  • two agents producing conflicting successor states;
  • consumer acting on superseded state;
  • crash recovery after an external side effect;
  • revocation after a handoff was published.
Send a production edge case →

A message says something happened. A causal handoff should make it possible to verify what happened, why it happened, whether it is still valid, and what may safely happen next.

Context

This note was prompted by public discussion around multi-session Claude Code coordination and field reports of shared-file, JSONL and coordinator-session workarounds. The causal-handoff framing is RESONANCE analysis and is intended as a testable hypothesis, not a claim of a finished standard.