Yesterday we opened the operator program: 50 founding traders who run their own capital on Nabu every month, post about it, and sit with the team deciding what gets built. That's a long commitment and it's built for people with an audience.

This is the other side of it. The closed beta is one week, no posting, no follower count. You get access, you use the product the way you'd actually trade, and you write up what you found. Operators tell us what Nabu should become over months. Beta testers tell us what's broken right now, before those operators and everyone after them hit it.

What you'd be doing

You get access, you get one week, and you work through the product the way you'd actually use it. Specifically:

• Onboarding: sign up, connect your wallet, get through first-run setup. Note anything confusing or broken

• Strategy creation: describe at least three strategies in natural language and let Nabu build them. One simple, one that's specific to how you actually trade

• Simulation and backtesting: run them. Do the results feel right? Does the interface tell you what you need to know?

• Live deployment: put at least one strategy live with small size. Watch it execute, check the receipts, check that the leaderboard and strategy page update

• Breaking things: bad inputs, weird strategies, disconnecting mid-execution. Anything unexpected is useful

You don't have to cover all of it. Going deep on a few flows is more useful to us than touching everything once.

What good feedback looks like

We want to read something that shows you used the product and thought about it. The strongest write-ups will have most of this:

• Specific screens or steps where you got stuck, with what you expected versus what happened

• Screenshots or short recordings where they help

• At least one full flow end to end. "I wrote a strategy that did X, it compiled, the simulation showed Y which didn't match what I expected, here's what I tried, here's what would have helped"

• How it compares to what you use today, and what Nabu does better or worse

• What you liked and what annoyed you

• At least one change that would make you move to Nabu from your current setup

Two sentences written in five minutes won't be considered.

Rewards

The three best write-ups each receive $500, paid in USDC to a wallet of your choice. Best means the feedback clearly shows the product was tested in depth and gives us something we can act on. If no submission meets that bar, no rewards are paid.

How it works

1. Apply through the form: https://docs.google.com/forms/d/17_MiS72A96LbWVcXP3q1gtrz2mDVWJcynzj9htAfw6w/

2. If selected, you receive access credentials and a submission link by email. Your week starts that day

3. Use the product. Take notes as you go, it's much easier than reconstructing it at the end

4. Submit one document plus any screenshots or recordings through the link before your seven days are up. Late submissions aren't considered

5. Winners are announced within five business days of the final deadline and contacted directly

Seats are limited and we're prioritising people who actively trade.

Nabu is a strategy-first trading platform. You describe a strategy in plain English, the AI adviser turns it into a validated trading strategy, you backtest it against real historical data, then deploy it live on Hyperliquid or Binance with its own leverage (more venues coming very soon), sizing and native TP/SL. Every fill, position and PnL number is reconciled against the venue.

We spent the last few months closing that loop, and then we did the only test that counts: we ran hundreds of strategies on our own capital through August, and rebuilt half the product around what daily use taught us. The loop works. What we want now is 50 real traders on it, shaping it with us, before we open the doors to everyone else.

So this is not an ambassador program, and it is not an ad buy with extra steps. We are choosing 50 founding traders. You run your own capital on Nabu, you post about your experience using Nabu, and you sit in a private room with the team deciding what gets built next. The people using the product hardest are the ones who should define it. You get paid for showing up while you do.

No application form. We are already in touch with traders but the door is open if you think we missed you.

The deal

What you get

• $200 a month, paid in USDC, for genuinely using Nabu

• The Elite tier free while you're in the program ($149/month once gets activated)

• One of 50 founding seats: private operator group, direct line to the team, first look at everything we ship, your name on the cohort that was here first

• Your referral code and dashboard

What we ask each month

• Genuine use of the product with at least $10K of traded volume across the month, cumulative. Not much at all since leverage counts, one round trip on $1K of margin at 5x covers it.

• A strategy live 20 of 30 days (15 in your first month). Live means deployed and armed, it doesn't need to trade every day

