Technology

ARCO: the compute loop

ARCO is the market-optimization loop at the heart of Lineage, cycling through five stages (sensor, relay, compute, actuator, event) each cycle. Over successive cycles a market moves from an inefficient initial state toward a more efficient one, while consensus secures the integrity of that adaptive evolution.

Read the docs Whitepaper

ARCO advances through a fixed sequence of stages. Each stage consumes the output of the previous one and writes to the shared ledger, so market state evolves predictably across cycles rather than executing fixed rules.

Read & intent
Sensor
Devices read soil and market conditions, infer an optimal action with an on-device model, and build a signed P2PKH transaction with MCP agent context.
Match & settle
Relay
The relay stage matches buyer orders against seller offers and constructs a two-way payment binding the priced token to the asset item.
Verify & build
Compute
Mempool, mining, and storage nodes verify transactions, build the nested Merkle root, search proof of work, and append the block.
Commit & settle
Actuator
A hash commitment placed off-chain triggers physical actuation only when the signature, preimage, and on-chain inclusion all verify.
Evolve & broadcast
Event
Ledger transactions feed a genetic search over market policy. The best candidate policy is broadcast back to participants, closing the loop.
The loop repeats each cycle. The broadcast policy reshapes the next round of sensor readings, and the market moves toward equilibrium.

Payments and contracts run on many platforms. A smart market asks for more: it evolves continuously with external conditions and reaches consensus among every participant, so it can never be captured by fixed code. Five architectural choices, present from layer-1 up, are what make adaptive markets possible here.

Complete transaction records

A transaction-based (UTXO) ledger preserves the full transaction, every order and settlement, not just net debits and credits. That complete economic record is the raw material on-chain market analysis runs on.

Intelligence at layer-1

GPU proof-of-work does double duty: it secures the chain and supplies the compute for analytics. A dedicated op-ai-evaluate opcode runs AI evaluation directly over transaction data, inside consensus.

Real-world data, no oracles

IoT readings, climate data and other external signals enter the ledger as first-class blockchain items, validated at layer-1 by the mining network itself, so market functions never inherit an external oracle’s trust assumptions.

Security at the consensus layer

Market logic and data live at layer-1, secured by the entire mining network. There is no separate application layer to compromise; subverting a market would mean overpowering the whole network, not a handful of nodes.

Markets that adapt

Prices are discovered by consensus among all participants and move with conditions, so a market responds to unforeseen events: tariffs, shocks, supply disruptions. It does not freeze. Compute scales with value: more valuable markets attract more miners.

Traditional blockchains execute fixed rules. UTMMs allow market policy itself to evolve. Instead of hard-coding mechanisms, the network performs bounded search over policy space and verifies results cryptographically.

Feature Extraction

Transaction history becomes an epistemic substrate. Deterministic operators extract signals from market activity.

Adaptive Policy Search

Genetic algorithms and bounded optimisation explore policy space. Better market policies survive through deterministic evaluation.

Verifiable Intelligence

Zero-knowledge verification proves policy evaluation correctness without rerunning computation.

Event stage · pseudocode

Policy as an evolving program

At the Event stage, ledger transactions are discovered into a transaction set, compiled into a finite-state machine, and improved through fitness-guided evolution. The optimized policy is then broadcast to participants.

// ARCO Event Optimization

const soil_tx   = loadLedgerSoilTransactions();
const market_tx = loadLedgerMarketTransactions();

const T    = discoverTransactionSet(soil_tx, market_tx);
const FSM0 = buildFSMfromTransactions(T);

function fitness(FSM) {
  const r = simulateSeason(FSM);
  return weightedSUM(
    r.meanYield(),
    r.meanProfit(),
    -r.priceShockVariance()
  );
}

let POP = initPopulation();
while (!converged) {
  POP = evolvePopulation(POP, fitness);
}

const FSM_opt = bestCandidate(POP);
broadcastToFarmers(FSM_opt.policy());

Prime Radiant Consensus is Lineage’s consensus mechanism, technically Dynamic Proof of Weighted Work (DPoWW), an evolution of ecoPoW. It secures not only transaction ordering but the integrity of adaptive market evolution, shifting between fully distributed and semi-decentralized modes for throughput and reverting to full distribution when fault conditions require it. Miners produce blocks while also participating in economic evolution. Read the DPoWW paper

GPU-Native Mining

SandWorm Hash incentivizes GPU hardware. GPUs compute ML, VAR, and genetic-algorithm workloads.

Deterministic Time

Blocks map directly to UTC time, enabling predictable evaluation windows and synchronised policy updates.

Blockchain Service Providers

Architected for commercial performance and integration. API routes into the Layer-1 bring agents directly on-chain.

Watch the overview on YouTube

Mempool, storage, and miner nodes run the Layer-1 itself. The loop’s Compute stage executes across these subsystems, each running on its own host with its own HTTP API for transactions, ledger reads, and mining coordination.

Subsystem	Responsibility	API origin
Mempool	Verifies inbound transactions and builds the nested Merkle root for the next block.	https://mempool.lineage.to
Storage	Verifies UNiCORN linkage, applies UTXO changes, and appends the block to the ledger.	https://storage.lineage.to
Miner	Builds the coinbase transaction and searches proof of work over the miner root.	https://miner.lineage.to

Explore the node APIs

Markets Discover Knowledge

Markets aggregate dispersed information. UTMMs formalise that discovery process inside consensus.

Policy Becomes Programmable

Instead of static rules, institutions evolve through verifiable selection pressure.

Economic Intelligence Compounds

Better policies persist; bad policies disappear. The system improves continuously.

—

Block-to-UTC mapping

—

Policy evaluation window

—

ARCO cycles to converge

—

SandWorm Hash difficulty

The documentation covers the node APIs, transaction formats, and consensus rules. The whitepaper sets out the formal model behind Universal Turing Market Machines.

Read the docs Whitepaper

ARCO: the compute loop

Five stages, one deterministic cycle

Read & intent

Match & settle

Verify & build

Commit & settle

Evolve & broadcast

Built for markets, not just transactions