• Week of 15–21 September: active strategies up from 126 to 165, CEX orders from 389 to 440. All time: 540 strategies created.

• Ran KOL campaigns and our first testers programme.

• More Binance and Hyperliquid markets. HIP-3 markets through trade.xyz, which add tokenised stocks, are in final testing.

• The adviser keeps context across follow-ups, asks when a market name is ambiguous, and its margin and leverage suggestions now fit the strategy.

• A lot of execution work to hold up under more users. Fewer repeat calls to exchanges, better rate-limit tracking, more reliable handling of leverage, TP/SL and fills.

Community & GTM

• We ran KOL campaigns, including with @SoulzBTC and @Shuarix. Each came with a $500 prize for that creator's community. 

• 50 testers each spent a week on Nabu writing up what broke. The three best write-ups won $500 USDC each: @JeRRySec0422, @est3r_eth and @azizelliott. Their reports are already in our fix list.

In October we're running at least 3 one-week programmes:

• Testers, round two. Same format as September, new group. A week to trade and write up what's broken, and $500 USDC each for the three best write-ups.

• Skin in the Game. A mini trading competition. Build a strategy on Nabu, run it live with your own money on Hyperliquid or Binance for a week, and post the result on X. Ranked on percentage return, so account size doesn't matter. This is the small version. Bigger competitions like Genesis with a public leaderboard come later.

• Genesis, our first major trading competition, moved to October. We want to be sure the platform holds up with a lot of traders on it, and the extra time lets us polish the leaderboard and the other details.

Nabu in Use

• We had a total of 163 active users on Nabu. 135 of them were new. 

• The week of 15–21 September vs the week before:

• Active strategies: 126 → 165

• Deploys: 74 → 87

• CEX orders: 389 → 440, of which 331 filled

• Peak day was 18 September: 150 orders, 110 filled, 28 users.

• All time: 540 strategies created. As of 22 September, 159 were active, 162 paused and 219 archived.

• No dollar volume yet. We'll add it once paper and live trades are split out in the data.

• We've added tracking for each step from sign-in to first fill. The frontend side is in devnet and the backend is rolling out in stages. Conversion numbers once it's live.

Markets & Venues

• More Binance and Hyperliquid markets.

• HIP-3 markets on Hyperliquid, through trade.xyz, are in final testing. They add tokenised stocks, so you can trade crypto and equities in one account.

• Strategy Studio now knows each market's leverage limits and won't offer settings the venue would reject.

• If a market isn't supported, Nabu says so.

AI Adviser

• Keeps context across follow-up questions.

• Asks which market you mean when a name is ambiguous.

• Sticks more closely to the markets we support.

• Margin and leverage suggestions now fit a strategy you can actually deploy.

• We're moving to specialised models for different parts of the conversation, like exploring an idea, building the strategy and explaining backtest results.

Strategy Management

• If you bring your own PSL, you can reopen the chat later and go back to your Paper or live setup.

• Featured strategy cards are tied to the exact version and test run behind their results. Change the strategy and the old result no longer shows as current.

• All Strategies has search, sorting and pagination.

• Order and TP/SL activity is easier to follow.

Execution & Infrastructure

• Moved strategy compilation off the hot path.

• Nabu now reads Hyperliquid's private stream instead of asking the exchange for the same data again and again.

• Better tracking of rate limits and queued work.

• More reliable handling of leverage, TP/SL orders, fills and positions closed by the exchange.

Portfolio & PnL

• The portfolio shows your account value over time, transfers included. Each strategy shows its own trading PnL.

• Fewer places where two screens show different numbers for the same thing.

• You can see value by chain.

• Long-range charts should stay quick as your history grows.

What's Next

• The three October programmes (including Genesis)

• HIP-3 markets and tokenised stocks through trade.xyz, once testing is done.

• Shareable PnL cards.

• GMX: decentralised perps, plus joint campaigns with the GMX team.

• Testing the platform at 2,000 users.

• Further out: bring the LLM of your choice to the strategy workflow.

Thanks to everyone who spent a week breaking things for us. If you want to trade on Nabu, DM @nabupro for an invite code. See you at Genesis.

— Nicky, Evgenii and the Pelagos Team

• Describe a strategy in plain English and the adviser turns it into a validated Studio configuration.

• 14 editable strategy shapes, 20 presets, and backtesting that runs the exact rules you review.

• Strategies get their own leverage and margin settings, native TP/SL alongside signal exits, and position-aware Kill and Archive.

• Performance tracking comes straight from the venue. Fills paired into round trips, TP/SL attributed to the position that placed it, funding in PnL.

• The portfolio page, strategies header, strategy pages, trade history and template flow were all redone after three weeks of using the product ourselves.

• Genesis moves to September so it runs on this build. More at the end.

AI Adviser

• Describe a strategy in plain English and the adviser uses your balance, risk preferences and the markets on the platform to propose one you can test and run.

• The output is a validated Strategy Studio configuration, not an answer in chat.

• The adviser checks whether a requested market is supported and explains any substitution it makes.

• If research, validation or a backtest runs long, the conversation resumes from the last completed step.

• After a backtest, the adviser reviews the result with you and helps decide: adjust, go to Paper, or stop.

• The chat gives one final answer per turn. Progress stays out of the transcript, and every answer is checked so it never points to an option it didn't show.

• Stricter sourcing: market sentiment needs two independent news sources, social and influencer accounts are marked anecdotal, and derivatives figures only appear when there's typed data behind them.

• Ask how to position for a macro event and it pulls the positioning picture (funding, liquidation clusters, rates, ETF flows, sentiment), leads with a verdict, sets trigger levels from the data, and offers each option as a Studio strategy you can backtest.

• If a proposed strategy fails validation, the adviser repairs it in the same turn.

• Ask for a token list and you get a list, plus a question about what's missing.

• Binance authoring works the same as Hyperliquid.

Strategy Lab & Templates

• 14 editable strategy shapes: trend following, momentum, mean reversion, moving-average systems, RSI and stochastic, volatility regimes, defined-risk and trailing exits.

• 20 curated presets, 10 spot and 10 perp. Each opens the same editable Studio form as an AI-generated or manual strategy.

• Backtesting runs your generated PSL against prepared historical data, so the rules you review are the rules being tested.

• Backtests are reproducible and handle ordinary data gaps. Run the same config twice, get the same answer.

• Exit-rule validation catches conditions that can never fire.

• Template library cleaned up: venues match actions, the ATR volatility template goes both ways, spot venues show spot parameters.

• New template flow: pick one, sign in if needed, set your own size, deploy, land back where you started.

Strategy Toolkit

• Confirmed-bar OHLCV data and the core indicator set: SMA, EMA, RMA, RSI, ATR, stochastic, Bollinger. Signed-flow inputs and lagged observations on top.

• Fixed stop/target exits and three trailing-exit models.

• Pine Script to PSL migration is now largely automated, so the tested strategy library grows faster.

Execution & Strategy Lifecycle

• Nabu now reconciles against the venue on Binance and Hyperliquid perps. Positions, orders and reservations are checked venue-side; reservations release on rejection or archive, positions opened on the venue show up in Nabu, and Activity only logs what the venue confirmed.

• Deploy runs pre-flight checks for minimum notional, available balance and concurrency limits before any order goes out.

• Native stop-loss and take-profit can be combined with the strategy's own signal exits and close-before-reversal rules.

• Live Signals shows the rule, the current indicator values and how far the condition is from firing. Values keep updating while a position is open.

• Delayed orders, late fills, stale account data and failed protection placement are handled: the strategy keeps managing the position, recovers, or tells you why it needs you.

• Kill closes the position on the venue. Archive waits until the strategy is flat.

• Partial fills are handled: the strategy tracks what filled and works the rest.

• Long/short reversal is a supported strategy shape: one signal flips the position.

• Pause reasons and lifecycle events show in the Activity log.

• Paper mode: pick a starting balance and follow the strategy through the same activity, signal, fill and PnL surfaces as live. Paper and real strategies are marked separately.

PnL & Reporting

• Fills are classified as open or close and paired into round trips. Realised PnL, win/loss and hold time come from the pair.

• Venue-native TP and SL fills are tied to the position that placed them and labelled by whichever leg fired.

• Funding is in Total PnL at venue precision.

• Exchange-data failures are shown by venue, and an incomplete value says so instead of reading as a loss.

• The strategies header shows Total Value Deployed: mark-to-market of open positions held by active strategies. Flat strategies show a dash.

Sizing & Leverage

• Size a strategy by margin or by position notional, your choice.

• Each strategy runs its own leverage, independent of the account setting.

• Presets no longer come with a size filled in. Sizing, leverage and TP/SL are yours to set, and deploy checks them against your venue balance.

Venues & Markets

• Hyperliquid connect and account-refresh reworked, with a direct link to the docs from the connect screen.

• Binance perps token list refreshed.

UI & UX

• Portfolio page rebuilt. Everything you hold by asset, venue or chain, a hide-dust toggle that doesn't distort totals, unpriced tokens badged, and the last good state stays on screen if a refresh fails.

• Strategies header redesigned, one number per card: Total Value Deployed, Today's PnL with all-time underneath, trades, active count, worst drawdown.

• Strategy pages show the whole configuration, including every signal as compiled. Back takes you where you came from. Strategies can be reordered.

• Trade history has a reason on every row, closes labelled as closes, TP and SL fills named by leg, prices at asset precision.

• Activity shows orders and fills as separate events, with pause reasons.

• Focus mode for popups, waitlist sign-in via X, USD everywhere, and a lot of small fixes from three weeks of daily use.

• Faster page loads across the app and strategies pages, desktop and mobile.

Community & GTM

• Genesis, our first trading competition, moves to September so it runs on the August build. Everything is ready, from the rules and referral codes to the KOL partners and the $10,000 USDC pool. Waitlist spots hold.

• Joint campaigns with upcoming venues are agreed and waiting on the integrations.

• Incentivised feedback and debug program ready to launch: rewards for reproducible bug reports and product feedback, opening alongside Genesis.

• We started reaching out to traders directly: profitable on-chain wallets with an X presence, invited to Genesis and the feedback program.

What's Next

• Genesis opens.

• Locked capital allocation per strategy, with a Capital Under Management figure in the header.

• HIP-3 markets on Hyperliquid.

• GMX, 1inch and further venues, after Genesis.

August was about trusting the loop with real money before asking anyone else to. September is Genesis.

— Nicky, Evgenii and the Pelagos Team

• The AI can now read your balance and risk, pick a strategy, and configure it for you.

• Strategies can be backtested against a year of real market data before they touch a cent.

• Binance is integrated for spot and perpetuals, and Hyperliquid perps live in full.

Internally, we also made an important decision. We're pausing the venue race to focus on stability and usability. More on that below.

Let's go into the details.

GTM

Binance is in, and leverage is live. We added Binance support for spot and perpetuals, and enabled leverage on both Hyperliquid and Binance. It brings the deepest books in the market into the same strategy pipeline that runs your other venues.

Hyperliquid perpetuals live in full. Leverage and isolated-margin actions, full order lifecycle, scheduled cancellation, TWAP, trigger and modify flows, account context, unified balances, and signed-action reconciliation. Everything a perp strategy needs to run unattended.

The trading competition is coming together. We're building the waitlist, the rules, and the mechanics that make a competition worth entering: leaderboards, eligible strategies, prizes. Alongside it we've partnered with trader KOLs and their communities, who will compete and onboard their audiences with them. It kicks off August 24, and seats are limited.

Joint campaigns are agreed and loaded. Every new trading venue we're integrating in the near future has agreed to run joint marketing and announcements. They fire as each integration goes live.

We made Nabu a lot easier to use. A new guided tour takes you from sign-up to your first live strategy step by step. The portfolio page got a major overhaul too: everything you hold, sliced by asset, venue or chain, in one view. Already have an invite code? Come see for yourself.

On metrics, an honest month. We didn't push onboarding in July. The focus went to improving the product, so we unlocked very few invite codes, only for users who genuinely wanted to give feedback. The numbers reflect that choice. Our paid campaign on X did close to 5 million impressions, built for awareness ahead of the competition, not for clicks. The site saw about 1,000 visits. With the trading competition going live on the 24th of August, we expect our first real batch of users.

Tech

We shipped an AI strategy adviser. Until now the AI built what you asked for. The adviser goes further: it reads your balance and risk preferences, picks a suitable strategy from the supported set, produces a validated Studio configuration, and reviews your backtest results with you afterward. Under the hood it runs strict validation on everything it generates, binds strategies deterministically to real markets, and repairs its own output when a check fails. What the adviser hands you already passes every check and can run as-is.

The AI conversation got smoother. We reworked the conversational flow and the AI now surfaces all the information you need as you go.

The Strategy Lab foundation is complete. The Studio gives you 14 editable strategy shapes to start from: trend following, momentum, mean reversion, moving-average systems, RSI and stochastic defined-risk setups, ATR trailing strategies, signed flow, multi-bar reversal, and volatility regimes. Pick a shape, edit it, then backtest it, paper test it, or deploy it. Same pipeline whether the config came from you, a preset, or the AI.