• 2 original posts on X, at least one showing your live strategy card

• 1 recap thread with your real monthly PnL. Red months included

• Your code in at least one post, and "paid partnership" disclosure on every sponsored post

All of it, or that month's retainer isn't released. No partial credit.

What it actually costs you

Keeping a strategy switched on costs nothing. Clearing the $10K floor costs somewhere between $3 and $8 a month in exchange fees and slippage, depending on how you trade and where. You trade your own capital at your own sizing, we never touch your funds, and there is no reward for trading more than the floor. We'd rather pay you to keep a strategy running than tempt you into churning trades.

How payment works

The month happens first, the money comes after. You complete the month, we check the deliverables, and everything you earned arrives in one USDC payment by the 5th of the next month. No minimum payout. We never pay in advance, which also means we never have a reason to take anything back. Any term change comes with 30 days' notice.

The honest part

$200 a month is below your post rate and we both know it. That's because we're not buying posts. If we wanted only eyeballs we would pay for ads or KOL packages (which we will also do in the future, nothing wrong with it). What we're actually paying you for is to use the product, be involved, and help us define what Nabu becomes and how it grows. You'd be one of fifty, in the room with the team from day one, an OG of the platform before the doors open to everyone else. The posting is just the public side of that work. Call it an hour (or max 2) of real effort a month, no lockups, leave whenever.

Also honest: seats get reviewed, and the ones that aren't working go back to the pool. No fixed schedule and no quota, and if your seat is ever at risk you'll hear it from us first.

And the hard lines: wash trading, self-referral, undisclosed paid promotion, promising returns, or presenting backtests as live results end the seat immediately.

Who we're looking for

• 3K to 40K followers on X

• Verifiable on-chain trading history. Hyperliquid leaderboard, a wallet, anything we can check

• You post positions and losses, not calls

How to start

1. DM us on X.

2. Sign the operator agreement

3. Connect your Binance or Hyperliquid account via API. Takes 5 minutes, funds stay on your exchange

4. Fund with your own capital and deploy your first strategy within 14 days. That activates your seat and your first month starts

50 seats. DMs open if you think it's you.

Base does two things for the strategies you run on Nabu. The big one is cost, execution drops to almost nothing, which is the thing we'd been waiting on. The other is reach: a much wider set of tokens and pairs you can actually trade against, which is what makes the cheap execution worth having in the first place.

Gas was the constraint

A swap on Ethereum mainnet ran us about $0.17. The same kind of swap on Base came in around $0.001. That gap is the thing that has shaped which strategies are worth running onchain at all.

The receipts:

• Ethereum mainnet, ~$0.17 gas → [here is the etherscan link]

• Base, ~$0.001 fee → [here is the basescan link]

Strategies execute often, which is what makes gas such a heavy tax, and arbitrage is where you see it most clearly. On Ethereum, a chunk of every spread is gone before you've captured it. If gas starts at $0.17 and climbs whenever the network gets busy, you need either a wide price gap or a large enough position to absorb the hit and still come out ahead. So traders end up parking more inventory than they'd like to chase margins that are thinner than they look on paper. Plenty of arbitrage logic that's perfectly sound on its own just doesn't survive contact with mainnet gas.

Base changes that arithmetic because execution costs roughly a tenth of a cent. Spreads you'd previously have to skip are worth taking. You don't have to oversize a position just to outrun the gas, and the fast, small-clip strategies that never penciled out on mainnet become workable. None of the strategy logic changes here. What changes is the cost sitting underneath it.

And it opens up the token side

Cheap execution doesn't help much if there's nothing to trade against, which is the other half of why Base matters. The Base ecosystem has its own set of tokens that simply weren't reachable before, and on Uniswap v4 a lot of them trade in direct pairs rather than forcing you to route through an intermediate asset. Direct pairs mean fewer hops, less slippage, and cleaner execution on the pairs your strategies actually care about.

