The KryllOS whitepaper

Most automated trading tools are websites. The strategy runs on the provider’s servers, so the exchange API keys that can place orders on your account live on those servers too. The features are the ones the provider chose to build. And the service is paid for with a subscription, a cut of the trades, or both.

Each of those is a trade-off the user did not really choose: a third party able to trade on their account, a ceiling on what a strategy can do, and a cost that grows with activity rather than with what the user gets out of it.

• It runs on hardware the user controls: their computer, or a VPS they rent.
• The keys stay on that machine. Kryll is not in the path between the user and the exchange.
• What it can do is what is installed in it: blocks, strategies and applications, all from one store.
• Using it costs nothing: no subscription, and no trading commission taken by KryllOS.

Traders who want to automate a rule without writing code. Developers who want to extend the system. KRL holders who want to know what the token does inside the product.

KryllOS is in early access, and part of what is described here is not available yet. The roadmap lists what ships today and what is announced.

Kryll has been building automated crypto trading tools since 2017. Its publisher is Cryptense.

Its first product was a hosted platform built around one idea: a trading strategy should be something you can draw, not something you have to program. Traders composed bots by connecting blocks on a canvas, tested them against past market data, and ran them on Kryll’s servers. Over the years the platform added a marketplace where authors published their strategies for others to use, a mobile app, a reworked execution engine, multi-backtesting, variable blocks and webhooks.

The KRL token was issued in 2018 to fund the project and to serve as the currency of its ecosystem. Its maximum supply was fixed at 49,417,348 then, and it has not changed since.

KryllOS keeps the visual editor, the idea of a store that pays the people who build, backtesting before risking money, and the KRL token. Everything else was reconsidered from where it runs.

KryllOS runs where the user puts it. There is no hosted version: strategies run on the user’s computer or on a server the user rents, and the orders they send do not go through Kryll.

Funds stay on the exchange, in the user’s own account. KryllOS places orders on that account with an API key the user created, which stays on the user’s machine and is never sent to Cryptense or its team. KryllOS does not hold funds and does not withdraw them, and the key it uses should not have withdrawal rights.

A strategy in KryllOS is a graph of blocks that reads like a sentence. The graph you see in the editor is exactly what the backtest replays and what the engine runs: there is no hidden second version, and no export step that could change it. If you cannot read your strategy out loud to somebody else, you do not yet know what it does.

KryllOS takes no subscription and no commission on trades. The exchange charges its own fees, and a VPS or an AI provider, if the user chooses one, bills them directly.

KryllOS is a desktop, not a fixed product. Blocks, strategies and applications install from the same store and uninstall the same way, and a block that does not exist yet can be written, described to an AI, or installed from someone who already made it.

The source code of KryllOS will be published. Kryll is finishing version 1 first, so that what gets published is a foundation the rest can be built on, not a draft that changes every week. No date and no licence are announced yet.

Until then, the code is not hidden: KryllOS installs as readable Python source, not compiled code, so anyone who installs it can read what runs on their machine.

KryllOS is a desktop application for macOS, Windows and Linux. Inside it, each tool is a window: the strategy editor, a backtest, the file manager and the wallet can stay open side by side, and the user arranges them once. There are no pages to navigate between.

What the desktop can do is what is installed in it. Native blocks and applications ship with KryllOS; custom blocks, strategies and further applications will come from the marketplace.

On the user’s own computer, or on a VPS they rent, set up with 1-Click VPS Deploy. On a VPS, strategies keep running with the laptop closed, and it is still the user’s machine, the user’s keys and the user’s data. Kryll operates no server in between.

Access is through Kryll Embark, the portal that serves the builds. During early access it requires an access key, sent in waves to anyone who asks for one.

A strategy is a file: a .kryll document, in JSON, that holds the graph of blocks, their settings and the links between them. The editor opens it, the backtest engine replays it and the execution engine runs it, all from the same file. There is nothing to export and nothing to keep in sync.