Backtesting is live. The backtest service runs your actual generated PSL against real historical market data we've prepared for this. A year of history on 15-minute candles comes back in 20 to 30 seconds. This closes the loop the product needed: idea, strategy, backtest, paper test, deploy, all before real funds are involved.

20 curated presets, all editable. We added a preset library: 10 spot and 10 perpetual strategies. Selecting one hydrates the same Studio form as everything else, so every preset is fully editable. Open it, see the logic, change what you want.

A new exchange integration framework. Building for both centralized and on-chain venues pushed us to a new framework for exchange integration that makes each further exchange and venue easier to add, with private account streams, paper trading support, and appchain-managed leverage changes handled inside it. You'll see the payoff in how fast the next ones land.

Unified portfolio access. We introduced a wallet-level live-access grant for connected exchanges, so your portfolio view spans everything you've connected without repeated permission dances.

Take-profit and stop-loss orders shipped. Users can now attach TP and SL to positions directly. Nobody runs real size without these, and until this month Nabu didn't have them.

Automated Pine Script migration. We built tooling that migrates Pine Script strategies to PSL automatically. There are years of tested public strategies written in Pine Script. This gives Nabu a wide library of them without hand-porting each one.

The strategy vocabulary got deeper. Confirmed-bar OHLCV materialization, plus SMA, EMA, RMA, RSI, ATR, stochastic, Bollinger Bands, signed-flow indicators, lagged OHLCV observations, fixed stop and target exits, and three trailing-exit models. Every indicator added is a class of strategies that can now be expressed in PSL.

What's next

Stability over new venues. GMX, 1inch and the rest are still coming, and the joint campaigns are ready to fire when they do. But we've decided to shift focus. Adding venues faster than users can reliably use them builds a wide product that works badly. So August goes to the platform itself: more templates, a better Strategy Labs, UI and UX improvements, and the tools traders need before they'll run real size.

The trading competition kicks off August 24. Rules, eligible strategies, prizes and leaderboards are built. Seats are limited, so follow us on X to catch the entry window.

July put the full strategy loop in place: describe it, backtest it, paper test it, deploy it, verify it on-chain. August is about making that loop solid enough to invite a much bigger crowd through it.

— Nicky, Evgenii and the Pelagos Team

May was the month we held access back because we weren't ready on two things. June closed the audit, which was the gate holding wider access to users. With the report out, July is going to be important for the whole team. 

Let’s go into the details.

GTM

Our CEO put out the vision for Nabu. Not a product update, the bigger argument for what we're building. Good strategy is stuck private, where capital can't reach it, or public, where the edge gets copied out the moment it works. Nabu's answer is selective disclosure: policy public, alpha private, so capital can judge a strategy without the author torching what makes it work. Vaults made capital programmable. Nabu makes strategy investable.

We turned the new venues into a strategy list, built from what testers actually want. With v4 and Hyperliquid landing, we asked the current testers which strategies they'd want to run on them and used that to put together a spot-only list. We did the same for perps, this time leaning on our own research alongside the feedback. So when we open these up, there's already a sensible set of strategies for each venue ready to go.

Our best month yet on X. Organic impressions on X hit 140K, the most we've ever had. Website active users came in at 2K, up from 1.2K last month, about a 67% jump. We're still not reading much into follower count on its own, but reach and on-site activity both moved in the right direction.

The first trading competition is built. We've set the rules, the eligible strategies, the prize structure and the leaderboards. Traders go head to head to see who runs the best strategies, and it goes live soon. There are limited seats so make sure to follow us so you can participate. 

Lining up announcement partners ahead of the next integrations. Opening arbitrage between perp DEXs needs more venues, and we've started that work. Alongside the integrations we've opened conversations with several well-known names in the space to line up announcements and campaigns, ready to fire the moment each integration is live.

Tech

Base is live, and it brings Uniswap v4 with it. Base is in the venue picker for testers now (chain ID 8453), and strategies execute there through Uniswap v4, so you get v4 from the start with no extra setup. Base does two things for the strategies you run. The first is cost. A swap that ran about $0.17 on Ethereum mainnet comes in around $0.001 on Base. A tenth of a cent.

Both numbers are on-chain, so go check them yourself. That gap is what decides whether a strategy is worth running onchain at all, arbitrage most of all, where a chunk of every spread used to vanish into gas before you'd captured it. Cheap execution makes the thin spreads worth taking and the fast, small-clip strategies workable, with none of the strategy logic changing underneath. The second thing is reach. Base brings a wider set of tokens, including ones that weren't reachable before, and on v4 a lot of them trade in direct pairs rather than routing through an intermediate asset, which means fewer hops and less slippage. Coverage at launch spans the pairs with real depth, roughly everything trading above $50k in volume, so there's a genuine market to work with from day one. None of this touches custody: execution runs from your own account and Nabu never holds your funds.

Hyperliquid integration shipped. Hyperliquid is integrated. Market data is flowing and the trading path is landing now. It brings perps into Nabu for the first time: basis trades, funding-rate plays, perp/spot arb across venues. Live for testers in July.

Paper testing: try a strategy before you fund it. You can now deploy any strategy in paper mode. It runs exactly like a live one, real market data, real order flow, the strategy running its actual logic, but it never touches real funds. No live orders, nothing on-chain. You give it a starting balance, let it run, and watch its PnL and fills on the normal dashboards. A new user can validate what the agent built and see how it behaves before committing a cent. It takes the risk out of the first run.

The Neplox audit is done, and we published all 23 findings. Neplox spent two weeks on the app and account layer: client-side security, login and permissions, and how the trading wallet connects to Privy.

They came back with 23 issues. Everything rated Critical, High or Medium is fixed and re-checked, which is 20 of 23 closed. The three left open are Low and Informational, reviewed and accepted with the reasoning left in the report. Both criticals were real and exploitable, with working proof-of-concepts and fix commits you can read for yourself. We published the whole thing rather than a write-up of the flattering parts, because Nabu asks traders to verify execution on-chain instead of taking our word, and an audit holds us to that same test. Full report here.

What's next

Improve the product through AI, and start onboarding at scale. With the audit closed and the report out, two jobs come forward. We keep pushing the AI, sharper generation and a shorter path from idea to a live strategy. And we start onboarding properly, moving from the small tester group to real numbers. We're partnering with an agency to run campaigns, and we'll name them once the agreement is signed, alongside our own strategy-creation campaigns. Strategy templates land here too, ready for new users to build from. The goal for the month is 100 users running wallets between $500 and $1,000.

More chains, more venues. July widens the surface the agent has to work with. We're adding Arbitrum on the chain side, with a set of new venues alongside it: Binance, GMX and Ostium for on-chain perps, 1inch for better on-chain pricing and routing, and more centralized perp venues coming behind them. Every one of these is more pairs and more routes for the agent, plus strategy types that only open up once the venue's actually live.

The audit was the thing we'd been gating wider access on, and it's closed now. So July is about opening up to a much bigger group and pushing for real volume, while we keep grinding the AI fees and the onboarding path down.

— Nicky, Evgenii and the Pelagos Team

What May actually became was the work behind that. We pushed the strategy agent forward, sped up the execution engine, got the external audit done, and used what testers showed us to cut friction out of the path they take through the product. On the go-to-market side this was our strongest month yet. The details below.

GTM

The AI generation problem from April is fixed. This was the main thing slowing our invite waves last month. The AI strategy generation now does buy/sell and simple arbitrage reliably, which is the bar we needed it to clear before putting it in front of more people. We gave it to about 10 users this month and sat close with them, watching how they used it and where it still felt rough. The whole value prop for a power user is to describe what you want, the agent builds it and deploys it. That now works for the strategy types a new user reaches for first.

Two things still gate wider access. First, the AI fees are higher than we want them to be. The service works, but each generation costs more than we’re comfortable putting on users right now, and we’re bringing that down. Second, the audit. The external review was carried out this month and we’re working through the findings now. We’re not opening access wider until both are closed. That’s the honest tradeoff behind missing the May number. We’d rather be a few weeks late than open up before either is right.

X ads are cleared, and the first paid test worked. We resolved all our issues with X ads, so the account is now ready to launch paid campaigns. We ran our first test and got impressive results, over 2.5M impressions and thousands of link clicks to the website, all on a limited test budget. Organic impressions came in around 120K, our best month ever. Follower count stayed flat at 1.2K. Like we said in April, follower count on its own doesn’t tell us much. What’s promising is that paid is now a lever we can actually pull, and the early numbers say it’s a good one.

A new UI for the Portfolio and Strategy pages. Following our first power traders’ feedback, we designed a complete new UI for the Portfolio page and the Strategy page. It goes live in the next few weeks.

Pricing is designed. We also designed the full pricing strategy for Nabu and the UI that goes with it. It ships once the product is ready for market, but the thinking and the design are done, so it won’t be a scramble when the time comes.

The newsletter moved to Beehiiv. We moved our newsletter from Mailchimp to Beehiiv. We’d built up to 7K subscribers on Mailchimp when they decided to stop our service. Their policy toward crypto isn’t the friendliest. So we had to move, and we went with Beehiiv, which we’re really happy with. They’re crypto-friendly, the UX is great, and our open rate on the first newsletter jumped to 19.94%, which is high. We can’t wait to use it more often to share updates with our subs.

The creator program. Applications closed this month. We got over 2,700 applications and the team is reviewing every single one. We've already shortlisted a few good candidates, and we'll be onboarding them slowly as we see good fit.

KOL pilot. We also worked with a small group of KOLs this month. They built trading strategies with Nabu themselves and posted honest run-downs of how it went, the good and the rough. Around 25K impressions between them and hundreds of reactions. The bet is the same one behind the creator program: creators testing the product and posting about their real experience lands better than anything we say about ourselves.

Website traffic. Traffic on nabu.pro was relatively quiet early in the month and then jumped from mid-May onward as campaigns started to kick in. About 1,168 page views and 831 active users month-to-date, with an average session around 59 seconds.

Tech

With real money running through the platform, May went into the parts of the product that have to be solid before we widen access. Mostly that’s the strategy agent and the execution engine, plus the guardrails around both.

A stronger strategy agent. We made a round of improvements to the agent that turns a plain-English request into a working strategy. Before it writes anything now, it researches the market. It looks up the token, checks the pools and liquidity, sees what’s actually tradable. So the strategy it builds actually matches what’s there. It also checks its own work against a growing list of known mistakes before handing a strategy back, catching errors that used to slip through.

Faster, more reliable execution. On the engine side, we finished the work to speed up the path from a strategy spotting an opportunity to an order actually filling, and built the monitoring to measure every step of it. The picture from production is encouraging. Most of the price data a strategy reads is fresh to within a tenth of a second. And it earns its keep: it let us catch a live strategy that had silently stalled instead of trading, the kind of issue that’s invisible without it. We also made orders behave correctly under real conditions. Partial fills, retries, stale prices, all handled cleanly now.

Tested with real users, on real money. This was the first full month with testers running strategies with live funds, and we worked closely with that first group. Watching where they got stuck, then feeding it straight back into the agent, the engine, the onboarding flow. We also stood up automated end-to-end tests across the wallet so the path our testers rely on doesn’t quietly break as we keep shipping.

Base is ready. Base is fully built and integrated into the engine. It’s a lower-fee chain that gives strategies more pairs and cheaper execution. It’s done on our side. We’ll switch it on for testers once the audit findings are closed.

Audit done. We finished audit preparation and the external security audit was carried out this month. Working through the findings is the main item for next month, with the fixes shipping inside the same window. That’s the gate that unlocks wider access.

What’s next

Hyperliquid integration. We’ve already started building the Hyperliquid integration and it should go live in June. That brings perps into Nabu for the first time. New surface for the agent to work with: basis trades, funding rate plays, perp/spot arb across venues.

Uniswap V4. Bringing V4 into the tester experience. V4 unlocks custom hooks and pool structures that V2 can’t touch, and the token list grows alongside it. More pairs, more viable arb routes, more for the agent to work with when it generates strategies.

Improving the agent and the user path. We keep pushing on the agent. Sharper market analysis, more reliable strategy generation. And on the path the user takes around it, cutting down the steps between sign-up and a first deployed strategy. The close feedback loop with current testers keeps going through June and feeds directly into both.

Post audit fixes. Working through the findings from the external audit and shipping the fixes. Closing this out unlocks broader access.

June is about finishing the audit and the AI work and then opening up. Alongside that we keep working on AI efficiency to push the fees down. When the audit is closed and the fees are where we want them, we open access to a much bigger group and start pushing for real volume. The 10 testers we have now keep going through June, and what they show us keeps shaping the onboarding and strategy creation flow.

— Nicky, Evgenii and the Pelagos Team

Closed beta is live. Nabu opened to traders this month with real money on the line, running arbitrage strategies on MEXC and Uniswap. Closed beta means we hand out invite codes deliberately and only widen access as stability holds, same logic we laid out in March. We want a small group of users actually trading right now so we can see what breaks before we open this up to more people.

