Check the orderbook.
Calculate spread.
Place buy.
Wait for a fill.
Place sell.
Cancel stale orders.
Do it again.
And again.
And again.

There is nothing inherently wrong with manual trading. Many traders prefer it because it gives full control over timing and decisions.

But once the same sequence repeats hundreds of times, you’re not really executing a strategy anymore. You’re just clicking the same buttons faster. At that point, it altogether stops being a strategy problem and becomes a time problem.

Enter the o2 Trading Bot: built to automate the repetitive parts of workflows traders already follow.

The bot doesn’t replace your strategy.
It replaces mechanical execution.

You define pricing logic, sizing, timing and risk limits.
The bot executes that predefined loop continuously across markets, directly from your browser.

Connect wallet. Pick a strategy. Hit start.

Why Automate Execution

Most traders already follow strategies without calling them strategies.

• Some trade around mid price with fixed spreads.

• Some rebalance inventory every few seconds.

• Some cancel orders after a set time window.

These are execution loops.
And anything that repeats can be automated.

Manual trading still has its place. The bot simply removes the mechanical overhead so you can focus on decisions that actually require your attention.

Security and Execution

When you open bot.o2.app and connect your wallet:
The bot never asks for private keys.
Doesn’t take custody of funds.
Doesn’t have access to withdrawals.

Instead, your wallet creates a session key locally, in your browser.

The key can sign trading orders but cannot withdraw funds. The o2 contract enforces this at the protocol level.

You sign once to authorize the session. After that, every order is signed locally while your main wallet stays idle.

Execution runs client side, so you always see exactly what the bot is doing. The tradeoff is straight-forward: the browser tab must stay open and in return you get full transparency and control.

One Engine, Many Strategies

The bot is not built as separate tools for different trading styles. It is a single execution engine with configurable presets.

• Simple
  Balanced limit orders with moderate sizing and profit protection.

• Volume Maximizing
  Fast cycles designed for competition environments.

• Profit Taking
  Slower pacing with tighter spread control focused on consistent round trips.

Presets are just the starting points. Every parameter can be manually adjusted as needed.

The goal is simple: automation is meant to remove repetition, not control.

Built-In Guardrails

• Stop Loss exits positions if price moves beyond your defined threshold.

• Order Timeout clears stale quotes so capital stays active.

• Max Session Loss pauses execution once a defined loss level is reached.

• Profit Protection respects your weighted average cost basis.

Risk management stays part of the strategy and isn’t hidden behind advanced menus.

Multiple Markets and Visibility

Each market runs its own configuration while sharing the same execution engine. A round robin scheduler keeps execution running across all configured markets.

Because everything runs client side, activity is visible in real time.
The Trade Console streams orders, fills, skips and P&L updates as they happen.

Trade history is stored locally with filters and CSV export for deeper analysis.

Daily Streaks and Competitions

o2 has daily streak targets and volume based competitions that many traders already participate in manually. Maintaining streaks usually means executing consistent trading activity over time and coming on top of the leaderboard with boosted scores

This is where the bot fits in naturally.

Instead of manually running the same cycle to maintain volume targets, you can configure a strategy once and let it handle the repetitive execution while you monitor performance in real time.

Interface and Next Steps

The bot supports the same languages as o2: English, Japanese, Korean, Simplified Chinese, and Traditional Chinese.

Server side execution is being explored for traders who want strategies running continuously without keeping a browser tab open. The philosophy stays the same: automation handles execution while strategy remains in your control.

Try It Out

If your workflow repeats, you probably shouldn’t be the one repeating it.

bot.o2.app

Have feedback or ideas for new features? Our DMs are open

o2 was built having this in mind. We did not want to settle for a venue where trades pass through, but as a system where execution, incentives and performance reinforce each other in the long run. The result is an environment where participation isn’t just enabled but also reflected in how the DEX and its users evolve.

What follows is an explanation of how we see things from an infrastructure-first perspective

Trading Infrastructure Is Never Neutral

Every trading platform makes choices. Some are explicit, others are implicit, but all of them influence outcomes. What gets measured, what remains visible, what has lasting effects. These are factors that shape behaviour.