At launch, coverage spans the tokens with real depth on Uniswap v4 on Base, roughly the set trading above $50k in volume, so there's a genuine market to work with from day one rather than a thin long tail.

Using it

The workflow is the one you already know:

1. Connect your Privy wallet.

2. In settings, pick Base as your chain.

3. Back on the homepage, build your strategy as usual.

Strategy logic and risk controls all carry over unchanged. Execution runs from your own account, and Nabu never holds your funds.

Base support (chain ID 8453) is live inside the closed beta right now, and pair coverage and tooling will keep widening over the coming weeks.

Where this fits

The whole idea behind Nabu is a single strategy layer that sits across venues, so you define your logic once and run it wherever conditions happen to be best. Ethereum already put strategies onchain. But gas just made frequent trading too expensive to bother, arbitrage especially, where the cost per trade has to stay tiny. Base brings that cost down, and adds the token coverage to give those strategies something to work with. More chains and venues are coming.

"These past months were heads-down on the foundation, getting Nabu stable enough to add venues reliably. Base and Uniswap v4 are the latest to land, with a lot more coming through July." - Nicky Chalabi - Founder & CBO at Nabu 

Get access

Already in the beta? Base is in your chain picker today.

Not yet? find us on Discord, Telegram, or X and ask.

The reasoning is simple. Nabu asks traders to verify execution on-chain rather than take our word for it. An audit holds us to that same test, and publishing the result is how we pass it.

What Neplox looked at

The engagement covered the user-facing app at app.nabu.pro: client-side security, login and permissions, and how the trading wallet connects to Privy. Neplox had invite-only access to the platform and the frontend and backend source, and worked as a low-privilege authenticated user.

What it didn't cover: the strategy execution engine, the trading flow, and the wider infrastructure Nabu depends on. Those were out of scope this round, which focused on the app and account layer. We'd rather say that plainly than let "audited" carry weight it hasn't earned.

The findings

Everything rated Critical, High, or Medium is closed. The three that remain are Low and Informational, reviewed and accepted with the reasoning left in the report. That puts 20 of 23 fixed and checked by Neplox.

The two that mattered

Both criticals were real and exploitable, with working proof-of-concepts in the report.

One let any logged-in user write an admin's email onto their own account and inherit admin rights, because the account-linking endpoint took that field straight from the request body. The endpoint no longer trusts a client-supplied email.

The other was an open RPC proxy. An authenticated caller could pass another user's address and read their trading state, then chain that into placing orders on the victim's exchange account. That path no longer hands back another user's data.

Both fixes carry commit hashes in the report, so you can read the diffs yourself.

Why we ran it now

We've kept Nabu in invite-only beta on purpose. Finding this class of bug while the affected group is 50 traders rather than thousands is the whole reason to gate access before scaling. Running the audit during closed beta meant the fixes landed before the crowd did.

The report

The full Neplox assessment is here, with every finding, the proof-of-concept code, the fix commits, and four longer-term architecture discussions the team flagged.

Thanks to Artem Mikheev and Vsevolod Kokorin at Neplox for a sharp, direct engagement.

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 packaged capital. They didn't package strategy.

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.

Split the surface

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.

Strategy becomes the product

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.

What you're actually trusting

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.

Where this goes

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. 

I always wanted my own trading bot. Something that could do the work for me while I slept. I tried vibe-coding one. It didn't work. I'm not a developer, and every time I hit a wall I felt stuck, like I needed someone with real coding chops next to me to get past it. So I went looking for a tool that would just let me describe what I wanted and deploy it. Nothing out there actually solved the problem. That's why we're building Nabu.

Okay. Here's what's actually in your hands.

The execution gap

Crypto opened market access to anyone with an internet connection. That part worked. Execution never caught up.

Running a real strategy still means clicking through a dozen apps, reconciling positions in a spreadsheet, setting alarms for things you'll forget about anyway. The people who actually do well at this aren't always the ones with the best ideas. They're the ones who built systems around their ideas. Most people don't have the time or the resources for that, so they burn out and end up dropping it.

