Open source where it matters

The question we keep getting

“Is Aurono open source?”

The honest answer: partly. And we think that’s the right answer.

Here’s why.

The problem with “fully open source”

Fully open source sounds noble. And in many contexts, it is. But for a product that handles your money, “fully open source” often means one of two things:

No business model. The project depends on donations or volunteer time. Eventually, the maintainer burns out, gets a job, or loses interest. The project stalls. Your trading bot stops getting security updates.
Hidden monetization. The software is free, but the company makes money from your data, from premium features that make the free version frustrating, or from a cloud service that gradually becomes required.

Neither of these builds the kind of long-term trust you need from software that moves your money.

Our approach: open where decisions are made

Aurono splits the codebase into two layers with a clear principle: if it makes decisions about your money, it’s open. If it renders a chart or connects to an exchange, it’s proprietary.

What’s open

The entire decision-making pipeline is open source. You can read, audit, and verify every line of code that determines:

Whether to trade. The strategy evaluation engine — the exact logic that decides “buy”, “sell”, or “hold” — is fully public. You can trace every signal, every guard, every reason code.
How much to trade. The sizing engine that converts your “buy €10 of ETH” into a specific number of units, accounting for fees and rounding. Open.
How trades settle. The settlement model — reservations, fills, releases, capital and inventory bookkeeping. Every ledger entry, every balance calculation. Open.
How your P&L is computed. Average cost basis, realized gains, unrealized position value. The math that tells you how your strategies are performing. Open.
How signals are analyzed. The core sigma computation and trigger analysis math used in Lab. The statistics behind the calibration tools. Open.
The event schemas. Every event Aurono produces — decisions, fills, settlements — has a published schema. You can verify that events conform to the specification.

What’s proprietary

The user interface. Dashboard, strategy cards, charts, settings — the experience of using Aurono. This is where most of the development effort goes, and it’s what makes Aurono a product rather than a library.
Exchange adapter implementations. The specific code that connects to exchanges. This includes credential handling, order placement, and exchange-specific details. It’s thin, operationally sensitive, and changes frequently.
The Lab experience. The UI for Explore and Simulate — period selection, crash detection, regime visualization. The underlying math is open; the experience built on top of it is proprietary.

Exchange integrations: curated, not open

You might expect us to say “the exchange adapter interface is open so anyone can build one.” We considered that. But it’s the wrong choice when money is involved.

Aurono only integrates with exchanges that are licensed to operate in the EU, that meet our security standards, and that align with our values. Each exchange integration is a vetted partnership — not a community plugin.

This protects you in two ways: you know that every exchange available in Aurono has been evaluated for regulatory compliance and execution quality. And it enables us to build sustainable partnerships that keep the business running without charging you subscriptions.

Why this builds more trust

Consider two scenarios:

Scenario A: Fully open source bot. You download it, run it, and it works. But you have no idea if the version you downloaded matches the code on GitHub. The maintainer might push an update tomorrow that changes the sell logic. There’s no company behind it, so there’s no accountability.

Scenario B: Aurono. The decision engine is open — you can audit exactly how trades happen. The product around it is proprietary, backed by a company with a sustainable business model. If we change the sell logic, you can see it in the open repository. If we go out of business, the open-source core keeps running.

We believe Scenario B is more trustworthy, not less. Here’s why:

Accountability. We have a business to protect. We can’t quietly change the evaluation logic without it being visible in the public repository.
Sustainability. We earn revenue from the product layer. The open core doesn’t need to generate revenue — it just needs to be correct and trustworthy.
Independence. If Aurono Labs disappears, the open evaluation engine, settlement model, and portfolio math continue to exist. Someone could build a new UI on top of them.

The line we’ll never cross

The decision engine will never become proprietary. The moment we close the code that decides whether to buy or sell your assets, the trust proposition collapses.

This isn’t a business strategy. It’s a constraint we chose because we believe software that handles money must be inspectable. Full stop.

If you want to verify that Aurono’s sell guard actually prevents selling below cost basis — you can read the code. If you want to confirm that the cooldown timer works as documented — you can read the code. If you want to understand exactly why a trade happened at 3 AM — you can trace it through the open event log to the open evaluation engine.

That’s the kind of transparency that matters. Not “here’s our entire codebase, good luck finding the relevant parts.” But “here’s exactly the code that makes decisions about your money, cleanly separated, well-documented, and always public.”

What this means for you

You can trust the decision layer because you can verify it.
You can trust the product because there’s a business model that doesn’t depend on exploiting you.
You can trust the future because the core logic exists independently of us.

That’s open source where it matters.

Aurono’s open-source evaluation engine is available for inspection. The product experience is what you get when you use Aurono — built on top of a foundation you can trust because you can see it.

Join the waitlist to try the product layer when early access opens.