Because it is a file, a strategy can be copied, versioned, shared, or written by something other than the editor. That last point is what lets an AI agent build one.

Execution starts at the Wallet block, which sets the capital the strategy works with, and moves from block to block along the links. At any moment the strategy is at one place in the graph.

• A condition block (an indicator, a price level, a time window) holds the flow until its condition is true, then passes it on.
• An order block (Buy, Sell, Long, Short, Close) sends its order to the exchange, then passes the flow on.
• OR continues down the first branch whose condition is met. AND continues only when every condition inside it holds at once.
• GoTo sends the flow to another block, which is how a strategy loops or reuses a part of itself.

This model is why a strategy can be read: the path the flow takes is the path you see.

KryllOS connects to the user’s own exchange account through an API key the user creates on the exchange. Supported today:

Planned: KuCoin, Gate.io, Kraken.

“Supported” means the exchange can be connected, backtested against and paper-traded on. Live trading with real funds is not available yet on any exchange. Whether an exchange is available to a user depends on their country of residence: it is up to the user to check that it is authorised where they live.

The editor is a canvas. The user drops blocks on it and wires them together, without writing code. What results is not a diagram of the strategy; it is the strategy.

A finished graph reads like a sentence. For example: while the 12-hour EMA trend is bullish and most of the wallet is still in the base currency, wait for EMA(4) to cross above EMA(30) on a green candle, then buy with half of it at limit, and hold for 36 hours before looking again. Each part of that sentence is one block.

More than thirty blocks ship with KryllOS, in six families, plus custom blocks for everything else.

Buy and Sell sit in the same graph as Long, Short and Close. A strategy can span both markets without leaving the canvas, and the futures blocks open long or short positions with leverage. Leverage increases losses as much as gains (see trading risk).

A custom block, once installed, appears in the block library, drags onto the canvas and connects like any other, including inside AND and OR. There is no second-class tier.

Write it

Build the block outside KryllOS and import it into the editor.

Describe it

Tell your AI agent what the block should do and let it write the code.

Install it

Take one somebody already published, from the marketplace, once it opens.

The backtest engine walks a strategy through past market data and reports what it would have done. It was rebuilt from scratch for KryllOS and runs on the user’s machine, so a run costs nothing.

• It takes the graph built in the editor, unchanged.
• It reports every order, in order, not only a curve at the end.
• It shows the branches the strategy never took. A condition that never once became true is the most common bug in a strategy, and the hardest to see.
• Each run is a file in the file manager, which can be reopened, compared or shared.

Multi Backtest takes a list instead of a single run: one strategy on several pairs, several variants of the same idea, or the same strategy across several periods. It runs some in parallel and queues the rest, so the results can be read side by side. Candles downloaded for a run stay on the machine.

Paper trading runs the strategy against the live market feed, in real time, with no funds behind it. It is the only way to see how a strategy behaves in a market that has not happened yet, and it ships with KryllOS today.

Not a forecast

It shows how a set of rules behaved in a market that already happened. Past results, backtested or live, do not predict future performance.

Not the live market

A replay fills orders against historical candles. Real orders meet a real order book, with spread, latency and slippage.

Not proof

Parameters tuned until the curve looks good describe the past; they do not make a rule. A strategy that only works on the window it was tuned on is the normal outcome, not the unlucky one.

Not a substitute for trading small

The honest order is: replay it, paper-trade it, run it on money you can afford to lose, then decide.

Live trading, running a strategy with real funds on a connected account, is the next step. It is announced and not available yet.

Kryll does not build its own AI assistant. KryllOS ships with KryllOS Skill, a skill in the open Agent Skills format: a folder of instructions that an AI agent loads when a task calls for it. It teaches the agent the user already has to build, check and backtest strategies in the KryllOS editor.

It works with Claude Code, OpenAI Codex, Gemini CLI, Cursor and GitHub Copilot, and with any agent that reads the Agent Skills format, such as OpenCode, Goose, Amp, Kiro, Junie or Mistral Vibe.

