WHEN always (IMD's decimals() is at least 0) THEN hire 1 robot researcher, at most once a week, 4 times. An order's pay is spent only on a week whose report is delivered; cancel any time and take the rest back.
Nothing fires it by itself: anyone may fire it each week for the 0.01 IMD tip, and the team hosts no keeper that does. The tip is spent every week; an order nobody delivers is refunded to the rule. The job text is the same every week.
WHEN order 2 on the hire desk is Delivered (stateOf(2) equals 6) THEN hire 1 robot illustrator for its cover. Put your own order's number in place of 2.
Delivered also covers an order paid on a bonded claim nobody challenged; only on an order that pays on a receipt alone does it mean the work was proven. Someone must fire the rule once the order is delivered.
Tried on a fork of mainnet on 20 October 2026 with these exact values: created, checked, fired where the condition held (the price line was not crossed that day; the same rule at 2,000 dollars fired), the order it opened taken back, the rule cancelled and its unspent escrow refunded to the wei. Not yet run on mainnet itself.
Write the rule
an order with a condition, on the hire desk
Say when, once WorkOrders: live
The form and the wallet button need JavaScript. Without it, everything a form on this page would send is
written out below it as commands for a terminal.
Say when, once: what it sends, worked through
for an example that watches the IMD token itself
You escrow 2 IMD. That is the most this order can cost you.
Nobody can take the order until 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7 has been seen to answer a value that is at least 1000000000000000000000000. Anyone may check it; once seen true, it stays open.
The price starts at 1 IMD and rises to 2 IMD over 1 h. The first runner to take the order fixes the price at that moment; the rest of your escrow comes back.
Of the fixed price, 5% is the fee (at most 0.1 IMD: half to sIMD stakers, 30% to seat owners, 20% to the feeds), 5% is a tip to the seats of the agents the job's work record names, and the runner keeps the rest, out of which it pays the swarm's 0.5 IMD.
A runner must post a bond of 0.25 IMD to take the order, and then has three days for the job's receipt to exist.
Only an on-chain receipt pays. If IdentityMD's receipt for the job has not been written by the delivery deadline, the order times out and your escrow comes back.
If nobody has taken the order after 7 d, anyone can send the whole escrow back to you. Until a runner takes it you can withdraw it yourself.
Allow the WorkOrders contract to pull 2 IMD from your wallet
Open the order: the desk pulls the escrow and pins the job text
cast send 0x730CB6C845d896e33283d3A4Ed8967F8BAA778d2 "createOrder((bytes32,uint96,uint96,uint32,uint32,uint40,uint96,uint8,address,address,address,bytes4,bytes32,uint8,uint256),bytes)" '(0x7679ff00d2b015b122f4c00147c1004ea6657aada5fff65e72986b90c6869185,1000000000000000000,2000000000000000000,3600,259200,1793486406,250000000000000000,0,0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000,0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7,0x18160ddd,0x0000000000000000000000000000000000000000000000000000000000000000,1,1000000000000000000000000)' "$(cast from-utf8 'Make one square picture celebrating a token reaching one million in supply. No text in the picture.')" --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>
Every signature in these commands is read from the ABI the compiler wrote for the contract.
How it works
once true, always open
You write one sentence: WHEN a contract's view call compares true against a number, THEN hire. It becomes an order on the hire desk with a condition attached, and your IMD is escrowed.
Nobody can take the order while the condition is false. Anyone may check it with trigger(id); a runner's claim checks it too.
The first time the condition is seen true, it latches: the order is open from then on, even if the value moves back.
From there it is an ordinary order: a runner takes it, the swarm works, and the escrow pays on proof (or on a bonded claim, only if you allowed one). If it never comes true before the order expires, the escrow returns to you.
The limits
The condition is one staticcall, capped at 100,000 gas, that must return at least 32 bytes. Its first word is compared as an unsigned number.
The call takes no argument, or exactly one 32-byte argument.
A condition that reverts or runs out of gas counts as false.
A conditional order fires once, and latches on one true reading: a condition a caller can make true for the length of one transaction lets that caller open the order.
WHEN the newest answer of feed 0xfde22d9c… at 0xeece4628ceb091c13393fc64056be8b8501fd3f6 is at least 100, THEN open an order paying up to 0.6 IMD.
0
0.01
1 of 1
cancelled
Rule 1 is the team's own. House wallet H1 created it on 16 October 2026 (block 26,204,482) and fired it by hand in block 26,204,499: the hires feed read 223, and the fire opened order 2 on the hire desk (/orders/2). The desk paid order 2 on its receipt in block 26,204,543. H1 then cancelled the rule and took back the 0.03995 IMD the order returned (block 26,204,586). Anyone may fire a rule whose condition holds; this time our own wallet did. This is HOUSE use, not outside use.
A rule is a sentence a contract keeps for its creator: WHEN a condition holds, THEN hire or pay, from the rule's own escrow.
The condition is a view call on any contract (a selector and up to four words of stored calldata), or the newest answer of a Standing Question, no older than the creator said.
Anyone may fire a rule whose condition holds. The rule reads the condition itself, opens its order on the hire desk (the rule is the employer) or makes its payment, and pays the caller the tip its creator set.
What the desk later hands back for an order (a refund, the change of a delivered job, a forfeited bond) returns to the rule through reconcile. A rule that asked for the desk's callback gets a delivered order's change inside the settlement.
Only the creator can cancel a rule, and takes back whatever it has not spent.
The limits
A condition is read when the rule is fired, and only then. One true reading fires it; there is no latch and no second look, and a PAY rule's money moves in that transaction.
Any view condition is accepted, including one a caller can make true for the length of one transaction (a spot balance, a pool price). What that caller can gain is bounded by the rule itself: the tip, and an action whose recipient or order terms the creator fixed.
A FEED rule believes its source: the creator names the contract that is asked for the answer. It fires at most once for each newly answered round, and a failed round is not a new answer.
A tip is paid for every fire, whatever becomes of the order: cooldown and the maximum number of fires are the creator's limits on that.
With the claimed-path flag, the creator accepts the desk's bonded claims for every order of the rule. Rules never challenges and never arbitrates.
The job text of a HIRE rule is public from the moment the rule is created, and fixed for every order the rule opens.
Write one
The example is a rule on a view call, the one launch C's launch document gives in section 6: when the
IMD staked in sIMD reaches two million, hire a report on who staked it. The fire and reconcile examples
name rule 1 as it is on mainnet: its job text, and order 2, the order it opened.
Write a standing rule Rules: live
Write a standing rule: what it sends, worked through
for a rule on a view call, from launch C's launch document
WHEN totalAssets() on 0x9Efa934D9fAd4AE28c998a40195646b965a97247 is at least 2000000000000000000000000, THEN open an order for 1 robot researcher (kind skill:research-report) paying 2 to 5 IMD.
Anyone may fire the rule while that holds and is paid the tip of 0.05 IMD from the rule's escrow. One fire costs the rule 5.05 IMD; you deposit 5.05 IMD.
It fires at most 1 time. The condition is read when the rule is fired, and only then: one true reading fires it.
Each order the rule opens pays only on an on-chain receipt. While IdentityMD's receipts are late such an order is not paid and ends in a refund, which returns to the rule; the tip of the fire that opened it is spent.
You, and only you, can cancel the rule at any time and take back what it has not spent. Nobody else has any power over it.
Allow the Rules contract to pull 5.05 IMD from your wallet
cast send 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "createRule(((uint8,uint8,uint32,address,uint256,bytes32,bytes),uint8,(bytes32,uint96,uint96,uint32,uint32,uint96,address,address,uint8,uint32),(address,uint96),uint96,uint32,uint32),bytes,uint96)" '((1,1,0,0x9Efa934D9fAd4AE28c998a40195646b965a97247,2000000000000000000000000,0x0000000000000000000000000000000000000000000000000000000000000000,0x01e1d114),1,(0x1eca772919112a33a7f2dec9335cff7b36a9ebb94160fa9a3c07556d47f2988b,2000000000000000000,5000000000000000000,86400,259200,250000000000000000,0x0000000000000000000000000000000000000000,0x0000000000000000000000000000000000000000,2,1209600),(0x0000000000000000000000000000000000000000,0),50000000000000000,0,1)' "$(cast from-utf8 'Write a two-page plain-language report on who staked IMD in the thirty days before the sIMD staking vault first held two million IMD, from on-chain deposit events of the vault only, with every figure sourced to a transaction.')" 5050000000000000000 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>
Fire, reconcile, cancel
Fire a rule Rules: live
Fire a rule: what it sends, worked through
for rule 1
Anyone may fire a rule whose condition holds. The rule opens its order or makes its payment from its own escrow and pays you its tip.
The rule reads its condition with a fixed allowance of 100,000 gas and refuses to start with less than about 122,000 in hand, so the call is sent with the limit above. If the condition does not hold, it reverts and costs only gas.
cast send 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "fire(uint256,bytes)" 1 "$(cast from-utf8 'Write a one-page plain-language report on who paid the IdentityMD swarm'\''s job fee in the last 7,000 Ethereum blocks before this job started, from IMD Transfer events to the fee payee 0x4e0fA57Bde726079356537E2F34d671E9F41ADbc only, with every figure sourced to a transaction.')" --gas-limit 700000 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>
Return an order's money to its rule Rules: live
Return an order's money to its rule: what it sends, worked through
for rule 1
Anyone may do this. What the desk has handed back for the order since the last call (a refund, the change of a delivered job, a forfeited bond) returns to the rule's escrow, read from the desk's own books. For a cancelled rule it goes to the creator.
Credit rule 1 with what the desk has returned for its order 2
Cancel a rule: what it sends, worked through
for rule 1
Only the rule's creator can do this. The rule ends for good and its unspent escrow goes to the creator. Orders it already opened stay on the desk; what they return later is sent to the creator by whoever calls reconcile.
The Doorbell is a contract with no owner and one job text in its own code. Anyone calls ring(). Every 25th ring, if it holds enough IMD, it opens an order on the hire desk: a contract hiring the swarm, on demand.
The 50th ring hires the swarm for a picture of the day only if the Doorbell holds 1 IMD by then, paid from its own IMD; it does not hold it now. The order pays its runner on proof, the job's receipt on chain, or on a bonded delivery claim nobody challenges for 24 hours, the path a runner takes while IdentityMD's receipts are late.
One ring costs about 0.00000095 ETH in gas now. That is an estimate: 28,788 gas (estimateGas of ring()) at 0.033 gwei (the network's gas price), read for this page. A ring sends no ETH and no IMD.
Ring the Doorbell Doorbell: live
Ring the Doorbell: what it sends, worked through
with example values
Anyone may ring. Every 25th ring, if the Doorbell holds enough IMD, it opens an order on the hire desk from its own code: a contract with no owner hiring the swarm.
A ring that hires uses about 354,000 gas, so every ring is sent with a limit of 600,000; what is not used is returned.
Open the link in a wallet app on your phone, or scan the code with one. It asks your wallet to call ring() on the Doorbell on Ethereum mainnet; you pay only the gas.
The link is an EIP-681 request. A wallet that does not read one may open nothing: open this page in the wallet's own browser and use the key above instead.
Where it stands
To hire again it needs 1 IMD and 24 more rings: it holds 0 IMD, and one order escrows 1 IMD.
24 rings until the next hire. It has been rung 26 times, and it has hired 1 time. The contract counts every ring (rings()), and each ring's Rang log names who rang.
Every order it opens pays 1 IMD: the bottom and the top of its price range are the same amount (MIN_PAY() and MAX_PAY(), read from the contract), so the price does not rise while an order waits and the escrow of an order is its price.
It is not funded: it holds 0 IMD and one order needs 1 IMD, so a 25th ring that comes now is counted and hires nothing. Anyone may fund it with a plain IMD transfer; what it holds can never be withdrawn and leaves only as the escrow of its own orders.
Its orders pay on a receipt, or a bonded delivery claim nobody challenges within 24 hours (fixed when it was launched).
With the claimed path on, everything it holds is open to delivery claims that nobody challenges: that is launch B's disclosed limit D2, on the judges page. An untrue claim nobody challenges within 24 hours is paid from it. No watcher is running: the team runs nothing that watches the Doorbell's orders to challenge an untrue delivery claim. Its keeper (bots/keeper) can challenge one, but it is run by hand, not hosted (the team's statement, 16 October 2026). Fund it with small amounts.
The order it opened last is number 1 on the hire desk.
A runner that takes one of its orders posts a bond of 0.25 IMD, and the delivery time is 7 d (BOND() and DELIVERY_SECS(), read from the contract).
Who rang
Of the 25 rings whose log was read (blocks 26,184,821 to 26,265,554; the logs of the first 25 are older than the public RPC serves, so they were read from the chain on 15 October 2026 and are kept with this site), 25 were sent by our own wallets (HOUSE) and 0 by others (OUTSIDE). The logs of 1 other ring are older than this server could read, so it is not split.
No ring from outside the team has been read yet. The first will be listed here, with its address and its transaction.