We've written about this in The Rise of Agentic Finance and Introducing Nabu if you want the long version. Short version: the fix isn't another dashboard. It's moving from clicking actions to deploying strategies that run themselves. Trading went from manual, to automated, and then agentic. Nabu is what that last step looks like as a product.

What we shipped

You describe a strategy. An agent builds it.

This is the part that still feels like magic when I use it.

You tell Nabu what you want in plain English. Something like "look for arbitrage on PEPE, 5k notional, only fire if the spread clears fees by at least 30 bps." The agent goes off, pulls live prices from MEXC and Uniswap, checks the orderbook depth, looks at on-chain liquidity, figures out if the trade is actually viable after slippage and gas, sizes the position, and hands you back a strategy you can deploy.

It's not picking from a template. It's researching the pair and writing the thing.

Right now the agent can research arbitrage across 111 tokens. ETH, WETH, USDC, USDT, WBTC on the boring-but-deep end. PEPE, SHIB, FLOKI, DOGE, MOG, NEIRO, MOODENG, SPX on the side where things actually move. (Full list is in the app).

Adding a new pair used to be manual code. Now it's a conversation. That sounds small until you realize how much of running a desk used to be plumbing.

How Nabu compiles the strategies? 

Strategies in Nabu compile down to something called PSL, which stands for Pelagos Strategy Language.

Think of it as a strict rulebook for trading agents. Most code can do anything, which means it can also break in any way. PSL forces a strategy to declare exactly what it's looking at, what conditions it needs, what actions it can take, and what limits it has to respect. If your strategy compiles, the system can prove how it'll behave. If it doesn't compile, it doesn't run. We chose less flexibility on purpose, because the alternative is finding out your bot did something stupid at 4am.

You don't write PSL yourself. The agent does. PSL just runs underneath, doing the boring job of making sure nothing weird happens.

Production hardening on the engine

March was the first month with real capital flowing through end to end. That's a different bar than testnet and we knew it was going in.

We rebuilt the trigger logic. Instead of the engine reacting to every price tick, there's now a planner that watches trend direction and magnitude and only fires runs when there's real conviction behind them. Less wasted gas, better use of the capital that's actually in reserve.

We rewrote how we simulate CEX fills. Old version assumed clean execution. New version models orderbook depth, partial fills, slippage. Backtests now look like live trading instead of a fantasy version of it.

And the one I'm mega proud of: transaction compensation. When you're trading across two venues, the nightmare scenario is one leg landing and the other one not. The system now automatically generates the reverse transactions to bring your portfolio back to a consistent state when that happens. Without that safety net, you can't really call this autonomous execution. You can just call it hopeful.

Product stuff

Wallets get created and registered for you through Privy. You don't have to deal with that.

Every strategy now shows you its actual on-chain transactions and CEX orders, in the dashboard, in real time. No black box.

Portfolio and settings pages got redesigned. Deposit and withdrawal are split out properly. It works on mobile.

The strategy creation flow is currently being reworked because the first round of testers told us, fairly, that it had too many steps. That's the kind of feedback we wanted from running this closed.

The plumbing

Prometheus, Grafana, Loki, full monitoring stack across the platform. Staging and prod are properly separated now. The WASM runtime that strategies execute in got optimized for running a lot of them at once. Boring dev work but necessary.

None of this would be possible without Pelagos, the execution layer Nabu is built on. Pelagos coordinates execution and liquidity across chains with atomic, all-or-nothing guarantees. It's what lets us build multichain appchains, unlock cross-chain liquidity, and deploy autonomous agents like the ones running your strategies. All the hard infrastructure that makes Nabu work lives there.

Where we are by the numbers

We don't have flashy P&L charts to wave around yet. Too early, and what's running is still being watched closely by the team. What we can share is how the engine is behaving under real load.

Every Ethereum block, Nabu pulls fresh market data, hands it to every running strategy, and each one decides whether to fire transactions. End to end, that whole loop lands at roughly 125 to 140 milliseconds per block. Flat. No spikes.