The user describes a strategy in plain words. The agent places and wires the blocks, and what comes back is an ordinary strategy in the editor, which the user reads, changes and decides what to do with.

A general-purpose AI knows what an RSI is; it does not know how KryllOS runs one. The skill is written from the KryllOS source code, and each of its rules points to the file that implements it, so the agent can check a rule instead of taking it on trust. When the code and the skill disagree, the agent is told to follow the code.

1. Write: place the blocks in the editor.
2. Check: run the validator until the graph has no errors.
3. Replay: backtest it on real history, on the user’s own KryllOS.
4. Read: go through the trades and the logs, and make sure every exit (stop, target, timeout) can fire.
5. Fix: then go around again.

The keys

The agent works on strategies and backtests. Exchange keys stay in KryllOS, and the skill never asks for them.

The go-live button

The agent builds and tests. Sending a strategy live is something the user does, from KryllOS, after reading what was built.

The data path

The agent reaches the user’s own KryllOS through a private SSH connection that does not go through a Kryll server. The strategy goes to the AI provider the user chose.

The decision

The skill teaches how to build a rule, not which rule to build. Nothing an agent says with it is investment advice.

The skill is free and comes with KryllOS. The user pays their AI provider, on the plan they already have.

The marketplace will be one store for everything that plugs into KryllOS, priced in KRL and open to anyone who wants to publish.

Strategies

Complete bots, ready to run. A published strategy is still a graph of blocks, not a black box: it can be opened in the editor and taken apart.

Custom blocks

Single blocks that do something the native ones do not, and behave exactly like them once installed.

Applications

Tools that add a window to the desktop. This is how KryllOS grows without Kryll having to build everything in it.

Whatever is bought installs into the user’s own KryllOS and runs on their machine. Self-hosting, local keys and the ability to read every block come with it. Buying a strategy does not hand the buyer’s keys to its author.

A strategy is bought as its code, which the buyer can read, change and run on their own terms. New versions published by its author are never applied without the buyer’s action.

Anyone can publish what they built and set its price. A strategy that works is worth something to people who would rather not write one, and the marketplace is the mechanism that pays its author for it.

A strategy’s listing will show its results running live on its creator’s own KryllOS, with the period they cover, next to a risk warning. They are the creator’s results, not a promise: past results do not predict future performance.

Every purchase is paid in KRL and shared three ways:

The creator, 70%

Whoever published the strategy, block or application receives the largest share.

Ecosystem growth, 20%

A share funds marketing, partnerships, community programs and promotional campaigns, including rewards for contributions to the ecosystem. Kryll may also use all or part of it to burn KRL (see burning KRL). Cryptense, the publisher of Kryll, manages it. It does not go to KRL holders.

Kryll, 10%

A share funds the technical development, maintenance and operation of the platform. It is what keeps KryllOS free of subscriptions and trading commissions.

How submissions are reviewed, how items are categorised and rated, and whether an item is bought once or rented. These will be published before the store opens.

KRL is deployed on four networks. These are the only official contracts; a token at any other address is not KRL.

KRL is the currency of the KryllOS marketplace: strategies, custom blocks and applications are bought with it. It will also pay for the optional paid features of KryllOS, such as AI credits. A KRL wallet is built into KryllOS, so the token can be held and spent without leaving the app.

KRL is not needed to use KryllOS. The editor, the backtest engine, paper trading and everything else that ships work without holding any.

The supply of KRL has been capped at 49,417,348 since 2018, and no new KRL will ever be created. When the marketplace opens, every purchase will be shared out of KRL that somebody actually spent: 70% to the creator, 20% to the growth of the ecosystem and 10% to Kryll (see how a purchase is shared). Nothing is created to pay for any of it.

Kryll may decide to use all or part of the ecosystem growth share to destroy KRL permanently (a burn), to reduce the number of tokens in circulation. Burned KRL are sent to the address 0x000000000000000000000000000000000000dEaD, from which they can never be moved: they leave circulation for good, while the total supply recorded by the KRL contract stays the same.