Invite waves and testers. We sent out invite codes in waves and ended up with 40+ people who got access, poked around the frontend, and tried to get strategies running. Not a huge number but that's on purpose as we're not opening the floodgates while the execution environment is still being stabilised. Out of those, we pulled 5 users into closer working sessions. Sat with them, watched where they got lost, got their honest take on the strategy creation flow, deposits, withdrawals, onboarding. That feedback is going straight into what Evgenii, Boris and the rest of the team are building right now.

New public site. The waitlist one-pager came down. The new site is live on desktop and mobile with product, vision, roadmap, blog, and a teaser video. The whole team is super happy the site is out and people can finally see what we've been working on.

Creator program. 2,000+ applications. We launched a content creator program and got over 2,000 applications. First batch is being onboarded next week. The bet is that creators can test the product themselves and post about their real experience with it.

Discord rebuilt. Revamped the server end to end. We split out builders and creators into separate spaces and added regional channels, then redid the role structure across the server. One Discord covers both Pelagos and Nabu since the audience overlaps and we didn't see a reason to split them. We also pushed a batch of invite codes through the community this month instead of only handing them out via direct asks, so users showing up engaged have a path in.

AI strategy generation ran into problems. The service works but not reliably enough to put in front of more users and feel good about it. That's what we're fixing right now and it's the main reason the invite waves haven't moved faster. The whole value prop for a power user is: describe what you want, the agent builds it and deploys it.

Frontend security audit. Also in progress. The wallet handles real funds through Privy so we're not expanding the tester pool until that's done and we're comfortable with it. Slows things down a bit but there's no version of this where we cut corners on that.

Best traction month to date. Nabu's X account went from a few hundred followers to 1.2K, with over 107K impressions for the month. Both numbers are records for us. The crypto attention environment has been quiet for months and we flagged that in March. What changed is we had solid updates worth posting about. The launch, the site, the creator program all hit in the same few weeks. Follower count doesn't tell us much on its own. The signal we care about is whether testers stay engaged once they get inside, and we won't really know that until the AI is solid and we have more of them in. 

Fundraising

Fundraising is ongoing. Conversations are active and we're talking to funds. If you have a connection to a fund that should be looking at this, an intro is still useful.

Tech

Uniswap V4 support. Added V4 as a first-class DEX in the arbitrage engine alongside V2. NabuAgent-generated strategies can now route through V4 pools, meaningfully expanding the universe of viable pairs.

Base integration. Added Base as a supported chain. The arbitrage engine, fetcher, and tokenlist now operate against Base alongside Ethereum mainnet, opening a lower-fee execution surface for the strategy fleet.

Agent v2 with PSL state machine. Reworked the PSL strategy DSL around state-machine primitives. Strategies now express stage transitions, conditional waits, and compensation paths as first-class concepts instead of unrolling them by hand. Generated strategies are shorter, more correct, and easier to audit.

Pre-audit hardening. April was the month we got the codebase ready for an external security audit. Formalised invariants across the strategy execution path and added in-code assertions.

Frontend rebuilt on Vite. Migrated the wallet from Next.js to a Vite SPA. Next.js was slowing iteration (slow dev server, awkward SSR boundaries for an authenticated app) and the SPA model fits a wallet much better. Migration shipped without feature regressions. On top of it we restructured the Activity tab, fixed long-standing PnL bugs, and added live CEX balances and on-chain balance to the Portfolio view.

Observability and infrastructure. Parallel strategy execution inside a single appchain instance, which was previously serialised and capped throughput as the strategy pool grew. Targeted performance pass over hot paths. DB metrics across the appchain, git branch and commit hash tracked per service, Loki structured queries, and a state migration framework for the appchain.

What's next

May target is 100 power users actually running strategies, not just signed up and sitting there. That's contingent on the AI being solid and audit completion, which is the thing we're most focused on right now.

Base and Uniswap V4 went live in the engine in April. We're rolling them out into the tester experience in May. V4 unlocks custom hooks and pool structures that V2 can't touch, and Base brings a bigger pool of liquid pairs to work with. The token list grows alongside this so users have a lot more surface area to run strategies against, more pairs, more viable arb routes, more for the agent to work with when it generates strategies.

The close feedback loop with current testers keeps going through May. What they're showing us is feeding directly into cutting down the steps between sign-up and first deployed strategy.

Nicky, Evgenii and the Pelagos Team

Failures happen at the deployment stage specifically. So instead of pushing forward with more features or onboarding more users, we spent the time debugging and reworking the architecture underneath. Not glamorous work but necessary.

Invite codes went live. We're gating access deliberately and each wave will only open once the previous wave's issues are resolved and the environment is stable. We wanted to move faster on onboarding this month. Didn't happen. The stability work had to come first. We'll catch up in April.

Fundraising

We started conversations around our seed round. Before formally opening the raise we spent several weeks talking to 15+ funds, sharing the product, getting honest feedback on valuation, positioning, and the questions we should expect in diligence. That process was genuinely useful. Sharpened how we talk about what we're building.

If you have a connection to a fund that should be looking at this, an intro at this stage is valuable. We'll move fast.

Tech

AI strategy generation service. We built and shipped a standalone AI microservice that takes a natural-language description of a trading strategy and produces deployable PSL code. The agent researches on-chain liquidity and CEX orderbooks on its own, evaluates whether the pair is viable, sizes the position, assembles the strategy, validates the output. One conversation turn. This is the core of the Nabu product experience: describe what you want, the agent builds it. Adding a new pair is now a research + generation step, not manual PSL authoring. Massive difference operationally.

Execution engine — production hardening. Real money flowing through the system meant the engine had to go from "works in simulation" to "safe to run with money." Three things got us there:

First, the stimulus and trend planner. New subsystem that decides when to fire arbitrage runs based on price trend direction, magnitude, and available capital. Instead of reacting to every tick, the engine filters for high-conviction signals and sizes runs against the reserve. Less wasted gas, better capital efficiency.

Second, realistic CEX fill model. Simulates orderbook depth, partial fills, slippage. Backtesting now actually matches what happens live. We can evaluate strategies before deployment without discovering surprises in production.

Third, transaction compensation. When one leg of a multi-venue trade completes and the other doesn't, the system automatically generates reverse transactions to keep the portfolio consistent. This is the safety net that makes autonomous execution viable. Without it you're just hoping both legs land every time.

User experience. Invite code system shipped end to end including: backend, admin panel, onboarding gate. Frontend now shows per-strategy on-chain transactions and CEX orders so users can see exactly what their strategies are doing. Wallet onboarding automated through Privy managed wallets register on the appchain without the user doing anything. Portfolio and settings pages got redesigned with separate deposit/withdraw flows and mobile-responsive layout.

Infrastructure. Built a full monitoring stack: Prometheus metrics across the platform, Grafana dashboards, centralised logging with Loki. Staging and production now have separate deployment configs. WASM strategy runtime optimised for running strategies concurrently — binary caching, execution path streamlining, structured logging. Midnight network support added on the SDK side.

7,000 on the waitlist

Social interest across crypto has been slow this month (honestly in the past few months) and  we sure felt it in our X impressions. However our waitlist still grew by 500 users, bringing the total to 7,000. That number doesn't mean much until people are inside and deploying strategies, but as a signal during a quiet period it's fine.

We built a full website in the background: desktop and mobile that will replace the waitlist site once we open up. Homepage, product page, vision, roadmap, promo video. It's ready. 

Growth levers we're building out as the platform stabilises: invite codes are live, the only way to get them is by asking our team via Discord, Telegram and X. A referral program is also built and codes will be available in a few months.

On the product marketing side we've been redesigning the onboarding flow, portfolio pages, and strategy pages. Giving users full control of their trading once they're in.

GTM & budget

Two big docs got finished. A six-phase go-to-market plan with full descriptions of the campaigns, growth levers, and metrics for each phase. And a detailed budget plan tying spend to business milestones. Can't scale without them. 

What's next

April we need to do two things. Get more testers in, and go deeper with the ones already on the platform. Invite code waves will keep opening as stability milestones get hit. We want people trading different strategy types, not just the obvious ones. And we're going to start running structured feedback sessions. We need to know exactly where the friction is before we open this up more broadly.

After months of closed development, Nabu V1 shipped to our first cohort of testers this month. Not a demo. Not a sandbox. The real product, live on Ethereum mainnet with Uniswap V2 ↔ MEXC as the first DEX↔CEX pair.

Users are creating strategies, running simulations, and deploying with real policy controls. We’re watching how they interact with the creation flow, where they get stuck, what they try that we didn’t expect, and what breaks.

We shipped later than we originally scoped for January. The extra time went into getting the DEX↔CEX execution loop right. We didn’t want testers hitting a half-working product and forming the wrong first impression. That tradeoff was worth it.

Early feedback is already coming in. The main one so far: the strategy creation flow takes too many steps. We’re reworking the UI/UX to simplify the whole experience. This is exactly why we’re running a private release before opening up more broadly.

More venues and chains are coming. Right now the priority is nailing the core loop with real users before we expand the surface area.

AI-powered strategy generation

The biggest technical milestone this month: we built and shipped an AI agent that translates natural-language strategy descriptions into compilable PSL code. Not templating. The agent researches on-chain data (token addresses, pair liquidity, protocol details, real-time prices), generates PSL, and compiles it in a single conversational flow.

Several generated strategies are already producing positive simulated P&L on Uniswap V2 ↔ MEXC pairs. Early results, but the loop works: describe what you want, the agent builds it, you verify the code, simulate, deploy.

Midnight & Intent Protocol

In January we announced the Midnight partnership. In February we started building it.

Intent Protocol appchain. We built a working prototype on the Pelagos SDK. A cross-chain swap engine that manages the full intent lifecycle: lock → solve → settle → release, with on-chain escrow and settlement contracts and an automated solver bot.

Midnight smart contract prototype. Deployed and built tooling to interact with it. We’re now integrating Midnight components into the Intent Protocol appchain and the broader Pelagos infrastructure.

The goal is a single cross-chain swap pipeline connecting Midnight, Cardano, and external networks through Pelagos’ atomic execution model. Still early stage.

Infrastructure

Stability improvements across Pelagos core services this month. Less visible, equally important. The kind of work that keeps everything above running.

6,500+ on the waitlist

We announced Nabu publicly this month. Launched a microsite, X, Telegram, blog posts covering the vision and litepaper. One coordinated push with the end result of 6,500 people signing up for the waitlist.

That number means nothing until they activate and deploy strategies. But as a signal of interest before Nabu opens doors for the public, it’s a solid start.

The community is forming on X and Telegram. Still small, but people are asking about strategy types, execution latency, venue support. The right conversations.

Nicky joined a Space hosted by Peanut Trade on the future of perp DEXs. 50,000+ listeners. Good visibility with the right audience we’re building for.

From the Pelagos side, we put out a post about the kind of community we want: users who operate the product and bring other users who do the same. Not spectators, not farmers. We laid out how incentives will reflect that.

Incentives, tokenomics, business model

Three key docs got finished this month:

Incentives framework. How users earn across five dimensions: subscription loyalty, outcome quality, referral quality, execution volume, engagement depth. Designed so gaming it is harder than just using the product. In legal review now.

Tokenomics. Complete. In legal review. We’ll share closer to TGE.

Business model. Revenue streams, unit economics, path to sustainability. Sharing with investors.

These had to be done before we can go public on incentives or the token. They’re done. We move.

Plans for March

Product gets pressure-tested. Targeted outreach to professional trading groups, quant firms, and arb desks. We need users who will find every edge case and tell us what’s broken.

KOL partnerships start. Partnering with crypto-native traders and DeFi analysts to demo Nabu through live sessions and strategy walkthroughs. We’re being very selective about who we work with. The bar is they have to actually use the product. No scripts, no paid shills, no cringe.

Community grows with purpose. Dedicated channels for strategy sharing, performance discussion, and direct lines to the dev team.

What’s coming:

Nabu will have a full website with product details, documentation, and onboarding. We’re slowly opening up access to more traders. We’ll be giving out invite codes that grant access to test the platform.

We’ll keep collecting feedback, polishing the product, and working toward a broader launch. The target is 50 traders testing real strategies by the end of March. If we hit that and the feedback is strong, we’re on track. If not, we’ll know what needs to change.

If you know arb desks, quant teams, or traders who’d want early access, intros are welcome.

- Nicky, Evgenii and the Pelagos Team

In January, we repositioned Pelagos to set the foundation for what's coming in 2026: protocol mainnet, our flagship product launch, and major ecosystem integrations like Midnight Network.

Rebrand & Website Launch

In January, we launched a new website that explains what Pelagos enables, how atomic execution works, and what can be built on top of it.

What the new site does:

Explains atomic execution clearly:

• How multichain actions are treated as single executions with one outcome

• Why this matters: no partial outcomes, no stranded funds, one auditable result

• Technical mechanism: every step evaluated upfront, commits everywhere or aborts everywhere

Shows product advantages for users and developers:

• For users: one unified balance, no bridges, no network switching, predictable settlement

• For developers: build multichain apps that behave like single-chain transactions, unified liquidity, atomic guarantees

Showcases tech and performance:

• Live testnet across Bitcoin, Sepolia, Solana, Polygon, BSC

