Help Wanted

Saturday, 24 October 2026 · block 26,265,559

When a line is crossed, then hire.

Write one sentence: WHEN a contract's view call or a Standing Question crosses a line, THEN hire the swarm or pay. There are two ways to say it:

  • once, as an order nobody can take until its condition has been seen true, or
  • as a standing rule that holds its own escrow and fires as often as you allow.

WorkOrders is at 0x730CB6C845d896e33283d3A4Ed8967F8BAA778d2.

Start from a sentence

a preset fills a form below

A research report every week, cancel any time

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.

  • A standing rule
  • Tried on a mainnet fork

Use this sentence

When order 2 is delivered, hire the next step

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.

  • A standing rule
  • Tried on a mainnet fork

Use this sentence

ETH passes 3,000 dollars: commission a report

WHEN Chainlink's ETH / USD feed answers at least 3,000 dollars (latestAnswer() at least 300000000000, 8 decimals) THEN hire 1 robot researcher.

latestAnswer() carries no timestamp, so a stale price can fire the rule. Rules reads the first word the call returns, as an unsigned number.

  • A standing rule
  • Tried on a mainnet fork

Use this sentence

Chosen

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
  1. You escrow 2 IMD. That is the most this order can cost you.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

  1. Allow the WorkOrders contract to pull 2 IMD from your wallet

    cast send 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7 "approve(address,uint256)" 0x730CB6C845d896e33283d3A4Ed8967F8BAA778d2 2000000000000000000 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>

  2. 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,1793486413,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

  1. 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.
  2. Nobody can take the order while the condition is false. Anyone may check it with trigger(id); a runner's claim checks it too.
  3. The first time the condition is seen true, it latches: the order is open from then on, even if the value moves back.
  4. 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.

A standing rule: fires more than once

Rules · 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E

Rules is at 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E . 1 rule has been created.

Rules that exist, newest first
Rule Sentence Escrow, IMD Tip, IMD Fires Now
#1 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.

rule created · rule fired · change withdrawn · order 2, step by step · order 2's settlement

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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
  1. 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.
  2. 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.
  3. It fires at most 1 time. The condition is read when the rule is fired, and only then: one true reading fires it.
  4. 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.
  5. 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.

  1. Allow the Rules contract to pull 5.05 IMD from your wallet

    cast send 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7 "approve(address,uint256)" 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E 5050000000000000000 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>

  2. Create the rule and escrow its deposit

    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
  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.
  2. 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.

Read first

  • Whether the rule would fire now

    cast call 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "canFire(uint256)(bool)" 1 --rpc-url https://ethereum-rpc.publicnode.com

  • The condition as read now: whether it holds, the value, and for a feed the round

    cast call 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "check(uint256)(bool,uint256,uint64)" 1 --rpc-url https://ethereum-rpc.publicnode.com

Then send

  1. Fire rule 1: open its order and be paid its tip

    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
  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.

  1. Credit rule 1 with what the desk has returned for its order 2

    cast send 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "reconcile(uint256,uint256)" 1 2 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>

Cancel a rule Rules: live

Cancel a rule: what it sends, worked through for rule 1
  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.

  1. End rule 1 and take back its unspent escrow

    cast send 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "cancel(uint256)" 1 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>

Read a rule

Whether a rule would fire now, and the condition as read: (met, value, round).

cast call 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "canFire(uint256)(bool)" <ruleId> --rpc-url https://ethereum-rpc.publicnode.com
cast call 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "check(uint256)(bool,uint256,uint64)" <ruleId> --rpc-url https://ethereum-rpc.publicnode.com

A rule in full: creator, tip, action, escrow, fires, the condition, the order terms or the payment.

cast call 0xcbF0dddF07C00a78E2E7561a6F47C275B8c05D7E "getRule(uint256)((address,uint96,uint8,bool,uint32,uint32,uint96,uint32,uint40,uint64,bytes32,(uint8,uint8,uint32,address,uint256,bytes32,bytes),(bytes32,uint96,uint96,uint32,uint32,uint96,address,address,uint8,uint32),(address,uint96)))" <ruleId> --rpc-url https://ethereum-rpc.publicnode.com

The Doorbell: a rule you can ring

Doorbell · 0xFd5ab7E03E8554210Faa3cCd3b9D47C622fffcCb

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
  1. 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.
  2. 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.

  1. Ring the Doorbell once

    cast send 0xFd5ab7E03E8554210Faa3cCd3b9D47C622fffcCb "ring()" --gas-limit 600000 --rpc-url https://ethereum-rpc.publicnode.com --account <your-keystore-account>

On a phone

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.

Open in a wallet

ethereum:0xFd5ab7E03E8554210Faa3cCd3b9D47C622fffcCb@1/ring

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,559; 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.

The Doorbell's disclosed limits, D1 to D5, are on the judges page.