Burns may be carried out occasionally, periodically or automatically, including in real time as marketplace purchases are made. Kryll sets their frequency, volume and method according to the needs of the ecosystem and to technical, economic and regulatory conditions, and may change, suspend or stop them within its legal and contractual obligations.

This is not a commitment to burn KRL systematically or in any minimum amount, and it gives no guarantee as to the future value of KRL.

The whole supply was created once, in 2018, by the contract’s own distribution function, and split as below. These figures are written in the contract and can be read on-chain.

KRL is held either in a wallet whose keys belong to its holder, or on an exchange account. Whoever holds the keys is responsible for them: lost keys or a lost recovery phrase mean lost tokens, and nobody can restore them.

Moving KRL costs a network fee, paid in the native currency of the network used: ETH, on Ethereum as on Base, Optimism and Arbitrum. The network must match on both ends. KRL sent to the wrong address, or over the wrong network, can be lost for good. Between Ethereum and the three other networks, KRL moves through their official bridges.

KRL lives on Ethereum, which has run on proof of stake since September 2022, and on three networks built on top of it. None of them relies on proof-of-work mining.

KryllOS runs on the user’s own computer or VPS. Kryll operates no servers that run strategies.

Kryll has not published an environmental policy or a carbon assessment.

Not required

KryllOS is free to use without ever holding KRL.

Not inflationary

No new KRL will ever be created.

Not an income

Holding KRL earns nothing by itself. It gives no right to a share of marketplace purchases, nor to Kryll’s revenue.

Not a cut of your trading

KRL only moves when someone chooses to buy something: an item in the store, or an optional paid feature of KryllOS. KryllOS takes nothing from trades.

Not a vote

Holding KRL gives no vote on Kryll’s decisions.

KryllOS has no subscription, no paid plan, and takes no commission on trades. Self-hosting is what makes that possible: Kryll does not run the servers that run the strategies, so it has no per-user infrastructure to bill for.

KryllOS itself is free and will stay free. What may be paid sits beside it, in KRL: what creators sell on the marketplace, optional AI credits, and additional services.

Others still charge for their part: the exchange its trading fees, a VPS provider if the user rents a server, and an AI provider if the user connects one.

Marketplace

Kryll’s share of each purchase, once the store opens.

AI credits

Optional credits, paid in KRL, for users who would rather not take out their own subscription with an AI provider.

Exchange referrals

Some exchanges pay partners who bring them users a share of the trading fees they charge. Where Kryll takes part in such a program, that share comes out of the exchange’s own fee: it adds nothing to what the user pays, and KryllOS still takes no commission on trades.

The user creates the API key on the exchange and pastes it into KryllOS, which stores it on the machine that trades. It is never sent to Cryptense or its team, which has no access to that machine. KryllOS needs a key that can read the account and place trades; it does not need withdrawal rights, and a key used with it should not have them.

Orders go from the user’s KryllOS to the exchange. Trading history and performance data stay on that machine. Kryll runs no cloud service that stores users’ keys or trading data, so there is no central store of keys to breach.

Kryll’s servers come in at two points: Kryll Embark, which distributes KryllOS and its updates, and usage statistics, which the user can turn off in the KryllOS settings. These are usage events attached to a random install ID: they never include strategy code, API keys or exchange balances, and the user’s IP address is not kept.

Self-hosting moves responsibility as well as control. Keeping the computer or the VPS up to date and secured, protecting access to it, and backing up strategy files are the user’s job. A compromised machine exposes the keys stored on it.

When an AI agent works through KryllOS Skill, the strategy and backtest results it reads go to the AI provider the user chose, under that provider’s terms. Exchange keys do not. Using an AI agent is optional.

KryllOS is in early access. It is handed out in waves, as access keys for Kryll Embark, at no cost and with no conditions: anyone can ask for one. It will be free and open to everyone at launch.