• ~250ms block time, 100k+ TPS capability

• Parallel DAG-based consensus

Demonstrates what builders can create:

• Cross-chain DeFi (trades, liquidations, rebalances as atomic actions)

• Unified liquidity pools across chains

• High-performance appchains with shared security

• Real-time cross-chain state reactions

Features applications already built on Pelagos:

• LIQ Markets (cross-chain orderbook exchange)

• LayerCover (cross-chain insurance)

• Predicted (resolution marketplace)

Why it matters: This rebrand positions Pelagos as a leading execution layer in the web3 ecosystem. By showcasing real applications, technical capabilities, and a clear value proposition, we strengthen trust and credibility with investors, partners, developers and users. The messaging now reflects the execution-grade products we're building, setting up the stage for what we have in the pipeline for this year: protocol mainnet, flagship product launch, and major ecosystem integrations.

Our Flagship Product

As outlined in our December update, we are building a flagship product in-house to anchor Pelagos' go-to-market. January was focused on validation and execution.

This product is an AI-native platform for creating, verifying, simulating, and deploying automated trading strategies across DEXs and CEXs with enforceable policy controls. Users generate strategies via LLM, verify them deterministically against a constrained DSL, simulate outcomes, then deploy with hard constraints: loss caps, slippage limits, venue whitelists, kill switches.

Pelagos serves as the decentralized execution layer beneath the platform. Validators produce a canonical stream of attested events, execution records, state diffs, and finality signals. This removes reliance on opaque backends and enables auditable, network-driven execution.

The platform will launch first for low-latency DEX and DEX↔CEX automation, then expand into perps, non-EVM ecosystems, prediction markets, and privacy-focused environments.

Product Validation

• Over 20 calls with traders, quants, and liquidity providers to shape the MVP

• First litepaper draft prepared and being shared shortly with early users, community members, and investors

• Draft incentive and testing program prepared, with a targeted list of traders and arbitrageurs for early access

• Continued iteration with power users planned through and beyond V1

Technical Progress

MVP delivery in progress on Ethereum mainnet, major DEXs, and a first CEX integration (MEXC)

Core flow implemented:

• Strategies are created via LLM input

• Output is constrained by a verifiable DSL covering trading, arbitrage, and asset-management primitives

• Invalid strategies return compiler-style errors with fix suggestions, protecting users from incorrect logic or LLM hallucinations

Confidential execution:

• Strategy logic is encrypted and executed only inside Trusted Execution Environments (TEEs)

• One validator per TEE

• Validators participate in threshold cryptography but cannot read strategy logic in plaintext

• MVP shipped with TDH2 threshold decryption in TEE and an initial validator–TEE interface

Latency target:

• ~250ms p50 from market-relevant event to outbound transaction broadcast or CEX order request (venue confirmation handled separately)

• This enables an execution-grade loop-generate, verify, simulate, deploy with sub-second reaction times and confidential strategies that polling-based stacks cannot reliably support

The test is simple: Product-market fit will be measured by real usage and performance: if traders deploy capital, generate consistent returns, and continue using the platform, we've validated the model. If adoption or performance falls short, we'll have clear feedback loops to iterate quickly.

Midnight Network Integration

We formalized a major ecosystem partnership with Midnight Network (Cardano ecosystem). Initial scope: atomic swaps between Cardano Native Assets (ADA, CIP-26 tokens) and Midnight's native token, producing unified cross-chain execution records.

Longer-term: evaluating how Pelagos' execution model works with Midnight's privacy architecture, enabling private state transitions on Midnight to interact with external networks in a controlled, verifiable way.

Why this matters: This is our first major non-EVM integration and tests whether our execution model works across fundamentally different architectures. If successful, it validates that Pelagos can coordinate execution across any chain type, not just EVM-compatible networks.

Major Technical Milestone

We removed the last centralized component in our testnet execution flow. Outbound transactions are now signed in a decentralized way via threshold cryptography by TSS appchain, with no single party ever holding the private key.

Why this matters: This unlocks true "appchain → external chain" execution for Pelagos builders. Appchains can now trigger external actions while keeping signing decentralized and auditable at the network level. This is foundational for products like our flagship product and integrations like Midnight that require secure, decentralized outbound execution.

Team & Marketing

Team Updates

Two hires in January:

• 0xMachina, CMO - positioning, messaging, community, distribution, campaigns (led the rebrand execution)

• Camilo, Lead Designer - product and brand design end-to-end (led the website and visual identity)

Marketing

Key Wins

• Rebranded Pelagos and launched new website with clearer positioning around atomic execution

• Finalized updated messaging framework across all channels

• Established content strategy for X and blog (technical deep-dives, partner use cases, product education)

• Project visibility increased 35% month-over-month while community size remained stable indicating stronger reach and engagement quality

• Completed GTM preparation for flagship product launch

Focus for February 2026

Flagship product

• Early February: front-end MVP and closed private alpha with full DEX↔CEX strategy lifecycle

• Strategy simulation with PnL, drawdown, trade lists, and core risk metrics

• Phased security plan: threat modeling, targeted MVP review, and mainnet audit path

• By end of month: ~20 users running real strategies, expanded execution surface, and shareable performance envelopes without exposing strategy logic

Midnight & Cardano Integration

Core infrastructure:

• Integrate Midnight and Cardano as first-class data sources in Pelagos (ingestion + finality tracking) so Pelagos appchains can subscribe to Midnight intents and Cardano transactions/settlements

• Extend the external transaction signing/execution surface to support the first non-EVM targets needed for the Midnight/Cardano MVP, using the TSS appchain as the outbound signing coordinator

GTM

• Public release of our flagship product V1

• Onboard 50–100 power users

• Direct outreach to trading groups, KOLs, traders, and arbitrageurs

• Release incentives framework and referral program

What February Needs to Prove

1. Our flagship product works in production. Real users, real strategies, real money. If it works, we have a flagship product. If not, we learn what's broken.

2. Midnight integration validates the model. Can Pelagos enable meaningful interoperability between privacy-focused chains and public ecosystems? February tells us if the architecture holds across fundamentally different chain types.

3. Post-launch momentum sustains. Developer activity, partnership pipeline, and tester quality matter more than vanity metrics. We're measuring: builders shipping on testnet, partnership conversations converting, and power users entering the alpha version of our flagship product.

Useful introductions:

• Arbitrage desks

• Quant teams

• Active traders (especially CEX↔CEX)

• Teams building cross-chain products

— The Pelagos Team

As we close out 2025, we wanted to share a clear snapshot of where Pelagos stands today: what’s live, what’s working in practice, and where our focus is heading into 2026. We’ve been heads-down building for most of the year, and this update reflects what is now real in production and active testing.

Before diving in, thank you for backing us this year. We don’t take that trust lightly. We also want to wish you and your loved ones a Merry Christmas and a strong start to the New Year.

2025 Highlights at a Glance

Tech & Infrastructure

• We’ve been operating a private Kubernetes-based testnet connected to Sepolia, Polygon Amoy, BSC Testnet, and Solana Devnet.

• Current baseline performance in this environment is stable, including:

  • ~170ms median block time

  • Core production hygiene is in place: repeatable deployments, recovery testing, and monitoring and debugging workflows

Core Protocol Primitives Shipped

• Threshold Signing (TSS) baseline architecture for appchains

• A consistent Block Explorer working from local development through clustered deployments

• Indexer + query foundations, including a prototype Uniswap V2 indexer appchain and a SQL-based query layer over block data

• Avail DA integration, enabling low-latency appchains using sequencer + DA while preserving multichain access

• Early scalability work, including a sharded appchain prototype and benchmarking
  

Ecosystem Progress

LIQ Markets

• Stabilized trading flows (orders, storage, bots)

• Resolved a major storage issue

• Improved charting APIs and frontend responsiveness

• Built internal market-making and auto-trading bots to keep markets healthy

• Deployed Zealy endpoints and began structured community activation

The LIQ Markets Alpha Campaign launched with $1,200 in prizes and processed 9,000+ transactions in its first days, serving as an early stress test and UX feedback loop.

Next steps include Hyperliquid API integration at the appchain level and a mobile app, enabling users to trade perps using cross-chain balances directly on Pelagos.

Predicted

Predicted is testing atomic flows as an event-query dashboard and resolution marketplace. Outcomes are resolved using an oracle-style interaction pattern and then propagated cross-network.

Even with a simplified resolution method today, building on Pelagos preserves transparency while allowing validated outcomes to be pushed to any connected network that requires resolution services.

LayerCover

LayerCover is testing atomic flows as an insurance appchain:

• Users pay on Polygon

• Policies are attested and confirmed on Ethereum

• A $1,000 USDC cover has already been recorded with reserves on Ethereum

This demonstrates native cross-chain policy issuance without bridges or wrapped assets. We plan to run LayerCover campaigns in Q1 2026.

Community & Communications

• X grew ~23% to 2,000+ followers

• Discord grew ~30% to 2,300+ members

• Ran builder-focused sessions with LIQ Markets

• Continued long-form technical content explaining atomicity, indexing, and how partners use Pelagos in practice

These channels have increasingly become sources of early feedback and testing interest as we prepare for broader product-facing releases.

Adoption Strategy & Focus for Early 2026

Our approach to adoption is grounded in a simple belief: infrastructure gains traction fastest when it is pulled into use by real products and real workflows. Pelagos is designed for complex, automated execution, and our go-to-market strategy reflects that.

Heading into 2026, our focus spans both internally led initiatives and continued ecosystem growth, with one flagship product anchoring our GTM efforts while partners move toward broader production deployments.

Flagship Product (Preview)

As part of this direction, we’re building a flagship product entirely in-house to show what Pelagos is meant to be when it’s actually used. The goal is to make cross-chain and cross-venue trading automation usable without programming.

At a high level, the idea is simple: stop programming trading systems, describe them instead. Our flagship product compiles plain-language trading logic into deterministic, risk-bounded execution that can run across multiple blockchains and centralized venues.

Users describe arbitrage, hedging, or execution logic in plain language. Our upcoming app turns that input into a readable execution program, with execution coordinated by the network. No custom code. No infrastructure to manage. No hidden behavior.

Nothing goes live by default. Every execution program has to define its risk limits, list failure conditions, and pass simulation first. If it can’t do that, it doesn’t run. That’s how automation stays predictable and bounded when real capital is involved.

The product is built to push Pelagos’ core systems hard: execution, data access, permissions, and cross-chain coordination. A few rules shape everything:

• Execution without programming. You don’t write code. You don’t deploy services. You define what the system should do, and the result is a readable, versioned execution program you can actually inspect.

• Risk comes first. If risk isn’t defined, nothing runs. Loss limits, failure conditions, and guardrails aren’t optional and they aren’t implied.

• Deterministic execution. Pelagos coordinates reads, writes, and execution across chains and venues so behavior stays predictable and enforceable.

• AI helps, but it’s not in charge. AI is used to compile logic and analyze results. Execution itself is controlled, observable, and constrained by the system.

• Execution isn’t private by default. Programs live as shared objects. They’re evaluated on real outcomes and improved through discussion and iteration, not hidden scripts running on someone’s machine.

Internally, this product already runs across the same execution paths, indexers, and permission systems we ship as infrastructure. That’s been one of the fastest ways for us to surface real issues and tighten the core network.

We’ll share full details, technical architecture, and rollout plans in January, with a broader launch planned for February 2026.

Focus Areas for 2026

Alongside the flagship product, our focus includes:

• Expanding real-world usage through internally led products, anchored by the flagship release

• Continuing to harden core network performance and reliability as execution workloads increase

• Supporting partners as they move from testing into broader, user-facing deployments

• Preparing the network for higher throughput and more demanding execution and data workloads

We are deliberately prioritizing depth and reliability over breadth as adoption ramps, ensuring Pelagos is ready to support both internal products and ecosystem applications at scale.

Closing

Thank you again for backing Pelagos this year. We know you have many opportunities to support, and we’re committed to earning that trust through consistent execution.

We’re entering 2026 focused and energized. January will mark the introduction of the flagship trading product that now anchors our GTM strategy, alongside continued progress on the core network.

If you’d like to help, introductions are always appreciated, especially to quant and arbitrage teams, active traders, and trading-focused KOLs interested in testing what’s coming.

Our focus remains on shipping, testing, and earning adoption the hard way.

Wishing you a restful holiday break and a strong start to the year ahead.

— The Pelagos Team

The problem

A typical flow looks like this: 

• swap on one chain, 

• move funds to another, 

• then try to repay, deposit, 

• or record something on a second or third chain. 

Every jump adds latency and new reasons to fail. When a leg breaks, users get stuck, desks miss fills, and ops teams spend time fixing partial state. Bridges and generic messaging handle sending funds from A to B, but they do not guarantee that several dependent steps finish together.

What does Pelagos do?

Pelagos turns a multichain plan into a single operation with a clean, binary outcome. Either every step lands everywhere, or the plan is dropped before funds move. Targets receive native transactions; there are no wrappers to reconcile later. When the operation completes, Pelagos returns one record that ties every chain’s transaction hash together so explorers, indexers, and finance tools can match the result without guesswork.

