Agglayer v0.3 Is Live: Lays Groundwork for non-CDK Chains to Securely join Agglayer, Starting with Polygon PoS

tl;dr

• Agglayer v0.3 is live, expanding the pessimistic proof with a new execution proof mode that allows chains to prove their own state
• Polygon PoS to connect to Agglayer by end of Q3, with other major chains coming soon after
• Agglayer is becoming chain-agnostic, so chains can connect regardless of underlying architecture
• Security upgrade to the pessimistic proof adds an additional safety guarantee that provides trust that a chain has settled
• Katana will be the first chain to use the new execution-proof mode, going live soon with a validity proof for CDK OP Stack chains. 
• Crucial step toward fast interop: v0.3 enables Agglayer to safely support sub-10s cross-chain transactions with enhanced security

The next Agglayer release is live, marking a major protocol upgrade that lays the groundwork for chain-agnostic interoperability. 

At the core of this release is an upgrade to the pessimistic proof, the security mechanism that ensures safe, trustless cross-chain transactions. Now, Agglayer connected chains can prove their own state to one another, even if they don’t share the same architecture.

In plain words: the pessimistic proof just got better. Previously, the pessimistic proof only verified transactions in and out of a chain, but not how each chain kept track of its state. 

With v0.3, pessimistic proof now accepts state-specific ZK proofs to confirm a chain’s transactions were executed correctly, according to its own rules. No changes to a chain’s underlying architecture required.

This is like 2FA for interop: chains now can verify their funds and their internal state before transacting.

In practice, this means more kinds of chains will join Agglayer, without changing a thing: Polygon Proof-of-Stake (PoS) network by end of Q3.

View the transaction for the upgrade here.

A flexible framework for any chain to join

To begin, this feature will be available to Agglayer CDK OP Stack chains, like Katana. Build with the familiarity of OP Stack, but the security and fast-finality of ZK. 

By year’s end, the new mode for pessimistic proof will extend to other chain types, too: Connecting Polygon to Agglayer in a fully trustless way, without requiring changes to Polygon’s underlying architecture. 

Polygon will be able to join as is, and prove state with a ZK proof of consensus. 

Other major chains—both EVM and non-EVM—will follow suit, each connecting via the expanded pessimistic proof, using the same modular design. 

First Polygon. Then…anything else. 

As each chain adds its own circuit, Agglayer expands horizontally. For Agglayer to truly aggregate everything, core infra needs to be flexible and modular enough to be chain agnostic. Agglayer needs to provide the conditions required for safe, fast interop (sub 10 seconds, to start). 

Agglayer v0.3 is that first step.

What’s changing in the pessimistic proof?

The pessimistic proof has always served as Agglayer’s security backbone. It guarantees that no chain can withdraw more from Agglayer’s unified bridge than has been deposited. In essence, Agglayer takes a pessimistic view of aggregated chains. It uses the power of ZK to ensure no single chain can rug any other. 

But until now, the pessimistic proof only confirmed chain balances, not behavior. It could prevent chains from rugging one another on the unified bridge, but couldn’t provide security for users of any specific chain. With v0.3, that changes.

As Agglayer expands to support fast interop (i.e. sub 10-second cross-chain transactions) and more diverse chain architectures, the pessimistic proof needs another safety check: Has the sending chain actually finalized its state? 

That’s where the expanded mode for ZK execution proofs comes in.

Expanding the pessimistic proof unlocks something Agglayer couldn’t do before: modular, chain-agnostic interop. Polygon’s architecture, for example, doesn’t use the same default bridge used by Agglayer CDK chains. But with a custom execution proof, it can now join Agglayer.

The protocol logic built for an expanded pessimistic proof is modular, meaning it provides a reusable framework to add new circuits for new chains. Chains can plug in according to their own finality mechanisms, and Agglayer doesn’t need to upgrade core logic to support them. 

So this upgrade doesn’t replace the pessimistic proof, but simply expands it. The new mode provides a deeper, more composable form of trustlessness. And it sets the stage for fast, secure interop between fundamentally different chains.

Fast interop, future proof

With an expanded pessimistic proof, Agglayer chains can begin to interoperate faster and with higher safety—approaching sub-10s latency even between dissimilar chains. 

And because each proof is modular, the system stays open to future additions—EVM or not.

Existing solutions like bridges, intents, and solvers focus on routing, but they don’t verify state. They route assets and transactions, but rely on external actors, off-chain coordination, or ad hoc assumptions about finality. And rollup clusters require chains to conform to specific stacks, governance processes, or upgrade rules—none of which scale in a world of millions of sovereign chains.

Agglayer doesn’t ask chains to conform. With v0.3, it meets them where they are, providing a secure, verifiable path for trustless interop between systems that were never designed to work together.

This upgrade lays the groundwork for Agglayer to be a fully chain-agnostic interop solution. When Katana’s public mainnet goes live later this month, Agglayer will officially be multistack; with v0.3, the target becomes a multichain Agglayer

What’s next?

• Execution proofs for CDK OP Stack: Now live with Katana, in private mainnet
• Proof of consensus for Polygon: Coming by end of Q3
• Expanded support for heterogeneous chains: Built into the modular design
• Fast interop: Sub-10s, trustless transactions between diverse chains

Agglayer’s v0.3 evolves the pessimistic proof in order to bring more chains, more safety, and more speed into the Agglayer network.

Agglayer is building what TCP/IP did for networks: a common, flexible protocol layer that lets independent systems talk to each other, instantly and securely.

Chain-agnostic by design. Trustless by default. Get aggregated. 

To learn more about Agglayer v0.3, check out the documentation.