Inside that window, individual strategies do their own evaluation in 5 to 50 milliseconds, depending on complexity.

The point isn't the absolute numbers. It's the consistency. Predictable latency is the whole game here. Spikes are where bad fills come from. We're not seeing them.

How you actually use it

Right now Nabu does one thing well: arbitrage between MEXC and Uniswap V2. We picked that on purpose. It's a strategy with a clear edge, it stress-tests the entire CEX-to-DEX execution path, and it forces us to get the hard stuff right before we add complexity on top.

That's where it starts. It's not where it ends. We're already lining up more CEXes, more DEXes, and other strategy types beyond arbitrage. The plan is to nail the core loop with real users first, then expand.

Here's the actual flow:

1. Login by connecting your Privy wallet.

2. Connect your MEXC account via API

3. Tell the agent what you want to trade and how much.

4. Deploy the strategy once you are ready.

5. Head to the Strategies tab to watch every transaction land in real time. Pause anything, kill anything, adjust anything.

Make sure both sides are funded: your Privy wallet and your MEXC account need to hold the tokens you want to arbitrage. You can top up your Privy wallet straight from the Settings tab.

One thing to keep in mind about the beta: it's early. We're shipping in waves, opening up new users only after the previous wave's issues are cleaned up and the environment is steady. There are rough edges. We're going to ask you a lot of questions. The point of running it this way is that we're building with the people inside, not just for them.

Bug reports, feature requests, weird strategy ideas - all of it goes in our Telegram and Discord rooms. The dev team is in there. We read everything.

What's next

A lot of stuff. Some highlights:

• Uniswap V3 and V4.

• More CEXes. MEXC isn't going to be alone for long :-)

• Base and Solana, plus the DEXs that matter on each.

• Perp DEX strategies, starting with Hyperliquid. This is the one that opens up real strategy variety beyond spot arb.

• Prediction market arbitrage. Different surface, same idea.

• Chinese language support among few others.

• Voice commands. Eventually you should be able to just say what you want and have it deployed. We're not there yet but that's the direction.

None of this is roadmap-deck stuff. The team is building it now. Everyone is locked in.

Get in

Closed beta is invite-only. If you want in, find us on Discord, Telegram, or X and ask.

If you know an arb desk or a quant team or a trader who'd actually push the product hard, send them our way. Those are the people we want.

Thank you so much for reading this far. Time to go trade.

The Nabu team

What didn't work is everything that came after.

Running a serious crypto strategy still means clicking through dozens of apps. Tracking positions across wallets and venues. Setting alarms for token unlocks you'll probably miss anyway. Manually claiming rewards. Watching charts for exit signals late at night, telling yourself you'll act rationally when the time comes.

You usually don't. Let's be honest here.

It's exhausting. Most people eventually burn out, not because they're wrong about markets, but because operating in crypto is a full-time job disguised as market access. The tooling forces you to become a system integrator just to participate. You need research platforms to find opportunities, execution interfaces to act, portfolio trackers to understand what you own, yield dashboards to monitor returns, bridge aggregators to move between chains. And then a spreadsheet to reconcile everything because none of these tools actually talk to each other in a way that matters. Total madness.

This leads to something I've seen play out over and over: the people who do well in crypto aren't always the ones with the best ideas. They're the ones who built systems around their ideas. Trading desks with custom software. Ops pipelines that don't depend on someone being awake, focused, and emotionally neutral at the right moment.

Crypto democratized access. Execution never caught up.

So while anyone can technically participate, the ability to operate at scale still belongs to people with either deep technical resources or an unreasonable amount of time. That's the gap, and it's been hiding in plain sight.

What Is Agentic?

The fix isn't another dashboard or a faster interface or one more aggregation layer pretending to unify things.

It's a shift in how execution itself works.