How does it work?

Pelagos keeps a live view of connected chains by ingesting finalized headers and events. A desk, appchain, or agent submits a plan that lists the steps to run, where to run them, and in what order. Pelagos simulates the plan against the current state. If all steps are feasible, Pelagos signs and submits the native transactions to the target chains. If any check fails, Pelagos stops the plan before anything moves on Pelagos. The record that comes back links all legs in one record.

Where does it help?

Time-sensitive and correctness-sensitive tasks benefit immediately. Liquidation flows can borrow on one chain, sell on another, and repay in the same operation. RFQ and solver workflows can settle on the source chain and finish on the target without wiring a pile of adapters. Insurance and payouts can accept payment on one chain and record reserves or claims on another. Treasury teams can move collateral across chains with one instruction and book against a single receipt. Chain-abstraction backends can let users pay from anywhere and rely on Pelagos to complete the follow-up actions as native writes outside their own environment.

Why should the teams use it?

They get faster, safer completion with fewer moving parts to maintain. Sequencing and checks happen in the Pelagos lane first, so the loop is predictable and quick. If a final leg cannot post, nothing posts, which removes cleanup / ops work. Fees stay in the low single-digit basis-point range and usually beat the combined cost of spreads, relayer fees, extra gas, and failures across several hops. Integration is straightforward because partners wire once to a record-driven API instead of maintaining several bridges and per-chain adapters.

Conclusion

Pelagos ends half-finished cross-chain work. You submit one plan, it checks the live state, then either writes the required transactions on every chain or does nothing. As the number of chains grows, this all or nothing execution keeps workflows simple, fast, and auditable without bolting on more side routes.

Development (scale & DevEx): 

We implemented a basic threshold-signing (TSS) appchain architecture as the new baseline to remove single-signer bottlenecks and plug into the main transaction stack; shipped a default Block Explorer for all appchains that’s customizable (views, entities, UX) while staying consistent from local dev to production; completed Avail DA integration so low-latency appchains can use a centralized sequencer with Avail data availability and seamless multichain access; delivered the foundation for an AI-powered arbitrage and trading bot appchain where strategies are defined in a DSL that compiles to WASM and controls users’ wallet logic, enabling rich trading and solver-style strategies; and enabled SQL-based queries over block data with a prototype UniswapV2 indexer appchain that other appchains can consume as a data service for composable, queryable onchain analytics.

In December, we will take the new signing appchain flow from architectural baseline to a fully wired, testnet-ready component by integrating it into the cross-chain transaction flow on the private testnet, validating liveness and reliability of threshold signing, and ensuring end-to-end observability of signing operations; evolve the Pelagos AI-powered arbitrage and trading bot appchain from prototype to a full product with a robust strategy lifecycle (creation, deployment, upgrade), multi-strategy trading, fees and rewards, risk guardrails, and richer monitoring for live strategies on the private testnet; and deploy the indexing appchain to testnet, extending it beyond UniswapV2 to cover a wider range of DeFi primitives (DEXes, lending, LP positions, etc.) while tightly integrating it with the yield-farming appchain so strategies can consume indexed onchain data directly as a first-class input.

GTM

Pelagos is focused on three GTM pillars: shipping real cross-chain use cases with chains/foundations (especially hard-to-access ecosystems), building an in-house AI-powered arbitrage and trading bot using Web2/Web3/AI, and giving indexers clean multichain data directly from Pelagos instead of raw RPC hacks. 

On Liquid Markets, we stabilized trading (orders, storage, bots, charts) and set up a Zealy campaign; next, they’ll integrate Hyperliquid’s API and launch a mobile app for cross-chain perp trading. We’ll kick off Zealy campaigns for LayerCover once Liquid’s community activities are done.

Marketing & Growth

Launched the Liq Markets Alpha Campaign with over 9000 transactions generated on Liq Markets during the first week. Twitter grew ~23% (1300+ → 1600+). Discord grew ~23% (1700+ → 2100+). 3rd Builder’s Spaces was organized with Liq Markets. Four articles released expanding on the possibilities and use cases of Pelagos. Our Founding Engineer, Krishna joined ZyptoApp’s Spaces talking about centralized platforms.

What was shipped in November (Product & Technical Development)

TSS Appchain: The new architecture baseline
Implemented a basic version of the new threshold-signing (TSS) appchain architecture. This is the foundation for removing single-signer bottlenecks and will evolve into the new TSS appchain flow integrated into the main transaction stack.

Block Explorer for every appchain, from local to cluster
Shipped a Block Explorer that now runs by default in the local development environment for all appchains. Each appchain can customize its explorer (views, entities, UX) while keeping a consistent experience from laptop to production clusters.

Avail DA integration completed
Completed Avail DA integration so appchains that require minimal latency can leverage a centralized sequencer while simultaneously benefiting from Avail data availability and seamless access to multichain infrastructure.

AI-powered arbitrage and trading bot appchain foundation with DSL
Delivered a baseline implementation of the arbitrage & trading appchain. We have developed the flow, initial DSL specs, and first successful strategies. Formalized the DSL spec (EBNF) and a strongly-typed runtime module exposing 11 core primitives (sources, indices, triggers, batches, simulation, risk, etc.), enabling composition without touching WASM directly while keeping safety. On the platform, strategies can now be created via a DSL that compiles to WASM code controlling a user’s wallet management logic. This forms a strong base for trading use cases and custom solver-style strategies.

SQL-powered data access & UniswapV2 indexer appchain prototype
Enabled appchains to run SQL queries over block data, and built a prototype indexer appchain for UniswapV2 contracts. Any appchain can connect to this indexer chain and consume its onchain data as a service, unlocking composable, queryable onchain analytics.

Near-term roadmap  (Product & Technical Development)

New signing appchain flow: Testnet-ready & integrated
Take the new signing appchain flow from architectural baseline to a fully wired, testnet-ready component: integrate it into the cross-chain transaction flow on the private testnet, validate liveness and reliability of threshold signing, and ensure end-to-end observability for signing operations.

Full-featured Pelagos AI-powered arbitrage and trading bot appchain
Evolve the current prototype into a complete arbitrage & trading bot appchain: robust strategy lifecycle (creation, deployment, upgrade), multi-strategy trading, fees and rewards, risk guardrails, and richer monitoring for live strategies running on the private testnet. We will share the specs shortly in our documentation.

Indexing appchain on testnet with richer DeFi coverage & yield integration
Deploy the indexing appchain to the testnet and extend it beyond UniswapV2 to cover more DeFi primitives (DEXes, lending, LP positions, etc.). Integrate the indexing appchain tightly with the yield-farming appchain so strategies can consume onchain indexed data directly as a first-class input.

Go-to-market

For Pelagos, the GTM focus is currently three items that we have been pushing internally. 

First, we work with chains and foundations where we can ship concrete use cases that depict the advantages of Pelagos, with a preference for ecosystems that are hard to access today and where Pelagos’ cross-chain execution actually fixes something real. 

Second, we are building our own AI-powered arbitrage and trading bot that looks for cross-chain arbitrage opportunities, and we have already been talking with a bunch of traders who want to run it. We combine Web2, Web3, and AI, unlocking trading, arbitrage (within Web2, within Web3, and between Web2 and Web3), intents, and strategy automation for all blockchain users, including advanced DeFi traders, quant teams, and power users, without being tied to a single platform: Ethereum, Base, Bitcoin, Solana, and any other networks. The traders will be able to build their own strategies using ChatGPT-style frontend and run those strategies. A user chats with LLM and creates a new strategy described in human-readable format of DSL (domain specific language). In addition, there will be a leaderboard for the strategies and based on the PnL and other metrics, users can decide to allocate their funds to those specific strategies. 

Third, we are working with indexers to give them access to proper multichain data. Pelagos already sits in the middle, watching many chains, tracking their finality, and only committing a cross-chain flow when every leg is valid. That means Pelagos is already holding a version of reality that is cleaner than what indexers can reconstruct from raw RPCs. Pelagos puts applications’ and users’ indexers into the same process, eliminating any latency or inconsistencies. So instead of every indexer reinventing multichain logic, Pelagos can just hand it to them. We are in the midst of signing agreements with these partners and, as soon as they are signed, we will disclose the names.

On Liquid Markets, the following items have been worked on this month:

• Stabilized the platform for different operations such as limit orders and market orders, where block production was previously stopped because of insufficient balance.

• Fixed a major storage issue to decrease the storage of unnecessary metadata.

• Built market-making and auto-trading bots that keep the order book filled and, at regular intervals, execute market/limit orders on either side.

• Fixed charting APIs and the frontend.

• Deployed Zealy endpoints for quests (launching a Zealy campaign with them).

Going forward, they will be integrating Hyperliquid APIs at the appchain level and building a mobile app for Liquid Markets, which will allow users to trade existing perps using cross-chain balances on Pelagos. For LayerCover, we will kick off Zealy campaigns upon completion of community activities on Liquid Markets.

Growth & Marketing

This month started Liq Markets Alpha Campaign with $1200 in prizes for our Alpha testers, which will last four weeks. The aim of the campaign is to gather the feedback from the community on current UX, stress-test the platform and gather the information for improvements. In the first 4 days upon activation, Liq Markets handled over 9000 transactions so far.

On the Social Media side: We grew X following by ~23%, increasing total follower number to >1600 and Discord channel grew by ~23% making it total of 2100 members.

From the PR perspective, our Founding Engineer, Krishna, participated and has been a guest at ZyptoApp’s X Spaces talking about centralized platforms, and we organized Builder’s Spaces with Liq Markets to talk more about current status of the development and what’s coming next.

Content wise, we released four articles, expanding on possibilities and use-cases of Pelagos:

- True Risk-minimized Atomicity

- From Oracle-Centric to Chain-Centric: Pelagos’ Model for Data

- Pelagos as the Single Source of Truth for Indexers

- One Swap Across Every Chain

Conclusion

November was about laying real infrastructure and lining it up with GTM. We shipped the TSS appchain baseline, per-appchain Block Explorers, Avail DA integration, the foundation for an AI-powered arbitrage and trading bot appchain, and SQL-based data access with a UniswapV2 indexer prototype. Next, we’re making the new signing flow fully testnet-ready, turning the arbitrage and trading bot into a full product (strategy lifecycle, fees, risk, monitoring), and rolling out a richer indexing appchain tightly integrated with yield strategies.

On GTM, we’re focusing on concrete use cases with chains/foundations, our own AI-powered arbitrage and trading bot for traders with a performance-based leaderboard, and indexer partnerships that plug into Pelagos’ cleaner multichain data. Liquid Markets stabilized core trading, reduced storage bloat, added MM/auto-trading bots, fixed charting, set up Zealy quests, and is now moving to Hyperliquid’s API integration, a mobile app, and LayerCover campaigns.

Growth continues started stong: Liq Markets Alpha Campaign with over 9000 transactions generated on Liq Markets during the first week. X and Discord grew ~23%. 3rd Builder’s Spaces was organized with Liq Markets. Four articles released expanding on possibilities and use-cases of Pelagos. Our Founding Engineer Krishna joined ZyptoApp’s Spaces talking about centralized platforms. 

Atomicity isn’t a buzzword. It’s a promise that either the whole transaction plan lands, or nothing moves. No promises of reconciliation later, no funds stuck between chains. You fix the legs up front, you check live balances, approvals, prices, and timing. If every check passes, you commit and post on each chain and if one thing is off, you stop before a single asset leaves. When it’s done, there’s one receipt tying every tx hash together so ops and finance don’t have to guess. That’s what we call all or nothing.

Current state

Most cross-chain flows are split into separate steps. You swap on one chain, move funds with a bridge, then try to finish on another chain. If the price shifts, an approval is stale, or a chain stalls, the flow breaks and funds sit in the wrong place. Someone has to interfere and fix it manually at times, which makes it unreliable and costly.

Real atomicity

Atomicity has to cover the whole operation. If the plan has four steps across three chains, success means you can point to four transaction hashes on those chains. If any step can’t go through, nothing is sent; so either it’s final everywhere, or it never starts.

Send one instruction with every step mentioned and the system checks live chain state including balances, approvals, nonces, liquidity, fees, timing. If a single check fails, nothing starts; while if everything checks out, it fires the native transactions on each chain and waits for finality. At the end you get one record with the tx hashes for every leg without partials and stuck funds.

You borrow on chain A, sell on chain B, and repay in the same operation. If the repayments cannot finalize, nothing happens.

For RFQ and solver flows, you settle the user on the source chain and in the same operation you perform the deposit or repayment on the target.

You can shift collateral across several chains with one instruction and you receive a single record with the hashes from each chain. Each case either completes end to end or does not start.

What doesn’t qualify as atomicity

• Bridge now, finish later.

• Mint a wrapped token and call it done.

• Send a message and hope the other side executes.

• Promise reimbursement if it breaks.

• And many more examples

The simple rules of atomicity

• Binary outcome: all legs commit, or none.

• Native writes: targets see real transactions on their chains.

• Pre-checks: simulate everything before touching funds.

