The roadmap
is a hypothesis.

Lain should watch the market while you sleep

The first step is giving Lain eyes. You show it the wallets, tokens and projects you care about. Then it keeps watching on its own.

›   Watch this wallet. Tell me when it starts building a new position.

›   Watch these ten addresses. Alert me if several of them start entering the same asset.

›   Every morning, tell me only what actually matters to my portfolio.

We do not need another crypto news feed. We need an agent that understands your context.

• Wallet monitoringIn progress
• Event-based alertsIn progress
• Portfolio-aware briefingsIn progress
• Lain keeps working while the user is offline

If a tool does not exist, Lain should build it

This is one of the most important ideas behind Lain OS. Imagine you need an unusual analysis:

›   Watch these 30 wallets and find tokens that at least 5 of them buy within 48 hours.

›   Ignore trades below $500.

Normally, that means API → code → server → cron → database → interface. With Lain, we want to reduce that to one request. It writes the tool, runs it and saves it for later. Over time, every user gets their own set of financial tools built around their strategy by Lain itself.

• Build tools from natural language
• Save and reuse them
• Modify existing tools
• Trigger them on schedules or events

From “I think I should buy” to an executable strategy

You describe a strategy in plain English:

›   Buy only if liquidity is above $500k, wallet X increased its position, and price impact is below 1%.

Lain turns that into rules. First, simulation, with no real money. We measure trades, results, maximum drawdown, fees and where the strategy failed. Only after that can the user allow real execution under strict limits and a kill switch. The goal is not to build an AI casino. The goal is to let people program financial behavior in natural language.

• Natural-language strategies
• Paper trading
• Simulation
• Risk limits
• First controlled live trade executed by Lain

Lain should protect money, not only make it

The more an agent can do with capital, the more important security becomes. We want to give Lain code and say:

›   Find the problem. Reproduce it safely. Fix it. Test it again.

We will start with our own software. Then CTFs. After that, authorized bug bounty programs. We want the full cycle: find → prove → fix → verify.

• Security sandbox
• Audit our own code
• First real issue found and fixed
• First CTF completed with Lain
• Public write-up

We want to know the real cost of AI work

AI feels cheap until you start running agents continuously. Lain should choose the route automatically, and the user should see the true inference and final cost.

›   Task completed · Inference cost: $0.06 · Final cost: $0.09

We want to compare models using a simple formula: quality / speed / price.

• Multiple AI providers
• Automatic model routing
• Measurable cost for every task
• Free and paid usage
• First real payments inside Lain

LAIN should be used because the product is being used

This is the core principle behind the token. We do not want to invent utility separately from the product. Useful work consumes AI, compute, monitoring and infrastructure. That work can be paid for through LAIN.

›   task → work → known cost → payment → verifiable result

For us, the first real paid task matters more than a million words about token utility.

• First real AI workload paid through the LAIN economy

The first external GPU

Today, Lain buys compute from large AI providers. We want to test another model: someone owns a GPU, they connect it to Lain, Lain sends a job, and the machine owner gets paid.

We do not need a global decentralized AI marketplace yet. First we need to prove that one external GPU can perform one useful paid task.

• External GPU connected
• Received a real workload
• Completed it
• Received payment