Agentic finance is finance operated by AI agents instead of human clicks. Not simple automation, not bots running rigid scripts someone wrote months ago and forgot to update. Agents that understand objectives, monitor conditions continuously, make decisions inside explicit constraints, and execute with discipline even when markets change.

The distinction matters more than it seems like it should.

Scripts break when reality deviates. Agents adapt. Bots follow instructions. Agents pursue outcomes. Automation executes tasks. Agents execute strategies.

A strategy isn't a trade, or even a sequence of trades. It's a system with a goal, boundaries, and rules for decision-making when things don't go according to plan. And in crypto, things rarely go according to plan.

Manual → automated → agentic. That's the progression, anyway.

Crypto is where this shift shows up first because the rails are already programmable. But actually using agentic finance means rethinking how strategies get defined and operated in the first place.

The Shift: From Actions to Strategies

Most people still interact with crypto through actions. Swap this token. Bridge to that chain. Deposit here. Claim rewards there. Each action exists in isolation and demands attention at exactly the wrong time.

This model made sense years ago. It doesn't anymore.

The surface area of crypto has exploded—chains, protocols, incentives, risks—while the execution model stayed basically the same. People don't hit a ceiling because they run out of ideas. They hit it because managing all of this manually doesn't scale.

The shift from actions to strategies fixes that.

A strategy is an agent. One that knows what you're trying to accomplish, understands when it should act, respects the boundaries you've set, knows when to stop. Importantly, it doesn't get tired or talk itself out of doing the thing it already decided was correct.

When strategies exist as formal objects instead of loose intentions, they behave differently. They run while you sleep. Execute at 3 AM with the same indifference as 3 PM. They don't hesitate, don't bargain, don't convince themselves this time is different (sounds familiar?).

This isn't about removing humans from decision-making, it's about removing humans from the mechanical parts they're bad at under pressure. You decide what matters. Systems do the rest.

The Strategy Superapp

So here's where the idea of a strategy superapp comes in.

Not a bundle of tools duct-taped together with integrations, but a single system where strategies are the core unit. Where objectives, constraints, execution, and risk controls live together instead of scattered across five tabs and a spreadsheet.

A strategy superapp doesn't ask you to manage actions. It asks you to define intent.

You describe what you're trying to achieve. You specify the conditions under which it should act and the limits it must respect. From there, the system monitors markets, decides when to act, executes with discipline, stops automatically when boundaries get hit.

Without a unified surface, agents are just a nice idea layered on top of fragmented tooling. With one, strategies become durable systems you can test, compare, deploy, and observe without losing context halfway through.

This is the layer that's been missing between market access and real participation.

Systematic Protection

There's a pattern I keep seeing in crypto.

Someone finds a real edge. Makes money for weeks or months. They know the risks, have a plan for what happens if things go wrong. Then one bad episode wipes out a disproportionate amount of the gains.

Not because they didn't know what to do but because they didn't do it.

They hesitated. Waited. Convinced themselves this time was different. Usually happens late, when attention is low and emotions are high.

This isn't a discipline problem. It's a human problem.

Pro trading firms solved this years ago by taking humans out of execution entirely. Rules get encoded into systems that don't feel fear, don't second-guess themselves, don't negotiate with the market at the worst possible moment.

Until recently, that infrastructure was inaccessible to everyone else.

Agentic finance changes that. When risk controls are enforced by systems instead of willpower, protection stops being something you hope you'll remember and becomes something that just happens.

What This Enables

When execution becomes programmable, the limiting factor shifts.

It stops being how many tools you can juggle and starts being how good your thinking is which is where the constraint should have been all along.

Strategies that operate without your presence. Risk limits that enforce themselves. Simulations that let you see how ideas would have behaved before you risk capital. Performance records that show what happened and why, instead of leaving you guessing. All in one place, one system, one source of truth.

This is what "superapp" actually means in practice. Not more features, but fewer seams. A place where strategies can be created, tested, deployed, and refined without constantly context-switching.

