In July 2025, we introduced Pelagos Network to the world. It's the execution layer for a multichain world, and it spans more than just chains: DEXs and DEX aggregators, CEXs, perps, and any combination of them. It exists to fix one problem: today, anything that reaches across more than one venue or chain is a sequence of separate, hopeful steps, and any one of them can half-complete and leave you with funds stuck on one side and nothing to show on the other. Pelagos makes that kind of action atomic: every step gets checked up front, and it either commits everywhere or aborts everywhere.

At the start of this year the same team that built Pelagos decided to build the application that would put all of that to work. That's Nabu, the flagship app on Pelagos, live in closed beta now. A small group of traders are describing strategies in plain language, testing them in simulation across a DEX and a CEX, and running them under hard policy controls.

This article isn't a product update. It's the bigger picture: the market we think Nabu opens up, the idea underneath it we call selective disclosure, and why strategy itself becomes the thing you invest in.

Let's start with the gap.

Plenty of traders have a real edge, and there's no shortage of capital that wants it. Look at what already exists: bots, vaults, structured products, copy trading, signal groups. None of it cleanly connects the two. Good execution-sensitive strategy is stuck in one of two states: private, where outside capital can't reach it, or public, where the edge gets read and copied and arbitraged out of existence the moment it starts working.

So edge either can't be funded, or can't survive being funded. That's the gap.

Vaults were the first real packaging layer in DeFi. Before them you executed everything yourself: every swap, every rebalance, every position. A vault let you allocate into a set of rules that managed assets for you. That was a genuine shift, and it's where the idea of programmable capital actually lands. You could point money at a set of rules and step back.

But look at what a vault actually packages. It packages allocation. You put money in, rules act on it, you get a share of the result. The thing being sold is access to capital deployment. The strategy underneath (the timing, the routing, the inventory logic, the reason any of it works) was never the product. It was either fully exposed in the contract, or hidden behind an operator you had to take on faith.

Trace that back and the real issue isn't vaults at all. It's what you're forced to disclose.

Put a strategy fully on-chain and you've published it. Anyone can read the logic. For anything where the edge lives in timing, execution, routing, or how you move between CEX, DEX, and perps, visibility is the same as decay. You're handing competitors the training data to copy you.

Hide it completely and you've built a black box. Now the user is back to trusting a name. "Allocate to me, I'm good, you'll see." That's the exact thing crypto was supposed to kill.

Both options lose. Reveal and the edge dies. Hide and the trust dies.

Disclosure isn't a dial you turn up or down. The real question is which parts you expose.

A strategy has two surfaces. One is the policy: which venues it can touch, its risk limits, its fees, its exit rules, what it's been validated against, how it's actually performed. The other is the alpha: the signal logic, the timing, the execution detail. The part that stops working the second someone else can see it.

Nothing says these two have to travel together. Make the policy fully public. Keep the alpha private. Now capital can judge a strategy on everything that matters for an allocation decision (risk, constraints, venue exposure, real track record) without the author setting fire to the part that makes it work.

That's selective disclosure: public policy, private edge, the thing vaults never had.

Once you can do that, the thing being sold changes. It stops being the capital, or a bot running underneath it, and becomes the strategy itself.

Here's the shape of it on Nabu. You describe a strategy in plain language, and you refine it in a back-and-forth with a model that co-authors the logic with you. It compiles into Pelagos Strategy Language (PSL), a constrained language we built for trading agents, where the compiler hands you structured feedback instead of letting a model hallucinate something that looks right and isn't. It runs through simulation before it touches real money: many variants generated, ranked on risk-adjusted return and drawdown and whether they actually hold their constraints, with the weak ones cut. The survivor gets wrapped into a vault with hard policy around it (loss caps, slippage limits, venue allowlists, a kill switch), and only then can it take outside capital, under rules everyone can see. What you end up with is a pipeline that runs from "I have an idea for a strategy" all the way to a vault other capital can actually allocate into, with a public record and a protected core.

And it can't live on one chain. The opportunity surface is the whole market: DEXs, CEXs, perps, lending, eventually RWA flow. Each venue you add brings its own spreads, funding paths, collateral routes, and inventory choices, and along with them its own custody model, its own latency, and its own trust assumptions. Cross-venue isn't an integration checklist. It needs execution architecture that treats moving between venues as the normal case, not the exception.

That's where Pelagos comes in, and I want to be precise about the claim. Most on-chain automation has too many hops between seeing a signal and acting on it. A price moves, an oracle publishes, a keeper or contract loop wakes up, then something finally executes. Every hop is delay, and every delay is slippage on the strategies that care about it. Nabu's strategies run on Pelagos, which collapses those hops: data, strategy state, and execution intent in one loop for the paths it supports, on a sub-second block target. I'm not going to wave a latency number around like a trophy, because the number isn't the part that matters. Fewer hops between seeing something and acting on it is a property of how the system is built, and that stays true whether or not we hit any particular millisecond on a given day.

If part of the logic stays private, you can't ask people to just trust the author. So you don't. You ask them to trust the validation, and you make the validation public.

This is the part that matters most if you're on the other side of the trade: not writing a strategy, but looking for one to put capital behind. On Nabu you browse vaults, and every vault shows its record up front. What the strategy passed: compile checks, simulation, variant ranking against a baseline, the constraints it held under, how it behaved live. You choose a vault by reading that, not by trusting a name.

"Validated" is not a synonym for "safe," and we won't pretend it is. It means the strategy cleared a standard you can read for yourself. The author keeps the edge, and you still get the evidence you'd want before allocating, which are not the two things in tension that people assume they are.

I'll be straight about what runs today versus what's on the path, because the difference is the whole point.

Today, in the closed beta: chat-first strategy authoring, PSL compilation with real compiler feedback, simulation across an Ethereum DEX and a centralized exchange, event-driven automation with hard policy controls, variant generation and ranking. It's narrow on purpose.

On the path: funding capture between spot and perps, responding to CEX/DEX dislocations, hedged LP exposure, inventory-aware rebalancing, cross-chain routing. These are real strategy classes, not a wishlist. But they ship as the venue coverage and execution classes land, and I'd rather show you the roadmap honestly than dress a target up as a receipt.

Put it together and you get a market that doesn't exist yet: a marketplace of protected, validated strategy products.

In that market, every participant has a clear role. Capital allocators find a vault that fits by reading its policy, risk, validation, and real execution evidence, rather than chasing whatever APY number happens to sit on a card. Authors sell access to their edge without setting it on fire to do it. Builders get an actual language to work in instead of duct-taping bot scripts together. The agents doing the execution run on a substrate that settles atomically and keeps their logic confidential. And the venues on the other side see structured, policy-bound flow instead of noise.

Vaults made capital programmable. That was step one, and it mattered. The next step is making strategy itself something you can validate, protect through selective disclosure, and allocate into. A product, with a public record and a private core. Capital gets more to choose from, authors keep what makes them good, and alpha stops being a secret you guard and becomes a thing you can actually sell.

That's what we're building toward. The closed beta is the part that's real today. The rest is the direction we're pointed. If you want to access our product please visit our website , follow the steps and kindly ask the team for an invite code.