CEXs, DEXs or anything in between, that claim neutrality usually hide their assumptions. The absence of visible rules doesn’t mean the absence of influence; it means influence operates out of sight.

This is how we approach things differently: by making execution fully transparent and outcomes observable, o2 allows behaviour to speak for itself. Rather than obscuring dynamics behind abstractions, it exposes them.

This doesn’t say how traders should act. It simply removes ambiguity about how the tech behaves.

From Transactions to Performance

Most DEXs are designed around transactions. You place an order, it fills and the system moves on. The product doesn’t really "care" whether a trade reflects skill, discipline or a repeatable approach.

On the opposite side, on o2, because execution is transparent and everything is observable, performance visibly accumulates over time rather than disappearing into isolated actions. Markets are weighted. Scoring is sensitive to PnL. Boosts stack up. Execution behaves predictably. As a result, outcomes begin to reflect not just participation, but the quality and consistency of ongoing trading.

Over time, this changes how traders engage with the DEX. Individual orders don't count much in isolation. Consistency begins to mean more. Traders refine execution, choose markets carefully and pay closer attention to repeatability instead of chasing singular outcomes.

This change isn’t enforced or verbatim explained, because explaining doesn't do a lot without practice. It emerges naturally from the way our competition framework behaves.

Competition Without Play-Pretend

The introduction of trading competitions on o2 made all of these dynamics visible.

Rather than turning competition into spectacle, its features act as a feedback mechanism. Leaderboards don’t just rank wallets; they reveal patterns and strategic performance. Certain approaches rise steadily. Others fade as conditions change.

There’s no instruction embedded in the interface telling traders how to approach trading. The leaderboard shows live outcomes instead. Participation itself becomes a learning loop, as traders analyse results, adjust strategy and improve through experimenting and repetition.

Competition on 2 isn’t designed to propagate empty hype. It's a way to make performance legible and valuable.

Learning From Real Usage Instead of Assumptions

Now that o2 has run 5 competitions back to back, we can confidently say the most valuable input isn’t speculation. It’s observation.

With over $170M in total trading volume, the platform is already surfacing clear behavioural patterns. And we don't mean just who wins, but how performance develops over time. Which strategies hold when the market is volatile or how traders adapt as new features are introduced.

That feedback informs how the platform evolves. Design decisions aren’t defended in theory; they are refined in response to use. What works is reinforced. What doesn’t, is reconsidered or thrown in the bin.

This is iteration grounded in behaviour instead of blind projection.

Why Infrastructure Has to Hold

Because this kind of competitive environment only works if the infrastructure can support it.

Execution must behave predictably. Liquidity has to respond under load. Latency cannot become a ghost variable. Results for competitors' efforts cannot hinge on opaque mechanics or off-chain shortcuts.

That’s why the underlying backend decisions are foundational.

Fully onchain architecture ensures that execution and state changes are verifiable. Free native asset movement through the fast bridge removes extra steps. Easy onboarding through any of 7 wallet options or email, lowers barriers. Our in-house market making infrastructure keeps execution reliable as activity increases.

Each component reinforces the others. Together, they create optimal conditions where competitions reflect the reality of quality trading rather than headline metrics.

Consistency Over Short Term Wins

One of the clearest things emerging so far is that steady execution outperforms one offs.

o2 doesn’t optimize for a single metric or short-lived spikes. It creates winners through consistency, by letting performance add up over time.

This isn't meant as a prescription for how people should trade. It’s just the result of infrastructure that doesn't get in your way and lets results speak for themselves.

Where This Leads (what is the payoff)

Seen this way, o2 is more than a trading platform.

It’s infrastructure for competitive systems: environments where outcome after outcome reflect real trading performance as opposed to what looks good at first sight

Developers can build strategies and tools that plug directly into this observable behaviour. Traders can measure themselves in a setting that doesn’t distort or hide results. The ecosystem can grow in directions that weren’t explicitly designed, because our foundations support it.

o2 isn’t finished and it isn’t meant to be.