Trading is only the obvious starting point. Yield, liquidity management, borrowing, reward harvesting, cross-chain repositioning—they all reduce to the same pattern: define an objective, set boundaries, let a system execute.

Nabu: Building the Strategy Superapp

Nabu is buidling this.

Instead of managing tools, you manage strategies.

Define them in natural language. Test them in simulation. Deploy them with explicit constraints. Once live, they operate independently monitoring conditions, executing trades, enforcing risk limits, stopping when they're supposed to stop.

Every strategy moves through a loop: create variants, simulate and compare them, activate the best, observe outcomes, iterate based on reality instead of assumptions.

Under the hood, strategies compile into PSL (Pelagos Strategy Language), a constrained, verifiable language designed specifically for trading agents. If a strategy compiles, it behaves predictably. If it doesn't, it never reaches execution. That tradeoff—less flexibility, more correctness—is intentional.

Nabu is built for speed and safety. Event-driven execution targeting ~250ms from market event to outbound transaction. Enforced risk controls: daily loss caps, max slippage limits, venue allowlists, kill switches.

This is infrastructure that used to exist only inside professional trading operations. Now it doesn't.

What Comes Next

Manual execution was never the end state, just a transitional phase while better systems got built.

Agentic finance is what comes next.

You describe what you want to achieve. Define clear boundaries. Then your strategies execute across market conditions without requiring constant supervision. Risk controls don't depend on how you feel in the moment. Performance records explain outcomes. Improvement becomes systematic instead of reactive.

When operational barriers fall away, institutional advantages stop being exclusive. The remaining bottleneck is the quality of your thinking.

That's the world we're building. Starting with crypto, where the infrastructure already exists. Expanding as more markets become programmable.

Agentic finance isn't a future concept.

It's already happening.

Anyone can describe an arbitrage opportunity in a sentence. But running it with real capital? That still means assembling bots, managing RPCs, stitching together exchange APIs, and hoping nothing breaks when markets move.

Nabu exists to close that gap.

Nabu is the strategy superapp for agentic finance where AI agents execute strategies with enforced discipline. Define trading strategies in natural language, test them rigorously, and deploy them across DEXs and CEXs with sub-second execution without infrastructure required.

This isn't copy trading. It isn't a black-box bot. And it isn't "AI that trades for you."

This is agentic finance where strategies become agents that execute with discipline.

From hypothesis to execution-grade system

The real bottleneck isn't generating ideas. It's turning many ideas into systems that run unattended.

Most automation products treat strategies as scripts you debug. Nabu treats them as first-class objects you operate.

You describe what should happen and under what constraints:

• Arbitrage across venues, halt if spreads collapse

• Market-neutral yield with exposure caps

• Directional strategies with drawdown limits

• Execution driven by events, not polling

Nabu turns those descriptions into structured, verifiable strategies you can simulate, compare, version, and deploy.

Every strategy moves through an operating loop:

1. Create variants – generate multiple candidates

2. Simulate & rank – measure PnL and risk before deployment

3. Activate the best – promote the top performer

4. Execute – event-driven, low-latency automation

5. Observe outcomes – receipts, metrics, performance

6. Iterate – refine or retire based on reality

Strategy development becomes an operating process, not a one-off bot build.

Built for speed, safety, and reality

Most automation tools optimize for workflows. Nabu optimizes for execution.

At launch, Nabu targets ~250ms p50 from market event to outbound transaction or order request. That's fast enough to unlock strategy classes like cross-exchange arbitrage that die on polling systems.

Speed without safety is useless, though.

Every strategy runs under enforced controls:

• Daily loss caps

• Max slippage limits

• Venue allowlists

• Kill switch

No permission defined? Can't act. Hit a limit? Execution stops.

No silent failures. No "the bot went rogue." No guessing what happened.

A verifiable language for trading strategies

The hard part of AI-assisted trading isn't generation. It's correctness.

General-purpose code generation is flexible, but you own the debugging, safety, and verification.

Nabu takes a different approach.

