Agent launch
Execution control
Robinhood Chain
Reading block
Build. Deploy. Automate.
Launch agents.Unlockautomation.
Write what an agent may do in one manifest, launch it with rules the contract enforces, and run it on your own machine. Every task is queued, checked, run or refused on the record.
What it is not: no hosted runners, no keys held by Launiq, no AI model included. Your runner signs with its own key; the rail only lets it call what your rules allow.
How it works01 / The manifest
Schema · illustrative
The studio writes the manifest and turns it into rules the contract enforces.
What Launiq is
LQ / 01
From one file to a running agent.
Write it once,
run it underits own rules.
An agent is a runner key on your machine plus a wallet the rail made for it. The manifest says which contracts and functions it may call, how much ETH a call may send, how often, and which calls wait for you.
The contract checks every call against those rules when it runs, not when it was planned. Change the manifest and the old rules stop working in the same block.
Open the agent launch studioa call is refused
Every refusal has a code and plain words.The runner reads it before it signs anything.
Contract: LauniqTaskRail, Solidity 0.8.28.
Tests and limits ↗
Execution control
LQ / 02
Approve theexact call.
Some calls should not run on the agent's word. Mark a rule or a task for approval and the runner can only propose: the exact call data and ETH value, hashed. You approve that hash from your wallet, and nothing else can run in its place.
Pause stops every task of the agent in the same block. Cancel ends one task. Both are one transaction.
01 / Proposals from the runner
02 / What the rail checks
Each proposal is checked against the rules on chain, not against what the agent says about it.
Example values, illustrative.
Live task dashboard / how a task moves
LQ / 03
How a task movesthrough the rail.
Three stages, each one an event on chain. The dashboard reads them; the replay page decodes them.
Pick a stage ↓
01
Queue
Queued with its limits.
A task names one allowed contract and function, the ETH it may send per run, a total budget, how many runs, how far apart, a gas limit and whether each run needs your approval. Tasks the runner queues itself always need approval.
- 01Arguments pinned by hash, or chosen at run time
- 02Token-moving calls with free arguments wait for you
- 03Interval and deadline in seconds, checked on chain
The task carries its own limits, so nobody has to remember them.
The parts
Three parts,all in the open.
Read how they fitTask rail
Agents, rules, tasks, approvals, failures. Deploys one wallet per agent, so agents never share funds.
Runner
Reads the queue, builds each call from the manifest, simulates it, then sends it with the runner key.
Integration hub
LQ / 04
What an agentcan reach today.
Four integrations work now. Each one is listed with how it is checked. Everything else is labelled planned until it runs.
Planned, not built: hosted runners, chat and email notifications, a library of shared manifests, other chains. Full list ↗
Step / 01
On-chain calls.
Any contract on Robinhood Chain, one function at a time. Each rule names the contract, the function and the most ETH a call may send. The agent's own wallet makes the call, so its tokens stay apart from yours.
1rule = { target, selector, maxValue }2check = rail.check(task, data, value)3if (check === 0) rail.execute(task, data, value)4else explain(check)
The point to check
The runner proposes; the contract decides.
Read live fromRobinhood Chain.
The figures below come from the chain through this site's relay, refreshed every few seconds while the tab is open. Nothing is typed in by hand.
Chain
Reading the chain…
Rail
Not deployed yet. The owner deploys it; until then the dashboard is empty and says so.
Tasks
Reading the record…
Limits
Written down,before you sign.
All limits- Limit · 13 Nov 2026The runner holds a key, on your machineLauniq hosts no runner today. The open-source runner signs with a key you create for it; keep only what the agent needs in that key and in the agent wallet.
- Limit · 13 Nov 2026The rules limit the runner, never the ownerYour wallet can pause, cancel, change the manifest or move anything out of the agent wallet at any time. That is on purpose, and it means your wallet is the real key.
- Status · 13 Nov 2026The contract is new and not deployed yetLauniqTaskRail has unit, hostile-target, fuzz and invariant tests, but no independent security review. Start with small amounts once it is live.
Questions and answers
Before you launch.
What does Launiq actually do?
It turns an agent's configuration into rules a contract enforces. You write a manifest (which contracts and functions the agent may call, how much ETH per call, which calls wait for you), launch it on Robinhood Chain, and run the open-source runner on your machine. Every task is queued, checked, run or refused on the record, and the dashboard shows it.
Does Launiq include an AI model?
No. Launiq is the launch, control and record layer. The runner in the repository follows the manifest step by step (fixed arguments, or numbers fetched over HTTPS). If you plug your own model or script into the runner, the contract still checks every call it produces.
Who holds the keys?
You do. Your wallet owns the agent. The runner signs with a separate key you create for it on your own machine. Launiq never receives either. The agent's funds sit in its own wallet contract, which only the rail can make call out, and only within your rules.
What can go wrong?
A rule that is too wide lets the runner do anything inside it: allow functions with fixed arguments where you can, and keep approval on for anything that moves tokens. A stolen runner key can run allowed tasks until you pause the agent. The contract is new and has had no independent security review; start with small amounts.
What happens when a task fails?
The failure is recorded on chain with the first 256 bytes of the revert reason. The replay page decodes it (error message, panic code, or the rail's own numbered refusal). Tasks you marked safe to repeat can be re-queued up to three times; others you cancel and queue again on purpose.
Is it live?
The contract is written and tested but not deployed yet. Until it is, the studio builds and checks manifests and the dashboard says there is no rail to read. Nothing pretends to be live.
Do I need $LAUNIQ?
No. Everything here works without it. $LAUNIQ is planned as credits for hosted runners and other paid services once they exist; that use is not built and not proven.