Before I get into what we built, I want to say something about the team. The past few months have been brutal in the way that only early-stage product work can be. Weekends gone. Sleep schedules broken. Telegram messages at 2am about edge cases nobody else would even notice. There were stretches where the only thing keeping the build moving was a small group of engineers who refused to give up on our goal. I can't thank them enough. If you end up using Nabu and it feels solid, that's why. If it feels clunky don’t forget this is a closed Beta. Help us shape it with your feedback.
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.
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.
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.
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.
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.
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.
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.
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.
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:
Login by connecting your Privy wallet.
Connect your MEXC account via API
Tell the agent what you want to trade and how much.
Deploy the strategy once you are ready.
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.
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.
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