Strategies compile into PSL (Pelagos Strategy Language), a constrained language designed for trading agents. PSL isn't Turing-complete, which is the point. The constraint gives you deterministic behavior, structured compiler feedback, and enforceable safety rules.

Less flexibility. More correctness.

If a strategy compiles, it behaves predictably. If it doesn't compile, it never reaches execution.

Iteration becomes a fast feedback loop closer to engineering than guess-and-check automation.

Execution without infrastructure

Nabu removes the need to build and maintain a trading stack.

Execution is powered by Pelagos Network, a decentralized substrate that provides canonical market events, state diffs, deterministic execution records, and confidential strategy execution inside secure enclaves.

No RPC management. No exposed keys. No trading safety for speed.

Pelagos enforces how strategies run. Nabu focuses on what they should do.

Intents, solvers, and composable execution

Strategies don't hard-code venue integrations.

They emit intents, declarative specs of desired outcomes, constraints, and acceptance checks. Solvers translate those intents into concrete execution across venues.

This separation matters because strategies stay portable as venues change. Solvers compete on latency, fill quality, and reliability. Execution quality improves over time without rewriting strategy logic.

Nabu launches with a first-party solver and will expand to verified partners, building an execution marketplace without fragmenting strategies.

Over time, this enables agent-to-agent composition. Producer agents specify outcomes as intents. Solver agents satisfy them with concrete execution. Monitoring agents watch receipts and propose controlled updates like tighter bounds, venue switching, parameter changes, all gated by simulation and policy.

The result: execution quality compounds as the solver ecosystem matures.

Social distribution, grounded in performance

Most social trading products optimize for attention. Nabu optimizes for reality.

Every strategy has a canonical page: thesis and constraints, simulation methodology, versioned performance, risk events and policy hits.

The feed surfaces what's actually happening: new releases, performance shifts, safety halts, real adoption. Strategy rooms attach discussion directly to versions and outcomes. Keeps collaboration operational, not noisy.

Leaderboards reward shipping and real usage: onboarding users, attracting TVL, generating volume, sustaining execution quality.

And because strategies run inside secure enclaves, creators can share performance without revealing logic. Distribution without alpha leakage.

Who Nabu is for

Nabu is built for anyone who wants automated trading to be testable and enforceable, not a trust exercise.

Strategy builders turning ideas into production systems without the infrastructure hell.

Advanced traders tired of black boxes.

Funds and trading desks running multiple strategies with real risk management and audit trails.

Influencers and curators who want to monetize strategies transparently, without custody or signal noise.

One strategy or twenty, the interface is the same. Define outcomes, set limits, watch what happens.

Why now

LLMs made expressing strategy ideas cheap. That shifted the bottleneck to verification, safety, and execution.

The challenge isn't generating hypotheses anymore. It's turning many hypotheses into automation that runs unattended: safely, reliably, and fast enough to matter.

Nabu's built on the belief that the next generation of trading platforms won't be chatbots or workflow glue. They'll be execution substrates, systems that can safely turn ideas into live, low-latency strategies.

Trading will be operated by strategies, not clicks.

Nabu's the system built for that world.

What's launching and what's next

Nabu launches with chat-first strategy authoring that generates multiple variants. Research simulation computes PnL and risk before deployment. Ethereum DEX automation plus initial CEX integrations. Event-driven execution targeting ~250ms p50. And policy-bound risk controls: loss caps, slippage limits, venue allowlists, kill switch. Plus strategy pages, feed, and rooms for distribution.

The roadmap: visual strategy editor and templates, high-fidelity simulation with historical backtesting, more CEXs and chains (Solana, non-EVM), perpetuals and privacy-focused ecosystems, verified solver partners and an open registry, competition leagues by strategy class with on-chain attestations, and a creator marketplace with profit sharing.

Nabu is currently in private access.

If you want early access or updates, join the waitlist at nabu.pro or follow @nabupro on X.

Agentic finance starts here.