Signet is a synchronous rollup that extends Ethereum. Same block, same state, same finality. Optimistic Thinking covered the protocol architecture — why we built it, how correctness works, what we traded away. This piece is the application argument.
Developer Experience
Not because we built better development tools — though we did. Because we removed the constraints that made building hard in the first place.
You’re not working around a proving system or designing for withdrawal windows. When you want the chain to do something new for your application, you don’t have to rebuild a fraud prover first. You get Orders, Fills, and atomic cross-chain execution — in the same Ethereum block.
The tooling is everything you know and love. Same EVM, same contracts. The model has a few new pieces — conditional execution, cross-chain atomicity — and those are the parts worth learning. They’re also the parts no other rollup can offer you.
Programmatic Actors
Signet’s architecture favors programmatic actors — bots, keepers, agents, any software that needs to reason about on-chain state and act on it.
The properties that matter for automated actors are the same ones Optimistic Thinking argued for: explicit events, deterministic execution, and atomic cross-chain settlement. An automated system can check did this Fill event happen? and branch on that. It can’t reliably reason about a 7-day challenge window or probabilistic finality.
The TypeScript SDK lets programmatic actors build full flows — L1 to L2, L2 to L1, multi-step coordination — from a single interface, against the same event-driven guarantees the protocol provides to everyone else. No special agent infrastructure. No separate API. Events and atomicity are exactly what orchestration requires. Everything else is extra.
Building Without Permission
Every design decision above exists because Signet has no proving system. That’s not a simplification. It’s the reason we can do things for applications that other rollups can’t.
Fault proofs create a ceiling on design. On Arbitrum, customizing the state transition function means updating the fraud prover to recognize the new behavior as correct — otherwise, the prover sides with unmodified nodes and your chain loses its own dispute game. The process: modify the node, disable fraud proofs, rebuild the prover, update the WASM module root onchain, re-enable. For every change. The OP Stack has the same constraint through Cannon. If you spent three to five years building a proving system to do what rollups do out of the box, adding any nuance — any application-specific customization — sends you through a loop of redesigning, updating, and maintaining the prover. Nobody will willingly do that.
You tell us your application needs deposits to execute before liquidations on the rollup, and we make that happen. You need swaps to settle before new positions open in your options protocol — we build that into the execution engine. Staking events need to precede withdrawals from your lending market — we write it into the block building rules. The state transition function, the execution engine, the block builder set — all of it is on the table. You say jump, we say how high.
Signet isn’t off the rack.
A general-purpose rollup is a cookie cutter. Deploy smart contracts permissionlessly — that’s the value proposition, and that’s where it ends. An app chain is bespoke: purpose-built for a single application. Signet offers both and isn’t limited to one application’s business logic. General-purpose execution with application controlled customization. The STF and rollup team should be catering to the needs of the application, not the other way around.
Look at DeFi today. The protocols holding the most value — Lido, Aave, Uniswap, Maker — are staking, lending, DEXs, vaults. Protocols like Morpho are deployed across half a dozen chains, each with its own fragmented liquidity, separate incentive campaigns, and duplicate operating infrastructure. Signet’s same-block L1 access means applications can use Ethereum collateral directly — without bridging it, without fragmenting it, without running parallel operations on every chain.
We’re talking to several teams building in these spaces right now. We have an open invitation and a round table of technical founders working on lending protocols, vaults, DEXs, and financial infrastructure. If you’re building at the edge of what’s possible and the rollup you’re on isn’t keeping up — reach out. We’re in active conversations and there’s room for more.
Where This Goes
We’re a small, independent, research-driven team with a decade in Ethereum. We’ve invented same-block cross-chain actions. Built the first synchronous rollup. No token. No venture capital pressure. And we think these design decisions will be necessary for every serious application eventually. It just might not be obvious today.
These two pieces are our opening arguments. Next, we’ll share explorations on how applications scale on Signet:
- Lending: What happens when Ethereum-native collateral stays on L1 and cross-chain liquidations collapse into a single signed Order.
- Vaults: What rebalancing looks like without 2–21 day settlement windows.
- DEXs: Why cross-chain swaps don’t need bridges.
- Agents: What happens when agents own the full loop — monitoring, executing, coordinating — on an event-driven rollup.
- Derivatives: How price-contingent execution settles options only when Ethereum oracle conditions are met — in the same block.
- Why No Token: The unit economics problem, and what durable infrastructure actually looks like.
If any of this is relevant to what you’re working on, reach out. Mainnet is imminent.