This document describes a software product and the token used in its store. It is provided for information only. It is not investment, financial, legal or tax advice, it is not a prospectus, and it is not an offer or a solicitation to buy or sell KRL or any other asset.

Despite its name, it is not a crypto-asset white paper within the meaning of the EU Markets in Crypto-Assets Regulation (MiCA). KRL was admitted to trading before that regulation applied, and this document has not been drawn up, notified or published under it.

Trading crypto-assets carries a risk of losing all or part of the capital involved. Automated strategies can lose money faster than a person would, because they act without hesitation, including on a rule that was wrong. Leverage on futures increases losses as much as gains. Exchanges can go down, reject orders or change their APIs.

Backtests and paper trading describe how a strategy behaved, not how it will behave. Past results, backtested or live, do not predict future performance.

KryllOS is in early access and, like any software, can contain bugs, including in the way it handles orders. A strategy can also contain logic errors its author did not see. Running KryllOS on one’s own hardware makes the user responsible for its availability and its security.

The price of KRL can move sharply and can fall to zero. The marketplace that uses it is not open yet, and how it works may change before it opens. Holding KRL gives no right to Kryll’s revenue, assets or decisions, nor to any share of marketplace purchases.

KRL may lose its value in part or in full, may not always be transferable and may not be liquid. It is not covered by any investor compensation scheme or deposit guarantee scheme.

The owner account of the KRL contract on Ethereum can restrict transfers to a list of approved addresses. If it did, holders outside that list could not transfer their KRL.

Nothing guarantees that KRL keeps enough liquidity or trading volume on the platforms that list it, or that they keep listing it. Like other crypto-assets with modest volumes, its price can be moved by speculation or by manipulation, such as pump-and-dump schemes or wash trading.

KRL relies on smart contracts on Ethereum and on three networks built on top of it. A flaw in those contracts, in the networks or in the bridges that connect them could affect transfers or balances. Congestion raises fees and slows transfers, and network upgrades or forks can disrupt the token for a while.

The usefulness of KRL depends on KryllOS and its marketplace, and on Kryll’s team, which makes the decisions about both. If the project lost its funding, its users or its team, it could be scaled back or stopped, and KRL could lose its use.

Exchanges, VPS providers and AI providers are independent of Kryll. They have their own terms, fees, outages and risks, which apply to anyone who uses them through KryllOS.

The rules that apply to crypto-assets and to trading software differ by country and are changing. They may limit or change what KryllOS or the KRL token can do in some places, and it is up to each user to check what applies to them.

Everything this document describes as announced, planned, in development or under consideration is an intention, not a commitment. It may change, be delayed or never ship. This document will be updated as the product changes.

Agent Skills

An open format for packaging instructions that AI agents load on demand. KryllOS Skill uses it.

Backtest

A replay of a strategy against historical market data.

Block

One step of a strategy: a condition, an order, a calculation or a tool. Strategies are graphs of blocks.

Bridge

The official link between Ethereum and a network built on top of it, through which KRL moves from one to the other.

Custody

Holding funds on someone else’s behalf. KryllOS does not.

Custom block

A block that does not ship with KryllOS: written by the user, by an AI, or installed from the marketplace.

Kryll Embark

The portal that serves KryllOS builds to holders of an access key.

KRL

The Kryll token, an ERC-20 with a capped supply, used as the currency of KryllOS: in the marketplace and for its optional paid features.

Live trading

Running a strategy with real funds on a connected exchange account. Announced, not available yet.

Multi Backtest

A queue of backtests, run partly in parallel, whose results are read side by side.

Paper trading

Running a strategy against the live market in real time, with no funds behind it.

Self-hosted

Running on hardware the user controls, rather than on the provider’s servers.

Vibecoding

Describing a strategy or a block in plain language and letting an AI agent build it.

VPS

A virtual private server, rented from a hosting provider, on which KryllOS can run around the clock.