TL;DR

• L2s solved throughput but fragmented synchronous composability; stopgaps (bridges, intents, shared sequencers) improve some properties but still fall short of general, atomic cross‑rollup execution.

• Research across distributed systems and cross‑chain protocols converges on two‑phase commit (2PC) variants for atomic multi‑domain actions. Compose applies this idea to rollups coordinated PREPARE → COMMIT with proofs aggregated and anchored on Ethereum.

• Making Ethereum validators the neutral coordinators (“composers”) aligns incentives with the base layer and avoids replacing rollup sequencers, unlike shared sequencer networks that require L2 integration and new trust surfaces.

The fragmentation problem, evidence and context

Rollups scale execution, but cross‑rollup actions (swaps, liquidations, auctions, game moves) still degrade into multi‑step, non‑atomic flows. That’s why users juggle bridges and relays, and why “half‑done” states (one leg landed, the other didn’t) are common failure modes. Bridge incidents underline the structural risk of asynchronous systems: the Wormhole exploit (~$320M) and Nomad (~$190M) each hinged on message/verification errors, not L1 consensus failures.

Optimistic rollups now ship “Stage 1” fault proofs, but withdrawals still rely on challenge windows; zk‑rollups give faster exits yet don’t by themselves re‑create cross‑rollup atomicity. The gap is coordination, not just proof style.

What’s on the table today (and where it falls short)

Shared Sequencer Networks (SSNs). Projects like Espresso and Astria provide shared ordering, preconfirmations, and optionally DA. They reduce latency/censorship risk and help interop, but require L2 integration (modifying sequencers/stack). Preconfirmations are promises, useful UX, not final atomicity. And a separate network becomes a new locus for governance and economics.

“Aggregation” frameworks (e.g., Polygon AggLayer). Directionally unifying liquidity and proofs with “pessimistic proofs” that assume other chains are untrusted is smart defense, but it’s still not a general mechanism to run arbitrary, multi‑rollup application logic atomically in one go.

Intent systems (UniswapX, Across). Intents push UX forward by letting solvers do the legwork, but settlement is economic/optimistic: great for many use cases, not a substitute for cryptographic atomicity of arbitrary cross‑rollup call graphs. (Even their own docs emphasize RFQ/solver markets rather than strict 2PC‑style commits.)

IBC-style channels. Cosmos’ IBC provides robust packet semantics, ICS‑20 transfers, and interchain accounts; recent work explores “Atomic IBC” and megablocks. Powerful but it lives in the Cosmos design space and still requires common channel standards and dedicated relayers.

Takeaway: these efforts improve pieces of the picture ordering, liquidity, portability but none, as deployed today, guarantees general atomic execution of multi‑rollup transactions without asking rollups to replace their sequencers or users to accept soft promises.

What research says about cross‑domain atomicity

Across distributed systems and cross‑chain literature, atomic commit (often 2PC) recurs as the simplest sound abstraction: either all sub‑transactions commit or none do. Newer protocols (e.g., CRATE, 2025) target cross‑rollup atomic transaction execution explicitly, proving all‑or‑nothing semantics and practicality in gas costs. Enterprise and academic work alike emphasize PREPARE/COMMIT phases, with proofs/fallbacks to ensure safety under failures.

That’s exactly the mental model Ethereum devs already know from databases and cross‑ shared systems, and it’s what users actually feel as “one click” → “one outcome.”

Why validators should coordinate the commit (not a new sequencer)

Ethereum researchers argue that based alignment with L1 validators maximizes liveness, decentralization, and neutrality for L2s. Instead of moving sequencing to a separate committee, keep rollups sovereign but let validators act as the neutral coordination surface. This avoids importing a new governance/economic center while pushing value and trust back to Ethereum.

Shared‑sequencer designs often add a separate BFT layer (and integration cost); preconfirmations are helpful but not final. By contrast, a validator‑aligned coordinator can collect proofs, enforce PREPARE/COMMIT across rollups, and post one aggregated result to L1, turning a set of L2 actions into one L1‑anchored outcome.

Compose’s Shared Publisher: validators as composers

Compose implements this validator‑aligned design as a Shared Publisher (SP):

• Sovereignty preserved. Rollups keep their own sequencers and fee markets; no need to join an SSN to gain sync UX.

• 2PC‑style coordination. Cross‑rollup bundles go through PREPARE → COMMIT; if any leg fails, all revert, no half‑states.

• Aggregated proofs to Ethereum. SP aggregates rollup proofs and publishes a single result to L1 for fast, unambiguous finality of the whole bundle.

• ETH‑aligned neutrality. Because SP is validator‑aligned, censorship resistance and revenue route toward Ethereum’s root of trust rather than a new off‑chain committee.

This is not a shared sequencer. It’s a validator‑backed commit layer that restores atomic composability across sovereign rollups. Precisely the property the ecosystem lost when moving to a multi‑rollup world.

How this compares

Operator economics: why validators care

Validators already monetize specialized services (PBS/MEV‑Boost today; AVSs via restaking tomorrow). A commit‑layer for cross‑rollup atomicity is a similarly natural service: collect/verify inputs from L2s, run the commit state machine, aggregate proofs, and publish an L1 result earning interop fees/tips. The trendline (validators adding off‑chain services with on‑chain accountability) is well established in EigenLayer’s AVS model.

Unlike SSNs that siphon ordering revenue to an external layer, SP routes value and neutrality back to Ethereum’s validator set. For operators, this is additive to staking rewards and compatible with existing MEV/PBS workflows.

What users & apps will actually feel

• No half‑states. Either the multi‑rollup operation lands everywhere or nowhere. (Prevents stranded approvals, partial liquidations.)

• Clear finality. One L1‑anchored result replaces days‑long coordination windows typical of optimistic exits; zk exits are fast, but not a cross‑rollup atomicity primitive by themselves.

• Sovereign rollups, unified UX. OP Stack, Arbitrum, Base, Scroll, etc. can join atomic bundles without surrendering sequencer control.

Safety posture under failures

• Leg failure in PREPARE → abort bundle; no partial commits.

• Publisher liveness hiccup → rollups keep producing blocks; bundles wait; safety unaffected.

• Missing data/proofs → SP refuses COMMIT; revert over partial state (safer than “optimistic” proceeds).
  These behaviors mirror the 2PC safety goal (never commit a subset), now anchored by an L1 publication rather than a soft preconfirmation.

Let’s put Ethereum’s validators at the center of composability

Research says atomic commit; ops reality says ship with existing sequencers, not instead of them; alignment says use validators, not a new committee. Compose’s Shared Publisher is the only approach that checks all three boxes at once: atomicity, sovereignty, ETH‑aligned neutrality, and that’s why validators should be composers, not just proposers.