It’s a system designed to evolve alongside the people using it, shaped by how it's applied and not by whiteboard ideas that only sound good in meetings.

Ultimately, the point isn’t where o2 is today, but where it's uniquely positioned to go and what it makes possible along the way.

For those of you who want to dive deeper, participation is the best way of learning: o2.app

Transparency That Can Be Verified

When systems operate off-chain, transparency becomes a promise. Users are told how things work, but they can’t independently verify what’s happening behind the scenes. Execution logic, matching behavior and state transitions are hidden in places users can’t see.

Onchain systems remove that ambiguity.

Every transaction on o2, every state change, every operation is publicly verifiable. Not through dashboards or status pages, but through the blockchain itself. This isn’t “trust us, we’re transparent.” It’s mathematical and cryptographic transparency.

In practice, this means traders can verify how scores are calculated, how referral volume contributes, when boosts apply and how rewards are distributed; directly from onchain data. The order matching rules themselves are auditable onchain, which matters because they directly affect the prices users are exposed to. There is no secondary system translating or “summarizing” results after the fact.

That distinction matters, especially in competitive trading environments where execution quality, fairness and predictability directly affect outcomes.

Security Is Inherited, Not Added

Fully onchain architecture also changes how security works.

o2 doesn’t rely on a separate security model layered on top of the blockchain. It inherits the security guarantees of the Fuel network itself. The same consensus, validation and cryptographic protections that secure Fuel also secure o2.

There are no centralized components that can become single points of failure. There is no privileged backend that can reorder execution, selectively exclude participants or alter system behavior.

Security isn’t something we bolt on later. It’s native.

Composability Is the Real Unlock

The most powerful consequence of being fully onchain isn’t just transparency or security. It’s composability.

Because o2 is entirely onchain, other smart contracts can interact with it directly. No permissions. No API negotiations. No intermediaries. Developers can simply build.

Trading strategies can interact with o2 contracts directly. Analytics tools can compute scores without relying on internal APIs. Other protocols can use o2 activity as an input to their own logic. These integrations don’t require coordination or approval, they emerge naturally from open infrastructure.

This level of interoperability isn’t possible when core components live off-chain. It requires infrastructure that is open by default.

Built Beyond the Next Cycle

Choosing to build fully onchain also meant designing o2 as infrastructure, not just a product.

It meant building systems that wouldn’t need to be reinterpreted, rewritten or selectively enforced as usage increased. Rules that exist as code don’t drift over time. Incentives that are enforced onchain don’t depend on discretion.

We aren’t building for the next quarter. We are building for the next phase of the ecosystem: one where transparency, composability and security aren’t optional.

Fully onchain architecture is our commitment to doing things right, not just doing things fast.


For those of you who want to explore the architecture in more detail or build on top of o2, tech documentation is available in the o2 docs: docs.o2.app

The Philosophy Behind o2

When we began designing o2, we asked a fundamental question: what does the ecosystem actually need?

What we found was a pattern of compromises that had become so common in DeFi they were treated as unavoidable. Speed versus security. User experience versus decentralization. Performance versus transparency. Builders were forced to pick sides, optimizing for one thing while sacrificing another.

Over time, these tradeoffs stopped being questioned. They became accepted constraints rather than engineering decisions that could be challenged.

The mission of o2, from the very beginning, has been to prove that these compromises are not actually necessary.

We believe you can build infrastructure that is fast and secure. Systems that are intuitive and fully onchain. Platforms that work reliably today and are designed to scale for tomorrow. o2 exists to show that these goals are not mutually exclusive, if you’re willing to put in the work.

What makes o2 different isn’t a single feature. It’s how every component works together as part of a unified system.

The Problem With Accepted Tradeoffs

The prevailing framework in DeFi has treated certain tradeoffs as immutable. Speed requires centralization. Transparency slows execution. Better UX means compromising on decentralization. Builders optimize within these boundaries rather than asking whether the boundaries themselves are real.

Why does this matter?

Because these compromises have real consequences. Traders get worse execution than they should. Hidden costs show up in slippage. Developers build on infrastructure that works at a small scale but starts to crumble the moment real volume arrives.