• Coordinated commit: one commit and either everything goes or nothing does.

• Records: a single, auditable record binding every leg.

The ‘atomic’ point

Real atomicity means one operation that either completes on every chain with native transactions or does not run. The system checks the entire plan against the live state before sending anything. On success you get a single receipt that links all transaction hashes across chains. If a system cannot guarantee this behavior, it is not atomic.

Join here: https://zealy.io/cw/pelagos/questboard/df16a45c-38a1-479b-a1c8-9515723d44cb

Alright, this is actually happening. After months of building Pelagos infrastructure, we finally have our first dApp to show you. And here's the cool part - we're running a $1,200 testing campaign over four weeks, and you get to be among the first to try it.

What is Liq Markets?

LIQ Markets is the first orderbook that executes trades atomically across multiple blockchains without bridges or wrapped tokens. When you place an order, Pelagos simulates all legs across chains and either co-signs native transactions on every chain simultaneously or cancels entirely - no partial fills, no bridge risk.

The Liq Markets delivers CEX-grade features including millisecond cancel/replace, deterministic queues, MEV protection, and sub-second order acceptance while letting traders keep collateral on their preferred chains. Your BTC on Chain A can fund perps on Chain B with settlement on Chain C, all in one click.

Why This Matters for Pelagos

We built Pelagos to be the universal execution layer - infrastructure that lets developers create applications that work across all chains and L2s. Liq Markets is the first real validation of this vision.

When independent developers choose your infrastructure to build something this ambitious, it means:

• The technology actually works

• The developer experience is solid

• The infrastructure can handle production applications

• Real innovation is possible on the platform

Join the Alpha Campaign

Ready to test the first dApp on Pelagos? Head to our Zealy campaign:

🚀 Join the Campaign Here

This link takes you directly to our testing campaign, where you'll help validate both Liq Markets and the Pelagos infrastructure powering it.

The Testing Campaign: $1,200 Over Four Weeks

We're coordinating with the Liq Markets team to run systematic testing:

Campaign Timeline:

• Start: Every Monday 9:00 AM GMT

• Week 1 Snapshot: Sunday 23:59:59 GMT - $300 distribution

• Week 2 Snapshot: Following Sunday 23:59:59 GMT - $300 distribution

• Week 3 Snapshot: Following Sunday 23:59:59 GMT - $300 distribution

• Week 4 Snapshot: Final Sunday 23:59:59 GMT - $300 distribution

WEEK 1 REWARDS - $300 POOL

• 30 spots available

• $10 per qualified tester

• Simple quest: Faucet testing + Order placement

• Perfect for beginners

Weekly snapshots mean weekly rewards. Jump in any week and earn your share.

What You'll Be Testing

The Liq Markets team has set specific parameters for this alpha test:

Daily Quest:

• Request testnet tokens from faucet (once per day)

Trading on Liq Markets:

• Place a Limit Buy order: 0.01-0.05 BTC

• Place a Limit Sell order: 0.01-0.05 BTC

• Execute a Market Buy order: 0.01-0.05 BTC

• Execute a Market Sell order: 0.01-0.05 BTC

These controlled tests help both the Liq Markets team and Pelagos understand:

• How the orderbook performs under normal conditions

• Where users experience friction

• How cross-chain settlement handles sustained load

• What improvements are needed before scaling

Important Testing Guidelines

Respect the Limits The Liq Markets team set specific parameters for good reasons:

• Faucet: Once per day (ensures everyone gets tokens)

• Orders: 0.01-0.05 BTC (maintains accessible testing)

• No spam or stress testing (that comes later)

Document Issues Found a bug in Liq Markets? UI confusing? Something not working? Document it. The team needs this feedback to improve before broader release.

Two Products, One Test Remember you're testing both Liq Markets (the dApp) and Pelagos (the infra). Issues could come from either layer, and both teams need your feedback.

Pro Tips for Maximum Rewards

Be Consistent Daily participation beats sporadic bursts. The Liq Markets team values reliable testers who provide steady data.

Engage with Both Communities Join both Pelagos and Liq Markets Discord servers. Each provides different insights and support.

Think Like a User You're not just testing technical functions. How does it feel to trade? What's confusing? What's surprisingly smooth? This feedback is golden.

Watch for Patterns If something fails repeatedly at certain times or under certain conditions, that's valuable data. Document patterns, not just individual incidents.

Security Reminders

• This is testnet - tokens have no value

• Only use testnet wallets

• Access Liq Markets only through official channels

• Never share private keys

Why This Is Actually Cool

Look, we could hype this up with revolutionary language, but here's the reality: a team of developers looked at Pelagos, understood what it could do, and built something that shouldn't be possible - direct Bitcoin to USDT trading without bridges, solvers, intents or gossip.

Now we need you to test it. Not break it (save that for later), but use it as intended and help both teams understand what works, what doesn't, and what needs improvement.

Campaign starts Monday 9:00 AM GMT
Join at: https://zealy.io/cw/pelagos/questboard/df16a45c-38a1-479b-a1c8-9515723d44cb
Weekly rewards: $300
Total pool: $1,200

This is the beginning of the Pelagos ecosystem. Liq Markets is just the first dApp. By testing it, you're helping validate not just one application, but an entire platform where developers can build the impossible.

Set your alarms for Monday. Prepare your testnet wallet. Join us in testing the first dApp on Pelagos and earning your share of $1,200 while you do it.

See you on Liq Markets. Let's prove that native cross-chain trading without bridges, solvers, intents is here.

But on Pelagos, it doesn’t work like that.

She opens her wallet, selects “Swap ETH to USDC,” hits “confirm”, and in less than a second, her ETH on Appchain 1 is gone, and her USDC appears on Appchain 2. No bridges. No solver. No waiting for a confirmation. Just done.

What actually happened behind the curtains

The moment Alice hit “confirm”, her ETH was locked inside the Appchain 1 Treasury, a contract backed by real ETH on Ethereum. At that same instant, every Pelagos validator saw that lock event. There’s no leader collecting blocks as all of them move in sync, inside a universal DAG sequencer.

Within a single round, about 400 milliseconds, the event is finalized, and ETH appears in Alice’s account on Appchain 1. She’s still in the same wallet, but she’s already in a different universe.

Now the DAG picks up her swap order. An Uniswap-style pool (running on another Pelagos appchain, let’s call it App-Uniswap) sees the incoming trade. The system simulates it across chains, checks if there’s enough liquidity, and only then commits. If it clears, USDC lands in her account on Appchain 2. If something fails, a slippage check, a pool limit, whatever, the entire thing rolls back, and her xETH unlocks instantly. That’s the atomicity promise: either everything happens, or nothing does.

To Alice, it felt like one click. To the network, it was a dozen coordinated acts, which were observed, agreed, and executed everywhere at once.

When the destination Is Ethereum itself

Suppose Alice wanted to go back to Ethereum instead. It still feels the same. She locks her ETH on Appchain 1, and Pelagos orchestrates the rest: validators finalize the event, trigger a TSS signature on Ethereum, unlock her ETH, and even handle gas through account abstraction. The ETH moves. The Uniswap swap happens on Ethereum. The result leads to USDC in her address.

Why does it work?

Because Pelagos doesn’t treat chains as different worlds. Every validator runs the same leaderless DAG, watching all appchains at once. A lock on Appchain 1 and a swap on Appchain 2 don’t live on different timelines, as they’re part of the same block-free event flow.

This DAG layer gives Pelagos what bridges never could:

• Instant finality (no waiting, no reorg risk)

• Native composition (cross-chain actions in one round)

• Scalability through sharding (each appchain can run as a microservice)

And under that DAG sits the Multichain Layer, a live feed of finalized blocks from Ethereum, Solana, and others. It reads events directly from those networks, validates receipts, and ensures external actions happen exactly once.

Reactive contracts listen to those receipts. As soon as one lands, they wake up automatically — no extra transactions, no manual claiming.

Tokens like ETH and USDC stay 1-for-1 backed on their source chains. Unlocking them takes one threshold-signature transaction. No bridges. No custodians. Just liquidity that can move anywhere.

And If the Target Is Solana?

The swap can match against an intent on Solana, or use an Appchain treasury that spans both ecosystems. Pelagos simply runs the external leg. From Alice’s view, nothing changes. From the system’s view, it’s just another plan, one that spans Ethereum and Solana and still settles atomically.

Conclusion

Pelagos makes the multichain world feel like one chain. There’s no “wait for bridge confirmation.” No wrapped assets. No retry buttons. It’s one DAG, one set of validators, one atomic commit across everything, Ethereum, Solana, L2s, and Pelagos appchains.

For Alice, it’s a button that just works. For everyone else, it’s the end of fragmented liquidity.

One signature. One plan. Native everywhere, or nothing moves.

Want to partner with us?

If you're a developer interested in building on Pelagos or a potential validator, we'd love to hear from you.

Let’s keep in touch

Join our community

• Visit our Website

• Join our Discord

• Follow us on X

• Email: contact@pelagos.network

Pelagos is built around a different assumption: the execution layer already has visibility into the external chains you connect. If the data is already on a chain Pelagos ingests, you do not need a second network to repeat it as you read the source directly, inside the same deterministic block. That is the core design difference.

What do today's oracles actually provide?

Chainlink: big, battle-tested network that aggregates off-chain and multi-exchange data and writes it to on-chain reference contracts. Most chains rely on this because they can’t fetch/aggregate themselves.

Pyth: low-latency, publisher-heavy model that pushes prices and broadcasts them to many chains. Good for fast DeFi dApps / use cases that need continuous updates. 

RedStone: modular oracle that can do push or pull, lives on numerous chains, and is very good at adding long-tail assets (LSTs, LRTs, RWAs) quickly. They explicitly state that they secure price feeds for any asset, on any chain and support on-demand delivery.

API3 / Airnode: the API provider itself can publish on-chain, removing middlemen

Chainlink CCIP: shows oracles also stepped into cross-chain messaging because chains are siloed.

Current oracles exist to make data available on chains that cannot see it, and distribute the same data to many chains.

What does Pelagos change?

Pelagos already ingests the state/events of the chains it connects to. If a price/feed/state variable is on Ethereum, on an L2, or on an oracle’s own chain that Pelagos tracks, an appchain can read it directly in-transaction, aggregate it with other sources, and settle atomically on Pelagos. That removes the mandatory oracle hop for on-chain data. The latency here is 400-500 ms for cross-reads, which is in the same window in which Pyth advertises its update cadence, so one is not losing timeliness.

The six usage patterns on Pelagos

**Direct cross-chain read (oracle-less path).** Appchain asks Pelagos for a value that already exists on another chain (for example, a Chainlink reference contract on Ethereum, or a pool balance on an L2). Pelagos has that state; the appchain uses it in the same block. No external oracle call is needed.

Read existing on-chain oracle feeds. Chainlink, Pyth, and API3 all end up writing on-chain. Pelagos can read those chains once and make the data available to every Pelagos appchain. This keeps the oracle’s infrastructure intact but removes the need for 10+ separate deployments. 

Plug the oracle’s own chain. Pyth maintains its own low-latency network and then broadcasts to other chains. Pelagos can treat that network as just another client chain: ingest it once, expose it everywhere. 

External request/response. For oracles that operate on a pull model, an appchain emits a request, the oracle responds, and Pelagos turns the response into a transaction. You keep compatibility without changing the core.

Oracle-as-Appchain on Pelagos. Following the API3 “first-party” idea, an oracle provider can run its own Pelagos appchain, have publishers post data there, and every other appchain simply cross-reads. Pelagos becomes the distribution plane and the oracle logic stays with the data owner.

Deterministic HTTP fetch. Pelagos can add a controlled external-fetch transaction: validators fetch a URL, apply a deterministic aggregation function, and commit the result. This is the proper way to bring in data that never touches a blockchain, but it needs security and compliance hardening first.

Where Pelagos shines

If you need a value that already lives on a chain you index, Pelagos reads the source; no separate oracle network is required. That includes reading Chainlink reference contracts, Pyth prices that are already bridged to an EVM, and on-chain pool/state data. 

For real-world, off-chain, private, or paywalled data you still need publishers/oracle operators.

For example, Pelagos can consume public CEX market data (order books, trades) from Binance, Coinbase, and Kraken, combine it with on-chain DEX pool, compute a VWAP/TWAP with outlier controls, and then execute trades or liquidations atomically in the same block without standing up a separate oracle deployment. Practically, you either run a small oracle-as-appchain that pulls those feeds and publishes signed ticks, or use Pelagos’ deterministic HTTP-fetch pattern so validators fetch the same endpoints in parallel and aggregate deterministically. Because Chainlink, Pyth, and RedStone already publish data on-chain or via their own networks, Pelagos can also cross-read those sources once and fan them out to every appchain, avoiding per-appchain redeployments.

For broader finance, Pelagos can ingest licensed FX/equity/macro APIs, publish signed values to an oracle-as-appchain, and let RWA or risk engines act with the same atomicity guarantees. On top, you can publish short-horizon on-chain price predictions by running a deterministic model that consumes these features plus live CEX/DEX signals and writes each block. For data that already lives on a chain or an oracle network, Pelagos replaces the mandatory oracle hop with direct cross-reads. For off-chain data, Pelagos standardizes ingestion and distribution via first-party publishers

