Cork: A Market for Any Risk

Money and assets are being rebuilt on programmable rails. Tokenization gave real-world assets a new medium for price discovery, transfer, and product creation with opportunities that couldn’t exist in traditional financial systems.

The risk that comes with holding those assets has evolved just as fast. Early onchain risk simply meant a stablecoin losing its peg. Today it spans restaking and liquid staking exposure, tokenized fund redemption queues, bridge and cross-chain settlement risk, and liquidation cascades triggered by machines trading faster than any human can intervene.

The asset side of onchain finance has diversified quickly in a few years. The risk side hasn't had an equivalent breakthrough since there's still no general way to price it, transfer it, or trade it.

Cork is that general way.

How Onchain Risk Has Evolved

The first wave of onchain risk was narrow and legible. A smart contract could be exploited or a stablecoin could lose its peg. These were binary, observable events with a clear before and after, and the tools built to handle them (audits, insurance funds, static reserve buffers) were built for exactly that shape of problem. The asset side of onchain finance didn't stay that simple, however.

Onchain risk has evolved and grown in complexity:

• Liquid staking and restaking created exposure that moves with validator behavior and slashing conditions instead of a single peg.
• Tokenized funds and RWAs introduced redemption timelines and NAV mechanics borrowed from traditional finance, layered on top of infrastructure that wasn't built to enforce them.
• Leveraged and looped strategies turned ordinary collateral into positions where a small price move can cascade into a liquidation event across several protocols at once.
• Bridges and cross-chain settlement added a new failure mode entirely: risk that lives in the gap between two systems rather than inside either one.

Each of these presents a genuinely new kind of exposure, not a variation on the exploits and depegs the first generation of tooling was built for. But even though every new asset type got its own bespoke fix, a liquidity buffer here, an insurance fund there, an audited hook somewhere else, there still hasn't been a general solution to pricing and transferring risk.

That's the gap Cork is built to close.

Turning Risk into an Asset

Every financial system needs a way to price risk and pass it to whoever is willing to hold it. Traditional markets do this constantly, through insurance, structured credit, and instruments that turn uncertainty into something you can buy, sell, or hedge. Onchain finance needs its own programmatic equivalent.

Cork's core capability is a two-sided marketplace where anyone holding a risk can find someone willing to price and underwrite it, programmatically and out in the open, without any intermediation. Every other detail (which risks get covered, how the payout triggers, who the counterparties are) is configurable on top of that marketplace. There’s no need to create a different product each time.

Here's how Cork works in practice:

1. Create the market: The party holding an exposure and the capital willing to underwrite it meet in a Cork Pool, and the premium is set in the open.
2. Tokenize the position: Each side of that trade becomes its own fully collateralized, transferable instrument. The coverage side is a Cork Swap Token (cST); the underwriting side is a Cork Principal Token (cPT).
3. Build capital markets: Those instruments become raw material for other financial products. cST and cPT support primary issuance, securitization, and a secondary market where positions trade freely, the same way any other onchain asset does.

Once you have a market where both the supply side and demand side are represented as tokens like cST and cPT, you’ve effectively tokenized risk. That turns risk from something you simply hold or hope to avoid into an asset you can price, transfer, and trade.

The result is a new kind of capital formation layer that helps an issuer launch a product or a curator or vault manager raise capital against a risk they'd otherwise have to carry alone. It also helps the capital willing to underwrite that risk get a differentiated, transferable position that can be composed into other products entirely.

Cork is the missing infrastructure, built for any risk market, that can actually scale.

A Market for Any Observable Risk

Cork proved this out in stages. Depegs were the first use case to apply risk tokenization to a binary, observable, high-stakes event with an obvious buyer and seller for the risk. Once that market worked, the same primitive extended to redemption liquidity, then to protected loops, and more recently to bridge and cross-chain settlement risk.

A few of the risks Cork already covers are:

• Depegs: Stablecoins, LSTs, and other pegged assets can lose their peg with no guaranteed way out. Cork markets give holders a redemption at a known strike, pre-funded and exercisable the moment it's needed.
• Redemption liquidity: Vaults and tokenized funds often sit behind withdrawal queues and notice periods. Cork lets holders exit into liquid collateral at NAV, on demand, instead of waiting out a queue.
• Protected loops: Looping illiquid collateral creates a liquidation trap — the exit disappears exactly when it's needed. Cork embeds protection directly into the loop, so the position unwinds at a known price instead of cascading.
• Bridges and cross-chain settlement: Assets moving between chains carry risk that lives in the gap between two systems, where a bridge exploit or a stalled message can leave a holder with a wrapped asset and no path back. Cork gives holders a way to redeem against that exposure directly, instead of waiting on a bridge operator to make them whole.

Each one of these use cases was built on the same foundation. The architecture behind Cork doesn't change from one market to the next. The same contract structure that prices a stablecoin depeg can price a vault's redemption liquidity, a looped position's liquidation risk, or eventually, an insurance claim. The only thing that changes is the oracle.

The same logic can even extend outward from DeFi and into traditional insurance, where a carrier's underwriting risk can be tokenized into participations that institutional allocators can hold, trade, and diligence by reading a ledger. This has the potential to open up a fragmented reinsurance market that’s currently prohibitive to alternative capital.

If a risk is observable, Cork can build a market for it.

Setting the Stage for Agentic Finance

Machines are becoming the primary operators of financial markets with more than 250,000 AI agents already operating onchain daily. The majority of crypto trading volume is already machine-driven.

While every layer of onchain finance has been rebuilt for agents (identity, wallets, payments, execution), risk hasn't. Agents can create, amplify, and transfer risk today, but they have no native way to manage it. Their only response to a risk event is to exit, all at once, creating their own machine-speed amplification of a liquidation cascade.

Cork’s risk infrastructure is built agent-native and makes it easy for them to handle risk on their own. Every pool is managed through a single contract at a deterministic address and pool operations are callable smart contract functions with no frontend required. cST and cPT are standard ERC-20s an agent can interact with programmatically.

Right now, Cork is the only risk primitive an agent can actually call. This matters more with each year, as DeFi's agent activity compounds and RWAs bring a much larger and more complex asset base onchain.

Why Now?

This isn't the first time risk infrastructure has had to catch up to a new kind of asset. Genoese marine insurance made long-distance trade financeable, and helped fund the Age of Exploration. Actuarial science and probability theory made long-duration institutional commitments mathematically credible, and made modern pension systems possible. Black-Scholes made derivatives priceable at scale, and gave corporations a discipline for hedging that didn't exist before.

Tokenization is a similar crossroads moment where assets are becoming programmable, composable, and borderless. They’re nothing that prior risk infrastructure, built for human counterparties and days-long settlement, was designed to serve well.

Cork is the infrastructure that rises up to the moment by turning risk into a tokenized, programmable asset itself. It’s collateral that's verifiable in a contract, trigger conditions defined in code, settlement that happens atomically. It’s a redefinition of risk.

Turn your risk into an asset. Tell us what you're exposed to and we'll show you the market for it.