Over time, this leads to systems that are fragile. They work, until they don’t. They scale, until they hit invisible limits. And when those limits are reached, the only option is often to rebuild from scratch.

o2 was designed to break out of this pattern.

Built for the Long Run

From the outset, we made a deliberate choice: optimize for the long term, not for the fastest possible launch.

That decision shaped every architectural choice that followed.

Building fully onchain is harder. Much harder. Designing native infrastructure instead of bolting on third-party components takes longer. Obsessing over execution quality, security and user experience sometimes adds months to development timelines.

But shortcuts have a cost. And those costs tend to surface later, when systems are under stress and the stakes are higher.

o2 was built with a different philosophy: invest upfront in foundations that won’t need to be replaced.

We aren’t trying to ship something that looks impressive in the next quarter. We are here to build a product that will still be relevant and reliable and scalable for years ahead, as the ecosystem grows and use cases evolve.

Why Fuel Matters

o2 is built on Fuel because Fuel itself is designed with performance and scalability as first principles.

As an execution layer, Fuel allows us to push performance boundaries without compromising on decentralization or transparency. That matters deeply for trading infrastructure, where latency, throughput and determinism all have real economic consequences.

But this isn’t just about raw speed. It’s about design alignment.

Fuel provides the ability to build fully onchain systems that don’t rely on hidden off-chain components or opaque execution paths. Every transaction, every state change, every operation can be verified. Not “trust us” transparency; but cryptographic, mathematical transparency.

As Fuel matures and the network grows stronger, o2 automatically benefits. It inherits the security guarantees of the underlying blockchain. Performance improves as the underlying system evolves. There’s no separate security model to maintain and no off-chain machinery that has the risk of becoming a liability.

Infrastructure That Compounds

One of the most powerful consequences of building fully onchain is composability.

Because o2 is entirely onchain, other smart contracts can interact with it directly. No special permissions. No intermediary trust assumptions. Developers and traders can simply build.

This is how ecosystems actually grow.

One person builds a trading strategy on top of o2. Another sees it and builds a lending protocol that integrates with it. A third combines both with something entirely new. Innovation thrives not because a single team planned every use case, but because the infrastructure allows ideas to become reality.

That kind of emergent growth isn’t possible when core components live off-chain or behind closed interfaces. It requires infrastructure that is open by default and composable by design.

More Than Technology

It’s easy to frame these decisions purely in technical terms: onchain architecture, security guarantees, performance characteristics. But the implications go further than that.

When infrastructure is transparent, users trust it more. When systems behave predictably under stress, developers build with confidence. When onboarding is smooth and execution is reliable, people are more willing to experiment, participate and stay.

This is how you move from potential to actual adoption.

o2 isn’t just a collection of features. It’s a carefully thought out attempt to rethink how trading protocols should be built when you stop accepting tradeoffs as inevitable.

Looking Forward

o2 wasn’t built for headlines or hype cycles. We didn’t optimize for the biggest marketing splash or the fastest announcement timeline. We built for sustainable growth.

The development timeline was long, intentionally so. Not in pursuit of perfection, but in service of durability. We wanted foundations that wouldn’t crack under scale, that wouldn’t need to be replaced when usage increased or assumptions changed.

Now that o2 is at its third competition, we’re starting to see that approach pay off. With over $60M in total trading volume, o2 is becoming a competition-driven arena where traders actively compete, perform and refine strategy over time. Winning isn’t driven by one-off trades, but by repeatable execution, market selection and discipline. This can only emerge in a system built for sustained competition. We’re learning directly from how traders engage, adapt and improve while evolving the platform based on real usage.

And this is just the beginning.

o2 isn’t a finished product. It’s a platform designed to evolve alongside the ecosystem. New capabilities will be added. New competitive dynamics will be added. The architecture is built to adapt; supporting not just more activity, but better performance over time.

What excites us most isn’t just what o2 is today, but what it enables tomorrow. The infrastructure is in place. The foundation is solid. What matters most now is enabling traders to perform and win consistently. That’s where the real story begins.