Relation to CCIP-style designs

Chainlink CCIP exists because most chains cannot safely move messages/tokens across domains; the oracle network becomes the trusted courier. Pelagos’ premise is that cross-chain execution and state access are native, so the oracle can go back to being just a data source.

Pelagos security angle

If the price is on a chain, Pelagos reads the chain. It doesn’t trust a third party to repeat. Delivery happens via the same consensus/sequencing that runs the appchain and there is no “oracle went down so DeFi died.” For off-chain stuff, we force multiple validators to fetch and aggregate with the same idea as first-party oracles but baked into Pelagos.

Conclusion

Pelagos makes the need to deploy an oracle to every chain / app pattern mostly obsolete for onchain data. Chainlink, Pyth, RedStone, and API3 all end up putting data somewhere onchain or in a network that can be read; Pelagos’ whole design is already ingesting those chains/networks and can execute atomically, so for prices and state that already exist on Ethereum, L2s, or an oracle’s own chain, Pelagos can just cross-read and use it in the same block. That shrinks oracles back to where they actually add value: publishing data that does not exist on any chain (RWAs, FX from banks, private APIs), or running their own economics. For that leftover part, Pelagos can host the oracle as an appchain and fan it out to every other appchain, giving the oracle distribution without 20 redeployments. So oracles don’t disappear, but they stop being mandatory middleware and Pelagos turns them into optional, standardized data sources in a multichain execution layer.

Want to partner with us?

If you're a developer interested in building on Pelagos or a potential validator, we'd love to hear from you.

Check our partnership deck or fill out our BD form

Join our community

• Visit our Website

• Join our Discord

• Follow us on X

• Email: contact@pelagos.network

Pelagos already sits in the middle, watching many chains, tracking their finality, and only committing a cross-chain flow when every leg is valid. That means Pelagos is already holding a version of reality that’s cleaner than what indexers can reconstruct from raw RPCs. Pelagos puts applications and users’ indexers into the same process, eliminating any latency or inconsistencies.

So instead of every indexer reinventing multichain logic, Pelagos can just hand it to them.

What Pelagos actually has that indexers don’t

Pelagos does three important things:

1. It correlates events across chains. If a user starts something on Ethereum and it finishes on an L2 and then pushes a transfer to Solana, Pelagos knows those are one flow, not three unrelated transactions.

2. It knows finality. Pelagos tracks how long to wait for each chain.

3. It knows the outcome. Pelagos can say “this flow committed” or “this aborted because leg 3 failed.” That’s huge because most indexers only see the successful legs on the destination chain and don’t even know something failed.

This is exactly the information indexers struggle to derive.

Example: cross-chain swap

User swaps on Ethereum, settlement happens on Arbitrum.

Without Pelagos

The indexer has to:

• watch Ethereum for swap/start event,

• watch Arbitrum for some bridge/mint/settlement,

• match them based on address, timestamp, maybe a memo,

• pray there’s no delay or reorg,

• and maybe fail to match if the dApp changed its pattern.

With Pelagos

Pelagos emits: “bundle started on Ethereum, settled on Arbitrum, all legs committed.”Indexer ingests one record and knows it’s the same operation. No guessing.

Example: cross-chain liquidation

A lending protocol integrated with Pelagos can trigger a liquidation on chain A and settle collateral on chain B in one atomic flow.

Indexers hate this kind of thing because it looks like two unrelated onchain actions. On chain A: liquidation. On chain B: transfer. Different blocks, different chains, maybe different timing.

Pelagos can emit:

• Bundle_id

• reason: liquidation

• leg 1: liquidation on Base

• leg 2: collateral payout on Ethereum

• status: committed

Now an indexer can build a “multichain liquidation dashboard” without doing dark magic.

Snapshots and resyncs

Big indexers sometimes need to rebuild: new schema, new feature, new chain. Replaying 10 chains from genesis is expensive.

Pelagos can serve immutable snapshots of its multichain view: “here is the state as of block X / slot Y / bundle Z.” Then it can serve a delta stream “all changes since bundle Z.”

Indexer flow becomes:

• download snapshot

• store it

• start consuming deltas

What indexers can actually build with this

• All your wallets across chains view that isn’t lying

• Real cross-chain volume charts

• All aborted bundles and which chain caused it

• All cross-chain liquidations for protocol Y

• Time-to-finality per chain in the real world

That last one is actually useful for infra teams.

Why this helps Pelagos too

If explorers, dashboards, analytics tools, custodians, even wallets start taking Pelagos’ feed, then Pelagos becomes the reference for what actually happened across chains. That locks in Pelagos as infrastructure, not just “another cross-chain thing.”

Conclusion

Pelagos already knows what happened across chains. Indexers don’t. If Pelagos publishes that view, i.e., bundles, legs, status, finality-safe events, snapshots, indexers can stop guessing and just store it. That makes explorers, dashboards, and analytics line up with reality instead of half-merged data from five RPCs.

Once a few indexers use Pelagos as their multichain source, the rest will follow, because nobody wants to maintain 10 different finality paths and brittle cross-chain matching when there’s a single place that already did it.

Development (scale & DevEx):

In October we shipped epoch-based consensus with validator rotation on testnet, hardened resilience via cluster-level chaos testing, enabled end-to-end cross-chain flows with a Solana (SVM) read/send path, began Avail integration testing for lower latency, implemented a minimal signer service for EVM/SVM, and launched a private Kubernetes testnet linked to Sepolia, Polygon Amoy, BSC testnet, and Solana devnet, hitting ~170 ms median block time and ~600 ms median external-block processing latency.

In November, we’re shipping a local-to-prod block explorer, standing up a TSS appchain to remove single-signer bottlenecks, use the Pelagos AI yield-farming appchain on real workloads to validate end-to-end execution, releasing Avail DA integration for minimal-latency appchains with centralized sequencing + DA, and polishing DevUX (templates, CLI, clearer errors, docs/tutorials) to take teams from zero to first appchain fast.

GTM

Multiple dApps are already testing the atomic flows.

LIQ Markets: atomic cross-chain DEX aggregator sourcing via OpenOcean;

Predicted: event-query dashboard + oracle-style resolutions propagated cross-network;

LayerCover: insurance coverage appchain.

Marketing & Growth

Twitter grew ~30% (1000+ → 1300+). Discord grew ~15% (1500+ → 1,700+). Created a YouTube channel. Nicky has been interviewed by the Mpost and has been a guest at Indexing Co’s latest podcast. We also made and shared demos of the dApps building on Pelagos, such as Liq Markets, LayerCover and Predicted. Nicky’s speech at ETH Istanbul also came out.

Hiring

In October, Konstantin Kalinovsky joined as Frontend Engineer (11+ years; blockchain integrations, wallets, DeFi UX), leading frontend architecture, component system, and performance hardening.

What was shipped in October (Product & Technical Development)

Consensus & Core Protocol

Epoch-based consensus/validator rotation: Completed and running in testnet.

Resilience & Infrastructure Hardening

Chaos and stability testing: Ran cluster-level chaos experiments emulating full/partial network loss and unexpected node crashes with subsequent automated recovery; validated stability characteristics.

Cross-Chain & Interoperability

Solana integration: Implemented read and send transaction flows (SVM).

External transaction flow: Working end-to-end submission from appchains to external chains via the cluster.

Avail integration

We are testing our integration with Avail, which allows us to reach minimized latency for our appchains.

Transaction Submission

Minimal signer service: Implemented for EVM and SVM paths to sign and submit external transactions in testnet.

Testnet Operations

Private testnet launch: Deployed in a Kubernetes cluster (internal access) that connected to sepolia, amoy, bsc testnet, solana devnet. Foundation for appchain testing and cross-chain flows.

• Median block time: ~170 ms.

• Median external block processing latency: ~600 ms (from node receiving an external block to the block being processed on the appchain).

Near-term roadmap (November - Product & Technical Development)

Block Explorer

Ship a block explorer that runs in local development and for deployed appchains, providing consistent transparency and debugging/observability from laptop to production.

TSS Appchain

Stand up a threshold-signing appchain integrated into the transaction flow to remove single-signer bottlenecks and improve security and liveness for cross-chain operations.

Pelagos AI Yield-Farming Appchain

Run the Pelagos AI yield-farming appchain end-to-end on the private testnet—execute real cross-chain strategies and messaging, let live workloads surface bottlenecks, and turn those findings into concrete UX, reliability, and operational improvements.

Avail Integration

Release Avail data-availability integration so appchains that need minimal latency can leverage a centralized sequencer while simultaneously benefiting from DA and seamless access to multichain infrastructure.

DevUX Improvements

Streamline the developer journey from zero to first appchain with templates, CLI ergonomics, clearer errors, and focused docs/tutorials so teams can ship faster with predictable local-to-cluster workflows.

Go-to-market (integrations)

Multiple dApps have already shipped and extended novel functionality on Pelagos in preparations for permissioned testnet.

LIQ Markets: https://testnet.liq.markets

On top of its unified order book, LIQ is implementing an atomic cross-chain DEX aggregator on Pelagos. Users can swap across chains with full atomicity; the frontend aggregates liquidity from existing DEXs via third-party aggregators (e.g., OpenOcean).

Predicted (Resolution Marketplace): https://predicted-appchain.replit.app/

Delivered an event-query dashboard that external parties can treat as a source of truth. Partners can interact with Predicted’s contract in an oracle-style pattern to resolve prediction events. While Predicted uses a simplified resolution method, building on Pelagos preserves transparency and propagates validated outcomes to any connected network that requires resolution services.

LayerCover: https://app.layercover.com/markets

Deployed a dedicated appchain on Pelagos for purchasing insurance policies. Example flow: Alice buys cover and pays USDC on Polygon; Pelagos attests and confirms the purchase on Ethereum; the appchain records that Alice bought $1,000 USDC of cover on Polygon while reserving assets on Ethereum. This enables native, cross-chain policy issuance and reserve accounting without bridges or wrapped assets.

Growth & Marketing

This month, we continued with the OG campaign and are currently preparing for activations for Liq Markets and LayerCover. X following grew by ~30%, increasing the total follower number to >1300 and the Discord channel grew by ~15% bringing it total to ~1700 members.

From the PR perspective, Nicky has been interviewed by Mpost and has been a guest on the latest Indexing Co’s podcast episode. Her full speech during ETH Istanbul has been posted and can be watched here.

Considering the finalization of Liq Markets and LayerCover and before people can start using the dApps and activity campaigns around them, we released the demos to showcase some of their capabilities and advantages they gained using Pelagos:

• Watch Liq Markets demo here

• Watch LayerCover demo here

• Watch Predicted demo here

We released an article Pelagos Atomicity vs Intents to further differentiate the two and to show why Pelagos is the better solution for dApps building cross-chain.

Hiring

In October, we strengthened the team with two key hires. Konstantin Kalinovsky joins as Frontend Engineer, bringing 11+ years of experience with a focus on blockchain integrations, crypto wallets, and DeFi UX.

Conclusion

October delivered working fundamentals and usage: epoch-based consensus with validator rotation is live on testnet; the cluster passed chaos tests and self-recovered; Solana read/send and end-to-end external submissions are running; a minimal signer pushes EVM and SVM transactions. The private Kubernetes testnet links Sepolia, Polygon Amoy, BSC testnet, and Solana devnet, with ~170 ms median block time and ~600 ms external-block processing latency.

On top, dapps are active: LIQ Markets is adding an atomic cross-chain DEX aggregator on a unified book, Predicted published a resolution dashboard used as source of truth, and LayerCover issued native cross-chain cover without bridges or wrappers. Marketing and growth moved: OG campaign continued, X followers rose ~30% to >1,300, Discord grew ~15% to ~1,700, demo videos shipped, the “Atomicity vs Intents” article went live, and PR included an Mpost interview, Indexing Co podcast, and the ETH Istanbul talk.

Hiring added Konstantin Kalinovsky (frontend, 11+ years) to accelerate UX and delivery.

November focuses on making this production-ready and safer: a block explorer with the same experience from laptop to cluster, a TSS appchain to remove single-signer bottlenecks and improve liveness, pressure-testing real strategies by running the Pelagos AI yield-farming appchain under production-like load, the Avail DA integration for low-latency appchains using a centralized sequencer with DA, and DevUX upgrades across templates, CLI, errors, and docs so teams go from zero to first appchain quickly.

This distinction isn't merely academic. For developers building the next generation of DeFi protocols, the choice between intents and atomicity determines everything from user experience to risk management, from capital efficiency to composability. Let's explore why atomic execution represents the superior path forward for serious cross-chain applications.

Understanding Intent-Based Networks

Intent-based systems operate on a marketplace model. Users express their desired outcomes -"swap X for Y at the best price", and a network of solvers, fillers, or relayers compete to fulfill these requests.

The intent is broadcast, solvers submit bids or solutions, and eventually, one executes the user's request. This approach offers flexibility and can aggregate liquidity across multiple sources. However, it introduces several critical limitations:

