2604.03997

# Ledger-State Stigmergy: A Formal Framework for Indirect Coordination Grounded in Distributed Ledger State **Authors**: - Fernando Paredes García (Independent Researcher) ## Abstract Autonomous software agents on blockchains solve distributed-coordination problems by reading shared ledger state instead of exchanging direct messages. Liquidation keepers, arbitrage bots, and other autonomous on-chain agents watch balances, contract storage, and event logs; when conditions change, they act. The ledger therefore functions as a replicated shared-state medium through which decentralized agents coordinate indirectly. This form of indirect coordination mirrors what Grassé called stigmergy in 1959: organisms coordinating through traces left in a shared environment, with no central plan. Stigmergy has mature formalizations in swarm intelligence and multi-agent systems, and on-chain agents already behave stigmergically in practice, but no prior application-layer framework cleanly bridges the two. We introduce Indirect coordination grounded in ledger state (Coordinación indirecta basada en el estado del registro contable) as a ledger-specific applied definition that maps Grassé’s mechanism onto distributed ledger technology. We operationalize this with a state-transition formalism, identify three recurring base on-chain coordination patterns (State-Flag, Event-Signal, Threshold-Trigger) together with a Commit-Reveal sequencing overlay, and work through a State-Flag task-board example to compare ledger-state coordination analytically with off-chain messaging and centralized orchestration. The contribution is a reusable vocabulary, a ledger-specific formal mapping, and design guidance for decentralized coordination over replicated shared state at the application layer. Keywords: Stigmergy, Distributed Coordination, Shared-State Coordination, Distributed Systems, Distributed Ledger, Multi-Agent Systems, Smart Contracts. ## 1 Introduction Blockchains started as a fix for the double-spending problem [16]. After Ethereum added Turing-complete smart contracts [17, 18], they turned into general-purpose shared-state machines: every participant reads the same world state, every transaction yields a deterministic state transition, and confirmed state is globally visible. At the application layer, this creates a distributed-coordination problem over replicated shared state rather than over direct message exchange or centralized assignment. An ecosystem of autonomous agents has grown up in this environment. Arbitrage bots, liquidation keepers, maximal extractable value (MEV) searchers, and decentralized autonomous organization (DAO) delegates all coordinate without direct messages. They read the chain, infer work from shared traces, and execute. The coordination mechanism they rely on has a name, borrowed from entomology. In 1959, Pierre-Paul Grassé noticed that termites build architecturally complex nests without blueprints or supervisors [1]. A termite drops a pheromone-laden mud pellet; that pellet stimulates the next termite to drop one nearby. Grassé called the mechanism stigmergy. Swarm intelligence researchers adopted it [4, 3], it showed up in robotic coordination [8], open-source development [9], and Wikipedia editing [10]. Heylighen [6, 7] generalized it into four components (agent, medium, trace, stimulation rule) and argued it is a universal coordination mechanism. Application-layer connections between stigmergy and blockchain remain sparse. Gürcan [22, 23] modeled Proof-of-Work consensus as stigmergic, the most rigorous prior treatment, but his scope was limited to the consensus layer. Capaccioli [24] sketched a link between Bitcoin and swarm intelligence without operational definitions. Dounas et al. [25] applied the concept to architectural collaboration on-chain but did not produce a general framework. Adjacent swarm-robotics work has used blockchain smart contracts to coordinate physical or simulated robot swarms [34, 35], but its focus is robot meta-control rather than application-layer coordination patterns for software agents. Existing work still stops short of mapping the full stigmergy apparatus onto application-layer ledger components and developing the resulting coordination patterns as a reusable catalogue for decentralized coordination over shared state. This paper addresses that gap by treating the ledger as a coordination medium, not only as an execution substrate. Definition. Building on Grassé’s notion of stigmergy (1959), we introduce Indirect coordination grounded in ledger state (Coordinación indirecta basada en el estado del registro contable) as a ledger-specific applied definition of stigmergic coordination for distributed ledgers, where ledger state is the shared medium that agents observe and act upon. Contributions. 1. We introduce ledger-state stigmergy as a named ledger-specific applied concept. The original stigmergy mechanism belongs to Grassé [1]; the ledger-specific definition and application-layer specialization are introduced in this paper. 1. We operationalize the definition with a state-transition formalism ( $S_t$ , $δ$ , $O_i$ , $P_i$ ) and identify three recurring base patterns together with a Commit-Reveal sequencing overlay for on-chain stigmergic coordination. 1. We illustrate the framework through a State-Flag task-board example and use it to draw out the main trade-offs against off-chain messaging and centralized orchestration. A companion preprint [36] develops medium-agnostic mathematical foundations for stigmergic coordination over arbitrary shared media. The present paper specializes that abstract framework to the distributed ledger domain and contributes the applied definition, design patterns, and application-layer analysis independently. The formalism used here is deliberately lightweight: it provides a disciplined notation for ledger-observable traces and predicates, while the companion carries the theorem-level machinery. Scope. We address application-layer coordination over shared ledger state, not consensus mechanisms (covered by Gürcan [22]). Token economics, governance design, and layer-2 scaling fall outside scope unless they directly affect the coordination patterns. The paper argues through a running analytical example rather than a simulation study; limits appear in Section 7.7. Research Questions. RQ1. Can the classical stigmergy framework (medium, trace, agent, activation) be formally mapped onto distributed ledger components? RQ2. What distinct on-chain coordination patterns emerge from treating ledger state as a stigmergic medium? RQ3. What trade-offs emerge when shared-state stigmergic coordination is contrasted analytically with off-chain messaging and centralized orchestration? Organization. Section 2 reviews background. Section 3 defines the formal model. Section 4 develops the pattern catalogue. Section 5 develops the running example. Section 6 compares the coordination styles analytically. Section 7 discusses implications and limits. Section 8 covers related work, and Section 9 concludes. ## 2 Background Three traditions converge in our definition: biological and computational stigmergy, environment-mediated coordination in multi-agent systems, and blockchains as state machines. ### 2.1 Stigmergy: From Termites to Software Grassé [1] coined stigmergie (Greek stigma, “sign,” plus ergon, “work”) from fieldwork on termite construction. A termite deposits a mud pellet laced with pheromone; the pellet’s presence stimulates a neighbor to deposit another nearby. No termite carries a plan. Structure emerges from local reactions to a shared physical environment. Theraulaz and Bonabeau [2] refined the picture, distinguishing sematectonic stigmergy (where the structure itself is the stimulus, as when a half-built column invites completion) from marker-based stigmergy (where a separate chemical signal, like a pheromone trail, carries the information). Dorigo et al. [3, 5] translated marker-based stigmergy into Ant Colony Optimization, showing that artificial pheromone trails on a graph can solve combinatorial problems. Bonabeau et al. [4] organized these results under the label of swarm intelligence. Parunak et al. [8] applied digital pheromone fields to unmanned vehicle coordination. Heylighen [6] produced the most general theoretical account, decomposing stigmergy into four components: (i) an agent that acts, (ii) a medium in which traces persist, (iii) a trace left by the action, and (iv) a stimulation rule linking traces to subsequent actions. A companion paper [7] classified varieties along two axes: quantitative versus qualitative traces, and sematectonic versus marker-based. His point was that any system where agents modify a shared environment and those modifications guide later behavior qualifies as stigmergic. The “environment” can be a termite mound, a software repository, a wiki page, or, as we argue here, a distributed ledger. This four-component decomposition provides the scaffold for our ledger mapping in Section 3. ### 2.2 Indirect Coordination in Multi-Agent Systems Computer science reached similar ideas through a different path. Gelernter’s Linda [11, 12] introduced tuple spaces: shared associative memory where processes coordinate by writing, reading, and consuming data without knowing each other’s identities. The producer does not need to know who will consume its tuple, or when. Malone and Crowston [13] framed coordination more broadly as managing dependencies among activities, a definition that covers both message-passing and environment-mediated approaches. Weyns et al. [14] argued that treating the environment as an inert container for agents misses a source of coordination. They proposed the environment as a first-class abstraction. Omicini et al. [15] pushed further with coordination artifacts: objects embedded in the environment that encapsulate interaction rules and mediate how agents behave together, without requiring agents to know about each other. Smart contracts do exactly this on a blockchain, but the connection has not, to our knowledge, been made explicit in the literature. ### 2.3 Blockchain as Shared-State Machine A blockchain is a replicated state machine [30]. Ethereum’s world state $σ$ maps every account to its balance, nonce, code, and storage [18]. A transaction $T$ produces a deterministic transition: $σ_t+1=Υ(σ_t,T)$ . Four properties matter here: the resulting state is globally visible (any full node can read it), immutable once confirmed, deterministic, and cryptographically authenticated. These properties make the ledger a good fit for a stigmergic medium: a shared environment where every action leaves a persistent, visible, verified trace that other agents can react to [19]. Smart contracts, in this reading, are coordination artifacts [15] embedded in that medium. A contract holds rules (its bytecode) and state (its storage), and agents interact with each other only through it. A Uniswap pool makes this concrete. The contract stores token reserves; a large swap pushes the on-chain price away from the external market; that price gap is a trace. An arbitrage bot sees the gap (its predicate fires), submits a corrective swap (its action), and the reserves update (a new trace that may trigger further agents). The liquidity provider and the arbitrageur never talk. All coordination runs through the pool’s storage. The pool contract plays the same functional role as the termite mound in Grassé’s original account: a shared medium that accumulates traces and stimulates action. ### 2.4 The Gap Table 1 maps the key sources to our definition. Each thread is well-developed on its own, but the intersection has barely been explored. Gürcan [22] produced the strongest prior connection; his scope was consensus, not coordination patterns. Capaccioli [24] gave a conceptual sketch with no operational definitions. Dounas et al. [25] stayed within a single application domain. Adjacent swarm-robotics work has used blockchain smart contracts to coordinate physical or simulated robot swarms [34, 35], but its focus is robot meta-control rather than application-layer smart-contract coordination patterns for software agents. A general, formalized bridge for the application layer is still missing. Table 1: Literature mapping: concept, source, and role in our definition ## 3 Definition and Formal Model ### 3.1 The Definition Building on Grassé [1], we define: “Coordinación indirecta basada en el estado del registro contable.” (Indirect coordination grounded in ledger state.) This definition introduces the ledger-specific specialization used in the present paper and connects it to the medium-agnostic shared-medium framework developed in [36]. It makes three commitments: the coordination is indirect (agents do not exchange messages), the substrate is the ledger state (world state plus event logs), and agents’ actions are grounded in observations of that state, meaning the state causally triggers the action. The Spanish formulation anchors the concept in the Latin American research tradition while the English translation keeps it accessible. ### 3.2 Mapping stigmergy components to ledger primitives Table 2 shows the mapping from Heylighen’s four components [6] to their ledger equivalents. This is not a loose analogy. Each component has a concrete counterpart in the ledger architecture, and the relationships between them (agent acts on medium, medium presents trace, trace triggers agent) are preserved structurally. Table 2: Stigmergy $→$ ledger mapping ### 3.3 Minimal formalization Let $S$ be the set of valid ledger states, $A$ the set of valid actions (transactions), and $I$ the set of agents. **Definition 1 (Ledger-State Stigmergy)** *A ledger-state stigmergic system is a tuple $$ ⟨S,A,I,\{V_i\}_i∈I,δ,\{O_i\}_i∈I,\{P_i\}_i∈I⟩ $$ where: - $S_t∈S$ is the agent-observable ledger record at block height $t$ , comprising confirmed world state together with the authenticated logs and receipts that agents can inspect after confirmation. - $a∈A$ is an action (transaction) executed by some agent $i∈I$ . - $δ:S×A→S$ is the deterministic state-transition function: $S_t+1=δ(S_t,a)$ . - For each agent $i$ , $V_i$ is an agent-specific information set (local view), typically a projection of that ledger record onto the data visible to $i$ . - $O_i:S→V_i$ is the observation function for agent $i$ , projecting the global ledger record to that local view. - $P_i:V_i→\{0,1\}$ is the activation predicate. When $P_i(O_i(S_t))=1$ , agent $i$ selects and submits an action $a_i$ .* Throughout the pattern catalogue below, we sometimes write $P_i(S_t)$ as shorthand for $P_i(O_i(S_t))$ when the observation map is not the analytic focus. Action selection itself is left outside the tuple: the companion’s broader system class adds explicit response maps for that step, while this paper keeps only the activation condition needed for the application-layer patterns. The total transition $δ$ is likewise an idealization; deployed transactions can revert or lose races, and the wasted effort discussed in Section 6 comes from those failed or displaced attempts. The stigmergic loop. Agent $j$ executes $a_j$ , producing $S_t+1=δ(S_t,a_j)$ . Agent $i$ , who has no idea $j$ exists, observes $O_i(S_t+1)$ . If $P_i$ fires, $i$ submits $a_i$ , yielding $S_t+2=δ(S_t+1,a_i)$ . That new state may trigger yet another agent. No message passes between $i$ and $j$ ; collective behavior emerges from shared observation alone. This tuple is a ledger-specific specialization of the abstract shared-medium system class $$ \mathfrak{S}=⟨M,A,I,U,\{O_i\},\{P_i\},\{R_i\}⟩ $$ developed in [36], where additional structure—explicit response maps, admissibility conditions, and a decay operator for non-persistent media—is axiomatized and proved. The observation function $O_i$ allows heterogeneous views: a liquidation bot watches collateral ratios while a governance delegate watches vote counts. We impose no algebraic structure on $V_i$ beyond set membership; in this applied paper it is simply the codomain needed to express agent-specific observations. The predicate $P_i$ is deliberately left abstract; it can encode a simple threshold check or a learned policy from a reinforcement learning agent. The model also says nothing about observation latency. In practice, there is always a delay between a state transition being committed and an agent detecting it, but that delay belongs to the implementation, not the model. In deployed ledgers, transactions are also batched into blocks, so an agent may act on a state it observed earlier than the state in which its transaction eventually executes; the contention and frontrunning discussed below arise from that operational gap rather than from extra structure in the tuple. ### 3.4 Relationship to Heylighen’s taxonomy In Heylighen’s classification [7], ledger-state stigmergy is primarily sematectonic: the state structure itself (a contract’s storage layout, a pool’s reserve ratio) is the stimulus, not a detached marker. The traces are quantitative: balances, counters, and timestamps carry graded signals rather than binary ones. One difference from biological stigmergy stands out. Pheromone trails evaporate; ledger state does not. Biology has built-in garbage collection. On-chain, a stale trace persists unless the contract includes explicit expiry logic. We revisit this in Section 7. ### 3.5 Conceptual architecture Figure 1 shows the basic layout. Agents read the ledger (downward arrows) and write to it via transactions (upward arrows). There is no lateral channel. Ledger-State Stigmergic Coordination Architecture Agent A Agent B Agent C | observe | observe | observe v v v +-----------------------------------------------+ | LEDGER STATE (Medium) | | $σ_t$ : world state + $L$ : event logs | +-----------------------------------------------+ ˆ ˆ ˆ | write | write | write Agent A Agent B Agent C All coordination runs through the ledger. No direct agent-to-agent channel exists. Figure 1: Conceptual architecture of ledger-state stigmergy ## 4 Design Patterns for Ledger-State Stigmergy The general model admits different realizations depending on which part of the state carries the trace and how the activation predicate is structured. We identify three recurring base patterns for single-contract ledger-state coordination together with one cross-cutting sequencing overlay, ordered by complexity. They are best read as an applied pattern catalogue rather than as a closed classification of every possible ledger-state stigmergic design. ### 4.1 Pattern 1: State-Flag A contract stores a Boolean or enumerated variable, say a task status that cycles through OPEN, CLAIMED, and DONE. Agents poll it. When the flag reads OPEN and the agent has the right capabilities, the agent claims the task. The trace is a storage-slot update ( $\texttt{flag}_t≠\texttt{flag}_t+1$ ). The activation predicate: $P_i(S_t)≡(\texttt{flag}=\texttt{OPEN})\wedge(\texttt{agent}_i\texttt{.capable}=\texttt{true})$ . Gas cost is low (one SLOAD to read the flag) and the pattern is easy to audit. The problem is contention. If several agents see OPEN in the same block, they all submit a claim, and all but one waste gas. Frontrunners can also snipe claims by watching the mempool and bidding higher gas prices [26]. Combining State-Flag with commit-reveal (Pattern 4) or routing claims through a private mempool reduces this risk. For griefing, where an agent claims a task and never finishes it, staking a bond with automatic reversion on timeout works well. Operationally, single occupancy in the worked contract comes from serial transaction execution together with a guard that causes later claimants to fail once the flag is no longer OPEN. The companion preprint gives an abstract guarded-claim exclusivity result (Proposition 7.1 of [36]) that supports this single-occupancy intuition under serial execution. Keeper networks like Gelato and Chainlink Keepers follow this pattern. A contract exposes a machine-readable readiness check; keepers race to execute when that check indicates the task is actionable. ### 4.2 Pattern 2: Event-Signal Rather than polling storage, agents subscribe to event logs. A contract emits TaskPosted(taskId, reward, deadline) when a relevant state change occurs, and agents filter the log stream for matching events. The trace is an event appended to $L$ . Activation predicate: $P_i(S_t)≡∃ e∈L_t:e.\texttt{type}=\texttt{TaskPosted}\wedge e.\texttt{reward}≥θ_i$ . Off-chain indexing (The Graph, WebSocket subscriptions) makes event monitoring cheaper than repeated SLOAD calls. The catch is that events live in transaction receipts, not in the world state $σ$ , so a smart contract cannot read its own past events. This limits on-chain composability. Operationally, the pattern is hybrid: the triggering trace is on-chain, but most agents observe it through off-chain RPC or indexing infrastructure. What keeps the pattern inside this catalogue is the location of the coordination trace itself: the event is committed to the chain’s authenticated record even when the observation path runs through middleware. The medium therefore remains ledger-grounded while the observation channel is operationally hybrid. Spam is a risk too: a malicious contract can emit fake events to bait agents into wasted transactions. Verifying the emitting address, cross-checking against storage state, and accounting for indexer lag or eclipse-style middleware failures are standard practice. Reorganizations can cause events from orphaned blocks to vanish; waiting for $k$ confirmations before acting handles this. Uniswap V2 and V3 emit Swap events that indexers and arbitrage bots consume. Bots often subscribe to these events instead of polling reserves, since the logs summarize swap activity in one place. ### 4.3 Pattern 3: Threshold-Trigger A quantitative state variable crosses a boundary: a lending pool’s collateralization ratio drops below the liquidation line, a governance vote reaches quorum, or a token balance hits a cap. Activation predicate: $P_i(S_t)≡\texttt{collateralRatio}(S_t)<θ_liquidation$ . Economic incentives fit naturally with this pattern: agents earn rewards for acting when thresholds are breached, and graded traces allow nuanced responses. But Threshold-Trigger is the pattern most exposed to MEV. Validators can see threshold-crossing transactions in the mempool and reorder them for profit [26]. Batch auctions [27] and MEV-share schemes offer partial mitigation. Oracle manipulation is a second threat: if the threshold depends on an external price feed, a corrupt oracle can force false activations. Time-weighted average prices and multi-oracle medians are the usual defenses. Lending-protocol liquidations illustrate this directly. In Aave’s terminology, when a borrower’s health factor drops below 1.0, any external agent can call the liquidation function and collect a bonus. The health factor is the trace, the bonus is the incentive, and the liquidation call is the stimulated action. No central party assigns liquidators. ### 4.4 Pattern 4: Commit-Reveal Sequencing Overlay When frontrunning risk is high, one of the base patterns above can be wrapped in a two-round sequencing overlay. Each agent first commits a hash of its intended action ( $\texttt{commitments}[i]=H(a_i\|\texttt{salt}_i)$ ). After a delay, agents reveal the plaintext. The contract validates the hash and processes the action. Phase 1 predicate: $P_i^commit(S_t)≡\texttt{phase}=\texttt{COMMIT}\wedge¬\texttt{hasCommitted}(i)$ . Phase 2: $P_i^reveal(S_t)≡\texttt{phase}=\texttt{REVEAL}\wedge\texttt{hasCommitted}(i)\wedge¬\texttt{hasRevealed}(i)$ . Direct mempool frontrunning is reduced substantially, but cost doubles (two transactions), latency increases by at least one block, and gas roughly doubles. Commitments also occupy storage until reveal or cleanup clears them. The main risk is griefing by non-reveal: an agent commits then withholds the reveal. Requiring a stake at commit time and slashing non-revealers addresses this, though it adds friction. Commit-reveal is therefore best read as a cross-cutting sequencing overlay rather than as a fourth same-level trace family: it phase-gates actions over State-Flag, Event-Signal, or Threshold-Trigger structures when the value at stake justifies the overhead. ENS domain auctions used this scheme historically. Bidders committed hashed bids, then revealed them after a deadline. Competitors could not see or outbid each other in real time. ### 4.5 Pattern comparison Table 3 summarizes trade-offs. Table 3: Comparison of ledger-state stigmergy base patterns and sequencing overlay | State-Flag | Storage var. | Bool/enum | Low | 1 block | Frontrunning | | --- | --- | --- | --- | --- | --- | | Event-Signal (hybrid) | Log entry | Subscription | Med. | 1 block+ | Spam, reorgs | | Threshold | Numeric var. | Inequality | Med–High | 1 block | MEV, oracles | | Commit-Reveal overlay | Two-phase | Phase-gated | High ( $∼$ 2 $×$ ) | $≥$ 2 blocks | Non-reveal | The three base patterns are not mutually exclusive, and the Commit-Reveal overlay can wrap them when frontrunning risk justifies the added cost. A lending platform might use Threshold-Trigger for liquidations and a Commit-Reveal overlay for governance votes within the same deployment. We therefore treat these base patterns and overlay as an open analytical catalogue for single-contract coordination rather than as an exhaustive taxonomy. A further addition would need either a distinct trace/predicate structure or a distinct sequencing structure not reducible to these cases. ## 5 Worked Example: On-Chain Task Board To make the framework concrete, consider a decentralized task board: a contract that posts tasks, and autonomous agents that claim and complete them using only the shared ledger state for coordination. In the sense introduced in Section 2, the TaskBoard contract is the coordination artifact through which agents interact indirectly. The example instantiates the State-Flag pattern and anchors the comparison developed below. It is intentionally a State-Flag witness rather than a worked demonstration of the full catalogue. ### 5.1 Scenario A TaskBoard contract manages tasks $T_j$ with a reward $r_j$ , a deadline $d_j$ (block number), and a difficulty indicator $w_j$ describing the effort needed to complete them. Lifecycle follows State-Flag: $\texttt{OPEN}→\texttt{CLAIMED}→\texttt{DONE}$ (or EXPIRED). Agents watch the board with heterogeneous capability profiles and finite operating budgets. Their behavior is simple: read state, check for open tasks matching their capabilities, claim if one is available, and later submit completion. This example is intentionally minimal so that the coordination mechanism remains visible instead of being buried under DeFi- or DAO-specific protocol detail. ### 5.2 Three coordination styles Off-chain messaging + on-chain execution (MSG). Agents discover tasks through a reliable off-chain pub/sub channel, negotiate claims off-chain, and then execute the agreed action on-chain. Centralized orchestrator + on-chain execution (ORCH). A trusted orchestrator assigns tasks by capability matching, informs agents off-chain, and lets them execute on-chain. This is the efficiency-oriented baseline: it minimizes duplication of effort but introduces a single coordination authority. Ledger-state stigmergy (STIG). No off-chain coordination channel exists. Agents observe only the TaskBoard state and act on their predicates. In deployment they may still rely on RPC or indexing infrastructure to observe that state, but that observation stack is not itself the coordination channel. Trust rests solely on the ledger’s consensus mechanism and on the contract’s trace-management logic. ## 6 Analytical Comparison of Coordination Styles Table 4 summarizes the comparison developed in this section. The strongest claims below are anchored in the State-Flag task-board witness; broader transfer to the rest of the catalogue remains a design hypothesis rather than an established general result. Within that witness, the TaskBoard contract is the coordination artifact that internalizes the coordination rules into the shared medium instead of delegating them to a side channel or scheduler. Table 4: Analytical comparison of coordination styles for the task-board witness | STIG | Ledger consensus plus contract rules | High when many agents react to the same visible trace | On-chain medium: expiry, timeout, staking, slashing | High; traces and recovery logic are protocol-visible | Ledger plus practical RPC/indexing reliance for observation | | --- | --- | --- | --- | --- | --- | | MSG | Reliable off-chain coordination channel | Lower if negotiation succeeds before submission | Off-chain coordination and participant retry | Medium; agreement happens outside the ledger | Ledger plus messaging infrastructure | | ORCH | Trusted scheduler or operator | Lowest in benign operation; scheduler bottlenecks remain | Central scheduler and its operational procedures | Low–medium; assignment logic is external | Ledger plus orchestrator service | ### 6.1 Benign trade-offs In benign conditions, the task-board witness makes ORCH the coordination-efficiency ceiling. Because a single trusted scheduler assigns tasks, it avoids most duplicate claims and minimizes wasted action, though that efficiency comes with scheduler-side assignment overhead and a concentrated trust point. MSG softens that advantage by distributing discovery and negotiation, but still relies on a side channel to keep collisions low before transactions reach the chain. STIG removes that side channel entirely. Its strength is trust minimization and public legibility: every agent can inspect the same contract state and decide locally whether to act. It also shifts coordination liveness onto the ledger and the observation stack that agents use to follow its traces. The price is contention. If several agents see the same OPEN flag in the same block, they may all attempt to claim it, and all but one will waste effort or gas. Within this State-Flag witness, that makes STIG the most transparent coordination style and usually the least coordination-efficient one in quiet conditions. We expect similar pressure wherever many agents are stimulated by the same visible trace, but this paper does not establish that as a general result for every pattern in the catalogue. ### 6.2 Adversarial pressure The comparison changes once coordination logic must survive dishonest or unreliable participants. A stigmergic design can embed recovery directly into the medium: staking, timeout reversion, claim caps, and explicit expiry all make the trace self-correcting without relying on a trusted scheduler. That is the main architectural advantage of the approach. However, this paper does not claim measured Byzantine superiority. If STIG is equipped with timeout or slashing logic while ORCH and MSG are not, any advantage belongs to the full mitigation package, not to stigmergy in isolation. A future empirical paper must test those baselines symmetrically before turning this analytical observation into a quantitative claim. ### 6.3 Scaling considerations The central scaling variable is not merely the number of agents but the ratio of agents to simultaneously actionable traces. A finite batch of open tasks invites races; continuous arrival or finer-grained partitioning would diffuse that pressure. Under a ledger-state design, scalability therefore depends on how often many agents are stimulated by the same visible trace at once. That scaling story is clearest for collision-heavy State-Flag settings like the task board; transfer to Event-Signal, Threshold-Trigger, or overlay-heavy cases remains a hypothesis for later validation. This leads to a practical design rule: reduce unnecessary trace collisions. Partition work where possible, expose capability-relevant filters, and make stale traces expire or decay. Those steps do not eliminate contention, but they keep a stigmergic system from degenerating into permanent claim races. ### 6.4 Worked-example takeaway The task board highlights the main architectural trade-off cleanly. MSG and ORCH externalize coordination into communication channels or scheduler-side assignment machinery. STIG internalizes coordination through the contract-as-artifact together with the shared ledger medium. That makes STIG more autonomous and more legible at the protocol boundary, but it also forces the contract designer to pay for contention management, stale-trace cleanup, and failure recovery explicitly. ## 7 Discussion ### 7.1 When this approach makes sense On-chain stigmergic coordination costs more gas than stronger off-chain coordination mechanisms and introduces contention. It is not always the right choice. It pays off when trust assumptions are minimal, when there is no reliable off-chain channel, and when protocol-level legibility matters more than raw efficiency. A rough heuristic is simple: if the cost of a coordination failure (a missed liquidation, a stuck task, an uncounted vote) exceeds the premium of keeping the coordination trace on-chain, the stigmergic approach is worth the extra machinery. Otherwise, MSG or ORCH will often be cheaper and faster. ### 7.2 Contract design lessons If autonomous agents will interact with your contract, make readable state a design priority. Well-delimited status flags, monotonic counters, and documented storage layouts help agents evaluate predicates efficiently. Staking, timeout reversion, and rate limits should be defaults for contracts meant for multi-agent use. There is a specific design recommendation here: expose dedicated view functions that return what agents need to evaluate activation predicates. A getOpenTasks() function is more agent-friendly than forcing agents to iterate a mapping and filter by status. This amounts to “stigmergic interface design”: making traces legible to the agents that read them. ### 7.3 Security and incentive surface Public, legible traces are a double-edged design choice. They let mutually distrustful agents coordinate without direct messaging, but they also expose the medium to frontrunning, spam, nuisance claims, and strategy leakage. Rewards such as liquidation bonuses, keeper fees, or task payouts give agents reasons to react, yet the same visibility can make profitable traces copyable by faster or better connected actors. That is why expiry, claim caps, staking, and timeout reversion are not just application logic but medium hygiene. They bound state pollution and turn some harmful deviations into costly ones rather than free ones. They also exploit a simple economic floor: flooding the medium with low-value traces is not free when the attacker must keep paying transaction fees to sustain the spam. Where ordering games dominate, commit-reveal, batch execution, or private orderflow can reduce direct imitation, though each shifts assumptions or adds latency rather than eliminating the underlying stigmergic mechanism [37, 38, 39]. Privacy-preserving predicates and layered execution are natural extensions for the same reason: they preserve ledger-mediated coordination while changing what part of the trace is publicly legible and when it should be treated as final. ### 7.4 Persistent versus decaying traces Pheromones evaporate. Ledger state does not. An expired task still marked OPEN, because nobody paid the gas to flip it, can trigger wasted agent actions indefinitely. On-chain stigmergic state should include an expiration mechanism: a block-number deadline, an epoch counter, or an explicit invalidation call. A more interesting approach is “trace decay” via decreasing rewards. A contract could reduce the payout of a stale task over time, gradually weakening agents’ predicates without requiring an explicit invalidation transaction. Whether the gas cost of such logic is worth it remains context-dependent, but the design direction seems promising. There is an analogy here to Dorigo’s original ant colony optimization work [3], where pheromone evaporation was not a bug but a feature. Without evaporation, early pheromone trails would dominate forever, preventing the colony from adapting to changing conditions. On-chain trace decay would serve the same function: letting stale coordination signals fade so that agents can redirect attention to current opportunities. The difference is that on-chain decay costs gas, while biological evaporation is thermodynamically free. The companion preprint [36] formalizes this distinction through a decay operator $D:M→M$ applied between update steps, with persistent-trace systems recovered as the special case $D=id$ . More generally, forgetting response-relevant metadata such as timestamps collapses behavioral distinctions unless some replacement state structure is added back in. ### 7.5 Cross-protocol stigmergy Our running example involved a single contract. In practice, DeFi composability means that a trace in one contract routinely triggers actions in another. A large deposit into a yield aggregator changes the aggregator’s allocation strategy, which rebalances underlying lending pools, which shifts interest rates, which triggers borrowers to refinance. Each step is a stigmergic reaction to a trace left by the previous step, and the chain of reactions can cross half a dozen protocols without any two participants being aware of each other. This cross-protocol version of ledger-state stigmergy is more complex than what our model captures. The observation function $O_i$ would need to project over multiple contract states simultaneously, and the activation predicate might depend on relationships between states rather than simple thresholds within a single contract. Formalizing this would require extending the tuple $⟨S,A,I,\{V_i\}_i∈I,δ,\{O_i\}_i∈I,\{P_i\}_i∈I⟩$ to a multi-contract setting, likely with a product state space and cross-contract observation functions. Such a product construction is developed abstractly in [36] (Proposition 7.2), where closure of admissible systems under product composition is proved; the companion also shows that freshness-sensitive behavior in a refined medium does not always admit a clean coarse-medium counterpart. We leave this extension for future work, but note that the basic vocabulary (medium, trace, predicate) still applies; what changes is the topology of the observation graph. ### 7.6 MEV as an adjacent broader case MEV searchers [26] are the most visible real-world instance of stigmergic competition around ledger systems, but they sit outside the paper’s strict core object because they react not only to ledger state (world state plus logs) but also to pre-confirmation signals in the mempool and builder pipeline. We therefore treat MEV as an adjacent broader case over a ledger-observable surface rather than as a pure single-medium instance of ledger-state stigmergy. Searchers watch pending order flow together with on-chain state, detect profitable configurations (arbitrage gaps, liquidatable positions), and submit transactions to capture them. The analogy runs deeper than terminology. Ants following pheromone trails can create traffic jams when too many converge on the same path. MEV searchers competing for the same opportunity create gas-price bidding wars that congest the network. Flashbots can be read as an attempt to channel this wild stigmergy into structured auctions, reducing the collateral damage. ### 7.7 Limits of This Paper Analytical status. This paper does not report simulation outputs, deployment measurements, or quantitative benchmark data. Its comparison among STIG, MSG, and ORCH is analytical: it identifies mechanism-level trade-offs and mitigation hooks without claiming measured performance gaps. Example scope. The task board is deliberately simple. Real applications involve nested calls, cross-protocol dependencies, heterogeneous agent populations, and often continuous task arrival instead of a single fixed pool of actionable traces. The example also instantiates only the State-Flag pattern, not the three base patterns plus the sequencing overlay. Fee and execution realism. A live network would add block-time variability, fee-market dynamics, builder incentives, mempool games, RPC/indexer latency, and richer adversarial behavior. Those factors matter, but they are outside the evidence base of this paper and belong in a future empirical branch. The same visibility that enables coordination can also leak agent intent and support spam or nuisance races; those risks are discussed qualitatively here but not measured. Highly legible coordination for participating agents can also remain opaque to outsiders who do not share the same observation stack or strategic position. Future validation. The natural next step is not rhetorical expansion but empirical validation. Any later paper that wants to claim quantitative robustness, gas bounds, or scaling behavior must supply a real simulator or deployment artifact together with recorded outputs. ## 8 Related Work Distributed coordination and shared-state systems. Our closest computer-science lineage outside blockchain-specific work is the literature on coordination through shared state and environment-mediated interaction. Linda tuple spaces and coordination languages [11, 12] showed how distributed processes can coordinate through shared associative memory without pairwise identity knowledge. Malone and Crowston [13] framed coordination more broadly as dependency management, while Weyns et al. [14] and Omicini et al. [15] treated the environment and coordination artifacts as first-class abstractions. The present paper differs by specializing that lineage to replicated ledger state, where traces are globally visible, persistent, and authenticated by consensus rather than maintained by an external shared-memory service. Digital stigmergy. Parunak et al. [8] applied digital pheromone fields to UAV coordination. Bolici et al. [9] documented stigmergic patterns in open-source teams. Elliott [10] argued that Wikipedia editing is stigmergic: editors modify a shared artifact and those modifications stimulate further edits. Zheng et al. [32] provided quantitative evidence that edit traces predict subsequent editing activity. None of these works address blockchain. Blockchain coordination. Lumineau et al. [21] studied blockchain governance as a coordination form but without the stigmergy lens. Hassan and De Filippi [20] formalized DAOs; whether DAO governance is better understood as stigmergic coordination than as voting remains an open question worth investigating. Cong and He [33] analyzed how blockchain resolves information asymmetry in economic settings. Stigmergy $×$ blockchain. Gürcan [22, 23] is closest to us. He modeled PoW as stigmergic consensus within a multi-agent systems paradigm: miners leave computational traces (valid blocks) that stimulate others to extend the longest chain. We address the application layer instead of consensus, offer a general four-component mapping, and include an application-layer analysis. Capaccioli [24] linked Bitcoin to swarm intelligence in an informal essay. Dounas et al. [25] applied stigmergy to on-chain architectural collaboration. Adjacent swarm-robotics and decentralized-service work also treats shared ledger state as an indirect coordination substrate [34, 35, 40, 41, 42]. That line of work is close in spirit, but its object is usually robot behavior, service orchestration, or application-specific cooperation rather than an application-layer coordination vocabulary for on-chain software agents. These works do not provide the ledger-specific mapping, pattern catalogue, and analytical comparison developed here. Formal models and security. Garay et al. [30] formalized the Bitcoin backbone protocol. Luu et al. [28] and Tolmach et al. [31] surveyed smart contract verification. Castro and Liskov [29] established PBFT. Daian et al. [26] characterized MEV. Kelkar et al. [27] proposed order-fair consensus. Recent work also treats mitigation as part of the economic environment: Canidio and Danos [37] analyze commitment mechanisms against front-running, Capponi et al. [38] study private-orderflow adoption, and Öz et al. [39] document concentration in MEV-Boost block-building auctions. We draw on this literature both as validation (MEV is stigmergic) and as threat model (stigmergic visibility is exploitable). Medium-agnostic foundations. Paredes García [36] develops an axiomatic framework for stigmergic coordination over arbitrary shared media, formulating a core system tuple, admissibility classes (persistent/decaying traces, exclusive-resource systems), response equivalence under observation-faithful representation, and a quotient adequacy/repair cycle for metadata refinements. That work is deliberately medium-agnostic; the present paper provides the ledger-specific specialization, applied definition, design patterns, and application-layer analysis. ## 9 Conclusion We introduced ledger-state stigmergy as a lightweight formal framework for analyzing how autonomous agents coordinate through shared blockchain state, grounding the concept in Grassé’s 1959 mechanism [1] and Heylighen’s general framework [6]. The four classical stigmergy components map onto ledger primitives, and from that mapping we identified an applied catalogue of three recurring base patterns—State-Flag, Event-Signal, and Threshold-Trigger—together with a Commit-Reveal sequencing overlay. The State-Flag task-board example highlights the paper’s central claim: trust-minimized coordination buys autonomy and protocol-level legibility at the price of extra contention, extra state-management logic, and reduced coordination efficiency relative to stronger off-chain coordination mechanisms. Several things remain to be done. We have not yet tested these patterns in a simulator or on a live network, where block timing, gas-price volatility, builder incentives, and adversarial adaptation would all matter. Cross-protocol stigmergy, where a trace in one contract triggers action in another, is a natural next step; the medium-agnostic product composition of [36] provides an abstract basis, and DeFi composability offers a ready testing ground. Formal verification of the patterns using established tools [31] would add confidence. And the growing population of AI-powered on-chain agents will likely produce stigmergic dynamics that are more complex, and more consequential, than what we see today. ## References - [1] P.-P. Grassé, “La reconstruction du nid et les coordinations interindividuelles chez Bellicositermes natalensis et Cubitermes sp. La théorie de la stigmergie,” Insectes Sociaux, vol. 6, no. 1, pp. 41–80, 1959. doi: 10.1007/BF02223791 - [2] G. Theraulaz and E. Bonabeau, “A brief history of stigmergy,” Artificial Life, vol. 5, no. 2, pp. 97–116, 1999. doi: 10.1162/106454699568700 - [3] M. Dorigo, V. Maniezzo, and A. Colorni, “Ant system: Optimization by a colony of cooperating agents,” IEEE Trans. Syst., Man, Cybern.—Part B, vol. 26, no. 1, pp. 29–41, 1996. doi: 10.1109/3477.484436 - [4] E. Bonabeau, M. Dorigo, and G. Theraulaz, Swarm Intelligence: From Natural to Artificial Systems. Oxford Univ. Press, 1999. doi: 10.1093/oso/9780195131581.001.0001 - [5] M. Dorigo and T. Stützle, Ant Colony Optimization. Cambridge, MA: MIT Press, 2004. - [6] F. Heylighen, “Stigmergy as a universal coordination mechanism I: Definition and components,” Cognitive Systems Research, vol. 38, pp. 4–13, 2016. doi: 10.1016/j.cogsys.2015.12.002 - [7] F. Heylighen, “Stigmergy as a universal coordination mechanism II: Varieties and evolution,” Cognitive Systems Research, vol. 38, pp. 50–59, 2016. doi: 10.1016/j.cogsys.2015.12.007 - [8] H. V. D. Parunak, S. A. Brueckner, and J. Sauter, “Digital pheromones for coordination of unmanned vehicles,” in Environments for Multi-Agent Systems (E4MAS 2004), LNCS 3374. Springer, 2005, pp. 246–263. doi: 10.1007/978-3-540-32259-7_13 - [9] F. Bolici, J. Howison, and K. Crowston, “Stigmergic coordination in FLOSS development teams: Integrating explicit and implicit mechanisms,” Cognitive Systems Research, vol. 38, pp. 14–22, 2016. doi: 10.1016/j.cogsys.2015.12.003 - [10] M. Elliott, “Stigmergic collaboration: The evolution of group work,” M/C Journal, vol. 9, no. 2, 2006. - [11] D. Gelernter, “Generative communication in Linda,” ACM Trans. Program. Lang. Syst., vol. 7, no. 1, pp. 80–112, 1985. doi: 10.1145/2363.2433 - [12] D. Gelernter and N. Carriero, “Coordination languages and their significance,” Commun. ACM, vol. 35, no. 2, pp. 97–107, 1992. doi: 10.1145/129630.129635 - [13] T. W. Malone and K. Crowston, “The interdisciplinary study of coordination,” ACM Comput. Surv., vol. 26, no. 1, pp. 87–119, 1994. doi: 10.1145/174666.174668 - [14] D. Weyns, A. Omicini, and J. Odell, “Environment as a first class abstraction in multiagent systems,” Autonomous Agents and Multi-Agent Systems, vol. 14, no. 1, pp. 5–30, 2007. doi: 10.1007/s10458-006-0012-0 - [15] A. Omicini, A. Ricci, M. Viroli, C. Castelfranchi, and L. Tummolini, “Coordination artifacts: Environment-based coordination for intelligent agents,” in Proc. AAMAS 2004, vol. 1, pp. 286–293. - [16] S. Nakamoto, “Bitcoin: A peer-to-peer electronic cash system,” 2008. [Online]. Available: https://bitcoin.org/bitcoin.pdf - [17] V. Buterin, “Ethereum: A next-generation smart contract and decentralized application platform,” Ethereum Whitepaper, 2014. [Online]. Available: https://ethereum.org/en/whitepaper/ - [18] G. Wood, “Ethereum: A secure decentralised generalised transaction ledger,” Ethereum Yellow Paper, 2014. [Online]. Available: https://ethereum.github.io/yellowpaper/paper.pdf - [19] N. Szabo, “Formalizing and securing relationships on public networks,” First Monday, vol. 2, no. 9, 1997. doi: 10.5210/fm.v2i9.548 - [20] S. Hassan and P. De Filippi, “Decentralized autonomous organization,” Internet Policy Review, vol. 10, no. 2, 2021. doi: 10.14763/2021.2.1556 - [21] F. Lumineau, W. Wang, and O. Schilke, “Blockchain governance—A new way of organizing collaborations?” Organization Science, vol. 32, no. 2, pp. 500–521, 2021. doi: 10.1287/orsc.2020.1379 - [22] Ö. Gürcan, “Proof of work is a stigmergic consensus algorithm: Unlocking its potential,” IEEE Robot. Autom. Mag., vol. 29, no. 2, pp. 21–32, 2022. doi: 10.1109/MRA.2022.3165183 - [23] Ö. Gürcan, “Proof-of-work as a stigmergic consensus algorithm,” in Proc. AAMAS 2022, pp. 1613–1615 (Extended Abstract). - [24] S. Capaccioli, “Blockchain, bitcoin and stigmergy: An explanation and a new perspective for regulation,” SSRN Working Paper, 2020. [Online]. Available: https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3645044 - [25] T. Dounas, D. Lombardi, and W. Jabi, “Collective digital factories for buildings: Stigmergic collaboration through cryptoeconomics,” in Blockchain for Construction. Singapore: Springer, 2022, pp. 207–228. doi: 10.1007/978-981-19-3759-0_11 - [26] P. Daian, S. Goldfeder, T. Kell, Y. Li, X. Zhao, I. Bentov, L. Breidenbach, and A. Juels, “Flash boys 2.0: Frontrunning in decentralized exchanges, miner extractable value, and consensus instability,” in 2020 IEEE Symp. Security and Privacy (S&P), pp. 910–927. doi: 10.1109/SP40000.2020.00040 - [27] M. Kelkar, F. Zhang, S. Goldfeder, and A. Juels, “Order-fairness for Byzantine consensus,” in CRYPTO 2020, LNCS 12172. Springer, 2020, pp. 451–480. doi: 10.1007/978-3-030-56877-1_16 - [28] L. Luu, D.-H. Chu, H. Olickel, P. Saxena, and A. Hobor, “Making smart contracts smarter,” in Proc. ACM CCS ’16, 2016, pp. 254–269. doi: 10.1145/2976749.2978309 - [29] M. Castro and B. Liskov, “Practical Byzantine fault tolerance and proactive recovery,” ACM Trans. Comput. Syst., vol. 20, no. 4, pp. 398–461, 2002. doi: 10.1145/571637.571640 - [30] J. A. Garay, A. Kiayias, and N. Leonardos, “The Bitcoin backbone protocol: Analysis and applications,” in EUROCRYPT 2015, LNCS 9057. Springer, 2015, pp. 281–310. doi: 10.1007/978-3-662-46803-6_10 - [31] P. Tolmach, Y. Li, S.-W. Lin, Y. Liu, and Z. Li, “A survey of smart contract formal specification and verification,” ACM Comput. Surv., vol. 54, no. 7, Art. 148, 2022. doi: 10.1145/3464421 - [32] X. Zheng, J. Xu, and G. Peng, “Stigmergy in Wikipedia,” Journal of Management Information Systems, vol. 40, no. 3, 2023. doi: 10.1080/07421222.2023.2229119 - [33] L. W. Cong and Z. He, “Blockchain disruption and smart contracts,” Review of Financial Studies, vol. 32, no. 5, pp. 1754–1797, 2019. doi: 10.1093/rfs/hhz007 - [34] A. Pacheco, V. Strobel, and M. Dorigo, “A blockchain-controlled physical robot swarm communicating via an ad-hoc network,” in Swarm Intelligence: 12th International Conference, ANTS 2020, LNCS 12421. Springer, 2020, pp. 3–15. doi: 10.1007/978-3-030-60376-2_1 - [35] A. Pacheco, V. Strobel, and M. Dorigo, “Real-time coordination of a foraging robot swarm using blockchain smart contracts,” in Swarm Intelligence: 13th International Conference, ANTS 2022, LNCS 13491. Springer, 2022, pp. 196–208. doi: 10.1007/978-3-031-20176-9_16 - [36] F. Paredes García, “Axiomatic shared-medium coordination for stigmergic systems,” Zenodo Preprint, 2026. doi: 10.5281/zenodo.19199497 - [37] A. Canidio and V. Danos, “Commitment against front-running attacks,” Management Science, vol. 70, no. 7, pp. 4429–4440, 2024. doi: 10.1287/mnsc.2023.01239 - [38] A. Capponi, R. Jia, and K. Y. Wang, “Maximal extractable value and allocative inefficiencies in public blockchains,” J. Financ. Econ., vol. 172, Art. 104132, 2025. doi: 10.1016/j.jfineco.2025.104132 - [39] B. Öz, D. Sui, T. Thiery, and F. Matthes, “Who wins Ethereum block building auctions and why?” in 6th Conference on Advances in Financial Technologies (AFT 2024), LIPIcs 316. Dagstuhl, 2024, Art. 22. doi: 10.4230/LIPIcs.AFT.2024.22 - [40] L. Van Calck et al., “A blockchain-based information market to incentivise cooperation in swarms of self-interested robots,” Scientific Reports, vol. 13, Art. 18028, 2023. doi: 10.1038/s41598-023-46238-1 - [41] J. P. Queralta et al., “Blockchain and emerging distributed ledger technologies for decentralized multi-robot systems: A survey,” Current Robotics Reports, vol. 4, pp. 43–54, 2023. doi: 10.1007/s43154-023-00101-3 - [42] Y. Liu et al., “Secure and efficient stigmergy-empowered blockchain framework for heterogeneous collaborative services in the Internet of Vehicles,” IEEE Communications Magazine, vol. 61, no. 9, pp. 186–192, 2023. doi: 10.1109/MCOM.008.2200542