The Promise Without the Guarantee

Intent networks fundamentally operate on best-effort execution. While sophisticated matching algorithms and reputation systems improve success rates, they cannot guarantee:

• Simultaneous execution across multiple chains

• All-or-nothing settlement for complex operations

• Deterministic outcomes before execution begins

• Protection against partial failures mid-transaction

When a perpetual DEX needs to atomically update margin across chains, or a liquidation protocol must ensure collateral sale and debt repayment happen together, "best effort" isn't enough.

The Hidden Complexity

Intent systems push complexity to the solver layer, creating:

• Solver centralization risks as sophisticated actors dominate

• Information asymmetry where users can't verify optimal execution

• Race conditions between competing solvers

• Trust dependencies on solver reputation and behavior

The Atomic Execution

In contrast, atomic execution frameworks like Pelagos treat cross-chain operations as indivisible units. Either all components of a transaction succeed together, or everything reverts cleanly. In short, it’s enforced cryptographically at the protocol level.

Cryptographic Guarantees, Not Market Promises

Atomic systems leverage:

• Threshold Signature Schemes (TSS) for native transaction authorization

• Directed Acyclic Graph (DAG) consensus for instant finality

• Deterministic sequencing ensuring order and causality

• Cryptographic proofs validating complete execution

When Pelagos processes a cross-chain swap, the protocol doesn't hope solvers will execute correctly - it cryptographically ensures atomic settlement across all involved chains within a single ~400ms block.

True Composability

Atomicity enables genuine composability that intent systems cannot match:

Atomicity enables genuine composability that intent systems cannot match: Traditional Intent Flow:

1. Submit intent for cross-chain swap

2. Wait for solver discovery and bidding

3. Hope solver executes all legs correctly

4. Handle failures manually if partial execution occurs

Atomic Execution Flow:

1. Submit atomic bundle with all operations

2. Protocol validates and simulates complete execution

3. All operations execute simultaneously or revert entirely

4. Guaranteed state consistency across all chains

Real-World Implications

The difference between intents and atomicity becomes stark in production scenarios:

Cross-Chain Perpetual Trading

Intent-Based Approach:

• Trader submits intent to move margin from Ethereum to Solana

• Solver attempts to execute but Solana transaction fails

• Ethereum funds are locked, position under-margined

• Manual intervention required, potential liquidation

Atomic Approach:

• Single atomic bundle handles margin movement

• Protocol ensures both legs execute or neither does

• Position remains safe throughout

• Sub-second complete execution

Omnichain Liquidations

Intent-Based Approach:

• Submit intent to liquidate position across multiple venues

• Different solvers handle different chains

• Partial liquidation leaves toxic positions

• Cascading failures possible

Atomic Approach:

• Atomic bundle orchestrates complete liquidation

• Collateral sale, debt repayment, and fee distribution happen together

• No partial states or stranded capital

• Complete execution in one block

Multi-Chain Yield Optimization

Intent-Based Approach:

• Express intent to rebalance across money markets

• Solvers compete but may only partially fill

• Capital fragmentation and suboptimal yields

• Multiple transactions and fees

Atomic Approach:

• Single transaction rebalances entire position

• Atomic unwind from over-utilized pools

• Optimal capital deployment guaranteed

• Minimal fees and slippage

The Technical Superiority of Atomicity

Latency and Finality

Intent networks introduce multiple rounds of communication:

1. Intent broadcast (~1-2 seconds)

2. Solver discovery and bidding (~2-5 seconds)

3. Execution across chains (~5-60 seconds)

4. Settlement confirmation (~1-10 minutes)

Total: 10 seconds to several minutes

Atomic execution compresses this to:

1. Bundle submission and validation (~100ms)

2. Simulation and sequencing (~150ms)

3. Atomic execution across all chains (~150ms)

4. Instant finality via DAG consensus

Total: Under 500 milliseconds

Security Model

Intent networks rely on:

• Solver reputation systems

• Economic incentives for good behavior

• Dispute resolution mechanisms

• Trust in relay networks

Atomic systems enforce:

• Cryptographic consensus among validators

• Threshold signatures preventing single points of failure

• Deterministic execution paths

• Protocol-level security guarantees

Capital Efficiency

Intent systems often require:

• Solver inventory across multiple chains

• Collateral posting for reputation

• Fragmented liquidity pools

• Higher fees to incentivize solvers

Atomic execution enables:

• Zero inventory requirements

• Direct access to all liquidity

• No intermediate capital locks

• Lower fees through efficiency

Why Developers Choose Atomicity

For serious DeFi applications, the choice is clear:

Predictability

Developers can simulate and guarantee execution paths before submission. No wondering if intents will be fulfilled or how solvers might interpret them.

Composability

Build complex multi-step operations knowing they execute atomically. Stack DeFi legos across chains without fear of partial failures.

User Experience

Users get instant, guaranteed execution without waiting for solver markets or handling failed intents.

Risk Management

Eliminate entire categories of risk: partial fills, race conditions, solver misbehavior, and execution uncertainty.

The Path Forward

While intent-based networks serve a purpose for simple, best-effort operations, the future of cross-chain DeFi demands stronger guarantees. As protocols grow more sophisticated incorporating complex hedging strategies, multi-venue arbitrage, and institutional-grade execution - only atomic frameworks can provide the necessary foundation.

The question is whether your application can afford anything less than cryptographic guarantees. For the next generation of cross-chain applications, from perpetual DEXs managing billions in notional volume to institutional gateways requiring deterministic execution, atomic cross-chain execution is a requirement.

Conclusion: Building on Certainty, Not Hope

The evolution from intent-based to atomic execution mirrors the broader maturation of blockchain infrastructure. Just as we moved from probabilistic to instant finality in consensus mechanisms, we're now moving from best-effort to guaranteed execution in cross-chain operations.

Intent networks ask users and developers to trust in market mechanisms and solver incentives. Atomic execution frameworks like Pelagos remove trust from the equation entirely, replacing it with cryptographic certainty. In a world where a single failed transaction can trigger liquidations worth millions, where arbitrage opportunities exist for milliseconds, and where institutional capital demands predictable execution, atomicity is essential.

Want to partner with us?

If you're a developer interested in building on Pelagos or a potential validator, we'd love to hear from you.

Check our partnership deck or fill out our BD form

Join our community

• Visit our Website

• Join our Discord

• Follow us on X

• Email: contact@pelagos.network

September marked a pivotal transition for Pelagos from prototype infrastructure to a production-ready platform. Core development advances included operational node synchronization, Kubernetes-based validator deployment, and the public release of our SDK with comprehensive documentation. On the go-to-market front, multiple DeFi protocols initiated testing of atomic cross-chain transactions on our private testnet, while community growth accelerated across all channels. Operationally, we strengthened the team with a founding protocol engineer to support scaling toward mainnet launch.

Product & Technical Development

Infrastructure Milestones

Node Synchronization & Cluster Architecture

• Achieved reliable node synchronization with recovery capabilities, enabling seamless addition of nodes to the validator cluster

• Successfully deployed operational nodes capable of recovering from failures and maintaining continuous event creation

• Established framework for running local appchain nodes independently of validator participation

Kubernetes Validator Deployment

• Launched initial Kubernetes cluster infrastructure for validator operations

• Implemented deployment service capable of provisioning appchains to Kubernetes environments

• Completed restart and recovery testing protocols, confirming node stability and state preservation following failure scenarios

SDK Release & Developer Tooling

• Published SDK v1.0 with full documentation on GitHub, establishing our public developer presence

• Delivered complete local development stack including:

  • Local node operations

  • Transaction submission capabilities

  • External chain data integration

  • Comprehensive documentation and tutorials

• Enabled developers to interact with Sepolia, BSC, and Polygon testnets through stable access to blocks, events, and receipts

Consensus & Cross-Chain Integration

• Integrated development-ready consensus module for internal appchain logic testing

• Established architecture for providing external transaction data to TSS (Threshold Signature Scheme) appchain

• Deployed first-version EVM contracts to target networks

• Implemented built-in RPC layer with templated APIs to streamline appchain integration

Appchain Scalability

• Built and benchmarked sharded appchain prototype, validating horizontal scalability approach

• Demonstrated early throughput improvements and confirmed architectural viability for multi-appchain scaling

Blockchain Integration

• Validated Ethereum and Solana read operations through SDK

• Confirmed working integration with multiple EVM networks (Sepolia, BSC, Polygon)

• Advanced Solana signing stub implementation with transaction signing and parameter optimization

• Initiated research on transaction resend mechanisms for enhanced reliability

Go-to-Market Progress

Developer Onboarding & Testing

Multiple established DeFi protocols have commenced private testnet integration:

LIQ Markets — Led by experienced DeFi builders, is developing the first crosschain, cross-margin perpetual exchange on Pelagos. Key differentiators include:

• Chain-Agnostic UX: One-click deposits and withdrawals across any supported chain

• Unified Trading Environment: Combined perpetuals and spot trading for both blue-chip and niche assets

• Private Pools: Optional trade privacy for institutional-grade execution

• Programmable Vaults: Flexible collateral management across chains

• CLOB Architecture: Central limit order book with price-time priority and millisecond cancel/replace functionality

Resulting User Experience:

• Sub-second order acceptance (no waiting for limit fills)

• True cross-chain cross-margin (eliminates chain-specific collateral requirements)

• Unified liquidity access without bridges or wrapped assets

Additional Protocol Integrations:

• Lendle (Lending Protocol): Testing atomic cross-chain collateral and liquidation flows

• Robinos (DeFi Infrastructure): Validating multi-chain transaction coordination

• LayerBank (Money Markets): Exploring unified liquidity layer integration

Community & Market Development

Growth Metrics (Month-over-Month)

• Twitter/X Growth: +50% (500+ → 1,000+ followers)

• Discord Growth: +20% (1,300+ → 1,500+ members)

• Engagement Quality: Increased technical discussion participation and builder inquiries

Community Initiatives

**Builder's Spaces Launch **

Inaugurated monthly AMA series spotlighting ecosystem builders. Initial session featured Bruce from LIQ Markets, providing technical deep-dive on crosschain perpetuals architecture.

Content & Thought Leadership

• Published detailed article on LIQ Markets' functionality and Pelagos integration benefits

• Participated in Cicada MM's Twitter Space discussing market-making in cross-chain environments

Event Participation

• ETH Istanbul (September 5-7): Speaking engagement on atomic settlements <1s (Nicky, Neb, Boris/Evgenii)

• Token 2049 Singapore: Attending for partnership development and investor relations (Nicky attending Hack Seasons panel and Simpleswap events as a panelist)

Developer Documentation

• Released comprehensive roadmap outlining quarterly milestones through mainnet

• Published documentation of first transaction execution (no manual intervention required)

Team Expansion

September Hire

Krishna Prasad — Founding Protocol Engineer. Former Polygon core team member who led Erigon-Polygon (PoS) integration. Krishna brings deep expertise in:

• Layer 1 protocol architecture

• External blockchain adapter development

• Validator operations and infrastructure

Current Focus Areas:

• Partner integration support (actively assisting LIQ Markets deployment)

• TSS (Threshold Signature Scheme) implementation

• External chain adapter development

• Validator operational procedures

Upcoming Addition

UX Developer (Starting October) Incoming team member will focus on:

• Developer tooling interface improvements

• SDK usability enhancements

• Documentation and tutorial development

October Roadmap Preview

Technical Priorities

Infrastructure Hardening

• Fail-safety and recovery stress testing under load conditions

• Validator activity tracking and monitoring systems

• Block explorer deployment for transparency and debugging

Developer Experience

• Continued SDK refinement based on early partner feedback

• Expanded language support and example applications

Cross-Chain Capabilities

• Epoch-based consensus implementation for validator rotation

• Completion of external transaction submission from appchains to external blockchains via cluster

• Integration of additional blockchain networks

Team Growth

• Onboarding of frontend developer

• Recruitment of additional blockchain engineer

Go-to-Market Activities

Testnet Launch

Public testnet deployment with initial cohort of appchains, enabling:

• External developer testing and feedback collection

• Real-world performance validation

• Community engagement and builder recruitment

Conclusion

September represented a significant maturation point for Pelagos, transitioning from infrastructure development to enabling real-world applications. The SDK release, combined with active protocol integrations and strengthened team capabilities, positions us well for Q4 testnet launch and subsequent mainnet preparation.

Our focus remains on delivering production-grade infrastructure that eliminates the complexity of cross-chain development, enabling builders to focus on application logic rather than blockchain interoperability challenges. The progress demonstrated by early partners like LIQ Markets validates our core thesis: atomic cross-chain execution unlocks entirely new categories of decentralized applications.

As we advance toward testnet launch, priorities center on infrastructure resilience, developer experience refinement, and strategic partnership development to build a robust ecosystem of applications leveraging Pelagos' universal execution layer.

Want to partner with us?

If you're a developer interested in building on Pelagos or a potential validator, we'd love to hear from you.

Check our partnership deck or fill out our BD form

Join our community

• Visit our Website

• Join our Discord

• Follow us on X

• Email: contact@pelagos.network