1. Question restated

Is CLAUS CREW worth building and launching within 14 days on IMD or CLAUS, and, if so, what is the smallest version that proves agents create verifiable onchain value and identifies its day-one payer?

Evidence convention: Record means an observed API response, chain read, or source-code property; Claim means a publisher's assertion not independently established here; Inference includes recommendations, proposed parameters, calculations and estimates. All labels and figures in this report have read date 2026-10-23 UTC, including table cells and formulas. Dates of events and commits are stated separately. A source's presence proves neither adoption nor economic independence. Proposed quantities are experiment choices, not market measurements.

2. Verdict in five lines

Inference — gap: partly served; NO to launching CLAUS CREW under all seven requirements. Paid agent markets exist; a demonstrated need for a second NFT seat network does not. Inference — speed to MVP: a 10-day, fork-only falsification experiment fits inside 14 days; a compliant live launch is not established. Inference — MVP: compare one AI-generated recovery call sequence with a deterministic keeper, then independently rerun it against a fixed-recipient balance postcondition. Inference — biggest failure: payout calls and census signing need ordinary code; neither NFT ownership nor rerunning establishes additional AI value or independent control. Inference — total IMD cost: 0 IMD further for the no-launch decision; optional experiment ceiling 2 IMD = three jobs × 0.5 plus one oracle × 0.5, excluding this assignment, gas and agent rewards.

3. Competitor table with at least five rows

The status column describes the observed product, not every feature on its roadmap. Last activity is the latest repository commit retrieved from GitHub's default-branch API, not a claimed last customer transaction. Commit pins are restated in section 13.

Name and primary links	Chain	Status, evidence grade	Last activity date, Record	Overlap	What it misses for this brief, Inference unless stated
Olas Mech Marketplace, contracts	Ethereum, Gnosis, Base, Polygon, Optimism, Arbitrum and Robinhood appear across deployment files/product pages; the client documents a narrower supported subset	Live, Claim in docs; Record: marketplace proxy bytecode exists on Ethereum and Robinhood at our pins	2026-10-22, contracts	Requesters prepay; specialist agents deliver results and receive onchain payment; requester choice and failover already exist	No demonstrated CLAUS-specific recovery postcondition, independent rerun-before-payment, or Uniswap v4 enforcement in the inspected marketplace. These are differences, not claims it cannot support them
Bittensor, runtime	Bittensor/Subtensor	Live, Claim in official docs; Record: public runtime implementation; no chain activity census performed	2026-10-23, runtime	Miners supply intelligence; validators score it; consensus determines rewards	Emissions and stake-weighted scoring are not a customer's escrow for a specific CLAUS chore. A subnet creates an incentive-design problem rather than solving the first paying job
Daydreams Task Market, contracts	Base in current product; Tempo also shown in live task listings; latest settlement revision documents Base Sepolia and Tempo Moderato	Live marketplace, Claim supported by browseable delivered task records; latest revision is testnet, not assumed live on mainnet	2026-10-23, contracts	Funded tasks, worker competition, evaluators, stakes, settlement; sponsored-task vaults directly overlap a fee-funded crew budget	Requester/evaluator and relayer trust remain. Its task hooks are not Uniswap v4 hooks. Security documentation explicitly describes relayer and upgrade boundaries
Virtuals ACP, architecture, current SDK	Base mainnet confirmed by official deployment listing and our code read; SDK supports additional networks	Live, Claim in docs; Record: listed Base core has bytecode at our pin	2026-10-05, SDK	Client/provider/evaluator roles, escrowed budgets, completion/rejection and pluggable job hooks	Evaluator acceptance is not necessarily an independent deterministic rerun. ACP's beforeAction/afterAction are job hooks, not v4 swap callbacks
POD, sandbox	Monad testnet, Claim	Testnet, Claim; publicly inspectable implementation, not a verified mainnet business	2026-10-13, repository	Closest design: separately owned seats, deposits, exact commits, signed checks and independent repeatability; later contracts let the poster accept/refuse	A rerun proves agreed checks, not usefulness. Current README says the later contract was used; its contracts README still says it is undeployed. No production deployment or independent operator census verified

Inference: Do not compete on “agents can get paid.” Compete, if at all, on a narrow, independently reproducible improvement to CLAUS operations, with customer money committed before work. POD is a pattern to inspect, not a drop-in security guarantee. Multiple NFT owners can still share a model provider, operator or beneficiary. The verdict also rests on verified CLAUS contracts and direct chain reads below, not any competitor's marketing or an X post.

4. Hook spec: callbacks and permission flags, hookData schema, fee math with one worked example, invariants, admin surface

Record — verified live scope. Ethereum CLAUS token is 0x1b54E762aa34CF6E28E9C082F2848e28E45DA6b8; hook is 0x37Bfb8AC7C960E558657871D41Ca70E07e7DbfFf; extension host is 0xea0436465676eA7001535Bfe2E5cbd4b137b7f91. The hook proxy resolves to 0xa62f9b597225779b430024398B70374E8468Ce14. Sourcify's matched source runtimes were compared byte-for-byte with pinned chain code for the proxy, implementation, host, token implementation, governance, active adapter and compute collector. This is source verification and read-only inspection, not an audit. Hook proxy, ProtectedHook, host.

Record — every live callback and flag. The address's low permission bits are 0x3fff = (1 << 14) - 1, so all callback and return-delta flags are enabled. This must not be confused with the much smaller set a new implementation would need. Pinned Uniswap flag definitions, interface.

Live v4 callback	Permission bit, Record	Purpose in inspected source, Record
beforeInitialize	1 << 13	Validate the original initializer, token, opening price and canonical pool parameters; one initialization
afterInitialize	1 << 12	Set dynamic LP fee to zero
beforeAddLiquidity	1 << 11	Inherited manager-checked acknowledgement
afterAddLiquidity	1 << 10	Inherited acknowledgement, zero hook liquidity delta
beforeRemoveLiquidity	1 << 9	Inherited manager-checked acknowledgement
afterRemoveLiquidity	1 << 8	Inherited acknowledgement, zero hook liquidity delta
beforeSwap	1 << 7	Quote module; pin transient fee plan; calculate specified-side hook delta
afterSwap	1 << 6	Account fees and ceiling; inherited processing; record trade for original module; clear transient plan
beforeDonate	1 << 5	Inherited manager-checked acknowledgement
afterDonate	1 << 4	Inherited manager-checked acknowledgement
Return-delta flags, not extra callbacks	1 << 3, 1 << 2, 1 << 1, 1 << 0	Respectively before-swap, after-swap, after-add-liquidity, after-remove-liquidity return deltas

Record — hook rules versus job rules. TradeExtensionHost.quote static-calls the selected module with bounded gas and validates six allocations whose sum cannot exceed 149,000 pips. The permanent core checks the aggregate tax ceiling of 150,000 pips. record authenticates the hook. execute later consumes an original receipt outside an unlocked PoolManager and calls the original module; failure reverts that delivery, not the completed swap. onTrade is a module callback; unlockCallback is a PoolManager unlock callback. Neither is an additional v4 hook-permission callback. There is no live “independent seat reran this work” gate in the permanent hook.

Record — sender and hookData. PoolManager forwards its caller as sender: ordinarily a router, not the end trader. The host passes this sender and arbitrary bytes hookData to quote, and commits keccak256(hookData) in its receipt. It rejects data longer than 4,096 bytes. Empty data works. A bare address in hookData and tx.origin are not authenticated trader identities. Uniswap's caller forwarding, verified host.

Inference — smallest experimental schema: swap hookData = bytes(""); all fees are uniform; nobody is metered as a trader. Job submissions use a separate typed message containing jobId, chainId, consumer, specHash, stateBlockHash, artifactHash, callsHash, operator, payout, nonce, deadline. This avoids introducing trader signatures, router allowlists or a venue lock. Any future trader discount would require an EIP-712 authorization binding the trader, authorized router, PoolId, direction, amount bounds, nonce and deadline, plus router-side verification that its authenticated payer is that trader. That integration is outside the experiment.

Record — current fee economics. The fee-state snapshot reports a total of 23,000 pips of gross ETH, or 23,000 / 1,000,000 = 2.3%, with wallet 12,000, compute 1,000, burn 1,500, reserve 2,000, NFT 3,500, platform 3,000; their sum is 23,000. LP rewards are paused and their current allocation is zero. The reserve is not a current payment to LP stakers. The active module is an adapter, not the compute collector directly. Verified adapter.

Inference — worked example using the recorded plan, not observed volume: for a gross exact-input buy of 1 ETH, total hook charge is 1 × 23,000 / 1,000,000 = 0.023 ETH, leaving 0.977 ETH for the pool-side swap before price impact. Allocations are wallet 0.012, compute 0.001, burn 0.0015, reserve 0.002, NFT 0.0035, platform 0.003 ETH; sum 0.023 ETH. This assumes no additional protocol fee and is not an all-in quote. Exact-output buys require gross-up, approximately net / (1 - 0.023); actual integer rounding follows the pinned FeeMath. No additional crew surcharge is proposed. A funded crew would need an authorized reassignment of existing proceeds, not another fee on top.

Inference — required experimental invariants: ordinary transfers remain exact; no mint or blacklist; other venues remain usable; swaps never wait for a model, reviewer or oracle; jobs spend only prefunded escrow; no duplicate job/receipt payment; payout recipients are bound before execution; a failing postcondition reverts target calls and reward credit atomically; royalty/LP liabilities cannot fund jobs; expired jobs refund only unearned escrow. Fee collection is not proof that useful work occurred.

Record — admin surface, decisive failure. The core freeze is real: the hook admin's ownership was renounced at Ethereum block 26,197,788, 2026-10-15T12:03:11Z, transaction renunciation. Current admin owner() returns the protocol's null-owner value. This is observed state, not a placeholder address. However, token owner() now returns governance 0x180eae784dee739fbab432b06f78bf9a98aae334. Its verified code allows the operator to switch approved adapters immediately, the founder to change operator immediately, and the founder to start return of token control. No time delay is enforced in these paths. A two-step ownership transfer is not a timelock. Governance, protected token implementation.

Inference — a compliant counterfactual, not the live system: use a new immutable CrewHook with beforeInitialize, beforeSwap, afterSwap, before-swap-return-delta and after-swap-return-delta enabled: mask 0x20cc = 8192 + 128 + 64 + 8 + 4; all other flags false. The hook owns the prefunded job ledger and an external executeJob entrypoint verifies signatures/postconditions outside swap callbacks. Only fee rules run inside swaps. Existing CLAUS could trade in this optional new pool without restricting transfers elsewhere; existing fees would not automatically follow it. Use no admin key for this new hook; job sponsors only choose terms for their own deposits. Adapting the frozen hook cannot add this entrypoint. If CLAUS instead keeps its existing module lane, every relevant governance/recovery path must migrate behind a verified delay of at least 24 hours = 86,400 seconds, with no founder bypass. Neither migration nor new pool adoption is approved or proven here.

5. Agent spec: signatures, pinned question, verification before pay, payments and failures

Inference — choose the smallest job honestly. The smallest objective live chore found is calling claimActive(amount) on the compute collector: it burns the collector's already accrued PoolManager claims and pays its immutable beneficiary. The caller cannot choose a recipient. A wrapper can measure the claim balance decrease and recipient ETH increase atomically. That is verifiable today, but a plain keeper can do it. It is therefore a useful baseline and fails hard requirement 1 as a CREW product. Verified collector.

Record — census baseline actually checked. Two Initialize log filters, from genesis through Ethereum block 26,257,499, selecting CLAUS as currency0 or currency1, returned 216 + 35 = 251 distinct PoolIds at canonical PoolManager 0x000000000004444c5dc75cB358380D2e3dE08A90. Deduplication used transaction hash/log index and separately checked unique PoolIds. Exactly one initialization uses the CLAUS hook. This is a census of initialized v4 pools at that manager, not funded pools, active markets, v2/v3 pools, other managers or other chains. Raw queries/results are in research/pool-initializations.json; event semantics are in the pinned PoolManager interface source. Signing the census adds provenance, not intelligence. A contract cannot infer complete historical enumeration from a signed list alone.

Inference — only credible AI hypothesis to test: given a previously unseen, verified CLAUS-related fee-program interface and a pinned state, an agent synthesizes the missing bounded recovery-call sequence from source and ABI, while a precommitted generic keeper fails to produce it. Execute only against sponsor-authorized targets/selectors with an immutable proceeds recipient and a minimum recovered-value condition. Do not give the agent arbitrary treasury authority. If all available cases reduce to known selectors, use the keeper and stop. This is an operational hypothesis about handling new interfaces, not proof that software in principle cannot perform the task. No qualifying instance was demonstrated during this research.

Inference — identities and signatures: NFT holders sign a seat-key authorization binding NFT contract/tokenId, ERC-8004 agentId, operator, payout destination, expiry and nonce. Check current ownership when accepting a job; a transfer invalidates unused authorization. Worker's EIP-712 signature binds the exact job/spec, source and execution hashes. A different controller's reviewer signs that same digest after recreating the result; the reviewer cannot be the worker, sponsor or their declared payout beneficiary. Same-controller exclusion is a necessary check, not proof of disinterest. Freeze membership and payout for each accepted job so an NFT transfer cannot steal a pending reward. Existing IMD workers may supply bids through this adapter; automatic IMD admission to another network was not verified.

Record — oracle functionality verified, trust not erased. IMD's public API returned one EIP-712 OracleAttestation and one signature for request 6faa93d8-edc2-4a44-be4e-fbeafdf43fa8, attested 2026-10-23T18:58:46.234Z. Local cast wallet verify --data --from-file recovered the advertised attester after normalizing the API's answerType: "bool" to its specified enum value 0. This verifies the signature, not the underlying question's truth or panel independence. The panel members do not each supply a separately contract-checked signature. Actual attestation, oracle request interface.

Inference — exact yes/no question template, frozen before a trial: “At the pinned Ethereum state block and under the attached immutable job specification, does artifact H provide a reproducible call sequence that increases the specified fixed recipient's ETH balance by at least the specified minimum, preserves every stated liability and authorization invariant, and succeeds on the held-out case on which the precommitted keeper baseline fails?” H, state-block hash, baseline hash, target code hashes and minimum come from the accepted job record; these are unresolved deployment-time inputs, not invented identifiers. The expanded document's canonical hash is pinned before paying for a question. Answer type is bool only. There is no numerical oracle question in the proposed experiment.

Inference — verification and payout sequence:

• Sponsor prefunds both worker and independent verification budgets before bidding. Bonds are separately accounted CLAUS collateral; no specified bond amount is economically justified yet. For the fork experiment use accounting variables and real historic prices only if available, not a guessed mainnet bond.
• Worker commits its sequence and artifact; reviewer independently reconstructs it in a fresh, network-isolated fork at the same block. Compare outcome and invariants, not identical model wording. Reviewer commits before seeing another reviewer's result.
• The execution wrapper accepts only the exact authorized sequence, snapshots fixed-recipient balance and liabilities, runs bounded calls, and requires the postcondition atomically. Payout credit is created only after success. Calls that cannot be measured atomically are ineligible for the first job class.
• In the optional oracle trial, require the pinned attester and exact domain/consumer, requestId, questionHash, bool encoding, chain/window/blockHash, quorum, issue/expiry times and unused nonce. Require the same artifact and spec hashes in the question. A valid signature for another consumer or question is worthless. Expired/no-quorum/ambiguous results cause no worker payment and eventual refund.
• Credit worker and reviewer to prebound pull-payment balances after acceptance; withdrawal is separate so recipient failure cannot break settlement. No bounty for a failed worker delivery. Verification work may have its own prefunded, verifiably delivered receipt; do not pretend honest reviewers can always be unpaid on rejection. A stolen sequence must not steal the worker's credit.

Inference — failure modes: false-positive tests; a malicious sandbox; RPC omission or reorg; shared controllers; reviewers copying work; replay and expired signatures; oracle-signer compromise; ETH balance changes caused by the worker donating its own ETH; flash-funded “recovery”; claim accounting rounded into dust; reverting recipients; jobs manufactured by insiders to farm fees; and CLAUS bond price falling during a dispute. Exclude donation- and wash-generated gains by tracing the authorized claim debit as well as recipient credit. Onchain success does not establish that AI was necessary; compare with the baseline separately. Slash only objectively provable faults such as conflicting signed outcomes for the same immutable job, not model disagreement. No zero knowledge component is proposed: proving execution would still leave oracle truth and controller independence unresolved.

Inference — seven hard gates, applied without waivers:

Requirement	Current decision	Reason / what would change it
AI does onchain work plain code cannot, paid onchain	FAIL	Existing claim/census work is deterministic. Novel-interface synthesis and incremental value are unproven
v4 hook enforces rules; callbacks named	FAIL for live CREW	Existing hook enforces fee accounting, not job acceptance. A task-module callback alone does not meet the strict hook requirement; counterfactual hook specified above
No transfer fees/restrictions/venue locks/postlaunch mint	PASS for inspected current token surface	ProtectedToken uses ordinary ERC-20 accounting, burn and metadata; no new token proposed. This is source inspection, not a historical full-system audit
No admin or at least a 24-hour timelock	FAIL	Frozen core coexists with immediate governance/module changes and founder recovery
Fair opening, snipers and bundles addressed	NOT PROVEN	No new asset sale in experiment. For any later market opening see below; the historical launch is not retroactively certified
Holder/LP rewards without killing volume	NOT PROVEN	Burn/NFT allocations exist, LP payout is paused, and no causal volume/fee sensitivity study was established
ZK only to remove trust, optional	PASS	None used; do not attach a proof to a still-trusted oracle and call the result trustless

Inference — fair opening: the experiment issues no token, NFT or discounted buy allocation, so sniping or bundling buys cannot obtain privileged job rights. Buying more CLAUS is not an admission credential. Collect sealed job bids over a preannounced window and reveal before selection; do not reward first transaction position. Controller screening remains a limit. If an optional new pool is ever opened, publish terms and start block in advance and use a prefunded batch opening at a uniform clearing price rather than privileged first-block purchases; count all bundled orders in that batch, with no per-wallet cap masquerading as Sybil resistance. Existing CLAUS trading elsewhere cannot be stopped, and builders can still trade those venues. No auction implementation or fairness proof was verified here; it is a launch prerequisite, not an achieved feature.

6. Economics: day-one payer, unit costs and break even

Record — money exists, but authority matters. Collector 0xa25ca2d2521aa47b6cc84b28be66e8fc7a1b768e had 369,233,351,306,046,421 wei / 10^18 = 0.369233351306046421 ETH of redeemable claims at our Ethereum pin; its other reported balance was zero. active() binds the operator 0xAB716305E5A8854c0DD08397087dbDD56eA32073. The current fee JSON reports the same amount and automaticProviderPayments: false. This is not the crew's treasury and is not evidence of agreed spending. Verified collector, fee snapshot.

Inference — who pays on day one: only the CLAUS operator, if it explicitly prefunds the experiment from its permitted compute budget or its own funds. Its motive is recovering proceeds or avoiding a demonstrably costly missed operation. Holders and LPs are not presumed customers; a permissionless claim caller does not acquire the right to skim the claim. No customer commitment, escrow deposit for CREW, quote for model/reviewer labor or willingness-to-pay was found. Therefore there is no verified day-one payer today. Without that commitment, spend no further IMD and do not launch. IMD is the procurement venue, not an assumed subsidy.

Record — platform unit costs and cadence. Capabilities lists jobs, launches and oracle requests at 500000000000000000 / 10^18 = 0.5 IMD each; scheduled runs are priced individually. Floors are 10 minutes for oracle runs and 30 minutes for job runs. These are not fast liquidation or MEV execution rails. Live capabilities.

Inference — auditable break-even, in ETH rather than guessed dollars: let p be ETH paid per IMD at procurement; W worker compensation; R independent verification compensation; G measured gas × effective gas price for job execution, oracle submission if any and withdrawals; C other incremental compute/storage not already in W/R; and F/N amortized fixed setup cost per accepted job. Then:

c_job = 0.5p + W + R + G + C + F/N.

If every job also buys an oracle, c_job_oracle = c_job + 0.5p + incremental oracle gas. Do not add the workers' own model expenses again when their quote already includes them. An all-IMD rerun procured as another paid job adds another 0.5p; an externally hired reviewer belongs in R. Expected revenue for a job must cover failures too: if acceptance probability is a, cost per accepted outcome is cost_per_attempt / a, plus any acceptance-only payments.

Inference — fee-funded ceiling: if the operator assigned the entire recorded compute slice, its gross inflow would be 0.001 × V ETH for gross canonical-pool ETH volume V. Before gas/other compute spending, at most J × c <= 0.001V, hence V_break_even >= 1000 × J × c. If only fraction s of the slice is authorized, V_break_even >= Jc / (0.001s). This derivation assumes the recorded plan persists and money is actually collected; it excludes the wallet, NFT and paused reserve shares. A one-time claim balance is runway, not recurring revenue.

Inference — customer and operator tests differ: customer recovered value U should exceed its full job spend and incremental risk; worker W must cover its own compute and opportunity cost; reviewer R must cover a fresh rerun. No measured p, gas distribution, recurrent missed-payout value, W or R was established, so a numerical profit forecast would be invented. A conventional keeper's gas-plus-margin is the relevant price ceiling for deterministic claims. Keep the aggregate fee unchanged during the experiment; that avoids an incremental swap tax but does not prove the existing fee is harmless to volume.

7. Home fit: what IMD or CLAUS must provide or approve, and if they say no

Record — IMD launch facts verified with limits. Capabilities enables custom hook-token launches on Ethereum and Robinhood, as well as Sepolia; custom-token hooks are enabled. Docs require fixed postlaunch supply and ordinary transfers and allocate ten percent to the swarm. A contracts-only deployment has no new token or swarm supply allocation. These are product rules, not a blanket preapproval of this design. Capabilities, launch rules.

Record — Intake and registries. Intake 0xa43e6f75ee006411f79ac1c84120606c2330de82 is advertised on both chains and has bytecode on both pinned blocks. Ethereum source is verified; Robinhood Sourcify source was not found, so there the evidence is official configuration plus code existence, not a fresh source audit. Identity 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432 and reputation 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63 are listed for both chains in the pinned official repository and have bytecode on both. No validation-registry deployment is listed in its deployment-address section: address not found. The presence of validation concepts elsewhere in the README does not supply that address. Official registry list, Ethereum Intake source.

Claim — swarm state, not an independent capacity guarantee. At API timestamp 2026-10-23T19:43:00.645Z, /swarm reported 1,026 online agents, 1,055 enrolled seats, 69 jobs and 16 oracles done in its last-day counters. These are control-plane claims, not unique humans, SLA capacity or independent signers. Swarm snapshot source.

Inference — preferred home for evidence gathering: buy bounded implementation/review work on IMD; keep CLAUS as the potential customer. A second admission, scheduler, bond, dispute and reputation stack would duplicate existing infrastructure before proving demand. A CLAUS NFT/agent-key binding adapter is enough to test seat provenance; do not mutate the NFT contract. The verified collection address, returned by the hook and present in token source, is 0x80396c7131159eB92E7E84839e51C9887A7A95d9; its current mint/admin policy was not audited, so do not promise a fixed-supply NFT migration.

Inference — approvals required for a real launch: CLAUS must approve a bounded budget and real work list; arrange correct control of every module/governance/recovery path; approve any change to proceeds allocation; publish code and the precise pool universe; and supply independent operators willing to quote and rerun. IMD must admit the exact job bodies and, only after gates pass, confirm a contracts-only path for a new hook using existing CLAUS. Its normal custom-token hook launch is not evidence that an existing-token integration is supported. No mainnet deployment should be ordered from this report. If CLAUS declines, publish the benchmark/keeper and stop: do not launch a rival token to manufacture a payer. If IMD declines an integration, preserve the read-only evidence and obtain a separately funded implementation route; do not imply IMD admission already exists.

8. Why now: changes within the last 60 days

Inference — window: use 2026-08-24 through 2026-10-23 inclusive as the calendar window. The changes make a test practical; they do not resolve the failed launch gates.

Dated change	Evidence and grade	Relevance
2026-09-16 work began; 2026-10-12 later POD acceptance rules; repository last commit 2026-10-13	Claim in pinned POD README, Record commit pin	A concrete independent-rerun reference now exists, with actual acceptance/refusal semantics and acknowledged implementation limits
2026-10-10 Intake revision became live	Claim in IMD onchain docs; Record Ethereum verified deployment metadata gives block 26,164,897, and both chains have code at our pins	A sponsor contract can buy work through the current intake; this does not make offchain results trustless
2026-10-15 permanent CLAUS core and extension host; admin renunciation at 12:03:11Z	Record, verified implementation/deployment metadata, renunciation transaction	Modules can change economics without replacing the core; the freeze also prevents adding a crew acceptance gate there
2026-10-20 compute collector/governance deployment, block 26,233,391	Record, governance verified metadata/source	A fee slice for compute and a concrete claim chore exist; there is still no automatic provider-payment escrow
2026-10-20 Daydreams settlement revision on testnets	Claim in pinned revision document	Explicitly tackles delivered-work refunds, decision windows and evaluator payment timing—evidence these are substantive design problems, not details to omit
2026-09-11 Olas published its offchain-request comparison	Claim, dated engineering account; corroborating marketplace source pin	Existing systems already separate request latency from asynchronous onchain settlement; a new network is not needed merely to get that architecture

Inference: ERC-8004's inspected repository last changed on 2026-08-15, outside this window. Do not market identity registries or generic v4 hooks as a newly shipped feature in this period. No dated evidence was found that independent rerun demand or economically attractive missed chores newly appeared.

9. MVP plan of 14 days or less: contracts, Foundry tests and exact IMD jobs

Inference — scope and schedule: a 10-day evidence experiment, with no deployment in this assignment and no automatic follow-on launch. Days below are allocations, not measured build times.

Days	Deliverable and stop rule
1–2	Reproduce current claims/census with deterministic code; obtain sponsor budget approval and an unseen-interface case. If there is no case that needs synthesis, stop and deliver the keeper
3–4	Implement fork-only RecoveryExecutor, CrewEscrow and seat authorization registry. Snapshot proceeds/liabilities; bind source/spec/calls; no arbitrary recipient or unrestricted target
5–6	Implement counterfactual immutable CrewHook and callback/fee harness; test against a local PoolManager and forked CLAUS dependencies. Existing core is not upgraded
7–8	Separate operator reruns sealed worker results and tests malicious cases. Optional single yes/no oracle only after the exact expanded question is pinned
9–10	Publish costs, deterministic baseline comparison, failure cases and independent rerun artifacts. Apply all kill criteria. Decide whether a separately authorized launch proposal is justified

Inference — Foundry test plan, to be executed by the implementation job, not claimed completed here:

• Fork Ethereum at block 26,257,499, checking the recorded block hash and dependency code hashes; fork Robinhood only for intake/identity integration if needed. No --broadcast.
• All listed callbacks: only-manager access, exact return selectors, correct permission bits and deltas; add/remove liquidity and donations remain usable. New hook deployment address must match its smaller mask.
• Fee tests for both swap directions and exact input/output; integer rounding, dust, protocol-fee ceiling, partial fills and bounded module return sizes. Empty data works; oversized data follows verified core behavior. Uniform pricing cannot confuse router with trader.
• Claim baseline: allowed collector call changes its claims and fixed recipient balance consistently; caller cannot redirect funds; zero/excess claims revert. A worker donation or flash-funded transfer cannot satisfy recovery provenance.
• Escrow invariants: paid + outstanding credits + refundable balances never exceed deposits and authorized inflows; each job pays once; no stake or holder reward leakage; reentrant target/recipient cannot double-credit; failed postcondition rolls back target calls and reward.
• Signature tests: wrong chain/consumer/spec/artifact/request/question; invalid bool encoding; insufficient agreement; stale state; expiry; replay; transferred NFT; changed operator; worker equal to reviewer or beneficiary. Test the real API signature format, including enum normalization.
• Fault injection: omitted census page/log range, duplicate PoolId, no liquidity, missing source, conflicting reruns, unavailable RPC, reverting program and unresponsive reviewer. No payout for missing evidence; deadline refunds remain callable.
• Fuzz state transitions, receipt replay and fee allocation sums; adversarial fork tests must be authored outside the worker's implementation. A rerun of only worker-written assertions is insufficient.

Inference — exact proposed procurement, not orders placed. The following are fixed briefs for job.open without onchain, using the documented job-body interface. Run the free POST /requests/check first and repair admission blockers. Future artifact/base-commit values must be the real outputs of preceding jobs; no fabricated repository, requester address or commit is supplied. A continuation uses the actual returned parentJobId. Do not order launch.open, a workflow that deploys, or a recurring schedule.

Order	Exact objective / acceptance deliverables	Price, Record applied to proposed count
A — research/implementation baseline	“Using the report's pinned Ethereum state and matched sources, implement a deterministic compute-claim keeper and canonical-v4 CLAUS initialization census. Produce a complete log-range manifest, one successful fork claim, fixed-beneficiary postcondition, gas measurement and source hashes. Find a real currently unsupported interface case; explicitly return NONE if none exists. No deployment, private keys or transactions.” Deliver baseline.md, machine-readable census and offline fork harness; invalid if it claims all venues/chains from one manager	0.5 IMD
B — build and test, only after A finds a qualifying case and sponsor approves	“Implement the fork-only RecoveryExecutor, CrewEscrow, seat-key authorization and counterfactual immutable CrewHook specified in sections 4–5. Use the actual pinned baseline artifact and unseen case from A. Worker/reviewer credits follow independent evidence and atomic recovery postconditions. Implement every section-9 adversarial test. Supply all dependencies as ordinary source files and an offline reproducible harness. No deploy, token issuance, live module change or oracle order.” Deliver source, Foundry tests and measured costs	0.5 IMD
C — independent adversarial review, only after B	“Review the actual B output commit and its inherited source pins independently. Recreate the result with fresh held-out tests; try recipient substitution, router spoofing, replay, self-funded recovery, bad census completeness, controller collusion and fee/escrow insolvency. Report precise reproductions and whether every hard gate passes. No deployment or external transactions.” Deliver review.md, repro tests and pass/fail gate matrix	0.5 IMD
D — optional oracle.request, only for the real accepted artifact	Use the exact expanded yes/no question in section 5, answerType: bool, evidence: panel; proposed panel size 5, quorum 5, validity 86,400 seconds, chain 1, fixed job state window and real consumer. Pin actual source/artifact hashes in definitions. Do not use allowAmbiguous to bypass screening	0.5 IMD

Inference — budget derivation: A alone costs 0.5 IMD; A+B+C costs 1.5 IMD; with D the ceiling is 2 IMD. No schedule is bought, and D is not automatically required for an onchain postcondition. If this assignment is charged at the advertised research-job rate, including it adds 0.5 IMD, giving 2.5 IMD; its actual payment transaction was not inspected. No numerical model/reviewer bounty or gas budget is silently included in these totals.

10. Kill criteria

All thresholds here are Inference — proposed decision rules, not empirical market facts.

Measurable criterion	Kill action
By the end of day 2, zero sponsor-approved, previously unsupported cases for which the precommitted keeper fails and AI produces a valid sequence	Stop CREW; deliver a deterministic keeper/census
By the end of day 2, zero explicit prefunded customer budgets covering worker, verification, gas and IMD charges	Stop; an account balance or token trading volume is not a purchase order
Any test pays a worker with a failed/missing postcondition, or pays twice for a job/receipt	No launch until independently reproduced fix; unresolved by day 10 means end experiment
Any relevant live admin/recovery path can take effect in less than 86,400 seconds, or an unverified bypass remains	No CLAUS live integration; a module-only timelock does not cure governance bypasses
An independent rerun cannot reproduce every accepted experiment result against the same pinned state, or controllers cannot be separated even at declared-beneficiary level	Reject acceptance claim and do not launch a “disinterested” network
Measured all-in cost per accepted recovery is at least the customer's attributable recovered value, or the deterministic baseline does as well at lower cost on every qualifying case	Stop the paid-agent thesis for that job class
New hook operation requires a transfer restriction, venue lock, postlaunch mint, privileged bundled buy or additional swap surcharge to fund the first experiment	Reject that design under the brief

11. Moonshot

Inference — boldest version under the same rules: a sponsor-funded maintenance market where CLAUS NFT seats and IMD seats compete to synthesize bounded repairs for new fee-program interfaces, publish full pool-state evidence and execute recovery actions against immutable postconditions. A new immutable v4 hook funds and owns the escrow ledger, not merely a dashboard; each job fixes code/state/spec hashes, worker/reviewer identities and maximum liabilities. Existing CLAUS stays transferable across venues, and job eligibility does not depend on token purchases. Sponsors can add jobs but cannot retroactively change their acceptance terms. The network has no general treasury-trading authority. ERC-8004 supplies discoverable identities and receipts, not a proof of honest operation; there is no assumed validation-registry address.

Inference — smallest falsifiable experiment: the same 10-day trial, with one real unseen interface case, a deterministic baseline, a worker and a separately controlled reviewer, a fresh fork rerun, and an atomic recovered-proceeds postcondition. The sponsor commits the budget before work. Pass only if the AI discovers a valid bounded sequence the baseline misses, the independent rerun succeeds, and measured recovered value exceeds full cost. That can justify a new proposal; it does not prove a network effect or satisfy a literal claim that all non-AI programs are incapable. A live experiment remains disallowed until the hook/admin/fair-opening gates pass. Day-one payer is the CLAUS operator from an explicitly approved budget; no agreement is inferred from its fee collector.

Inference — why it may be a bad idea: scarce missing interfaces may disappear after one adapter is written, leaving an ordinary keeper service beneath an expensive seat, bonding and review structure. The apparent customer could be recycling trading fees among related operators. A test suite can reward a clever but useless artifact, and two models can share the same mistake. CLAUS collateral falls with the ecosystem whose work it guarantees, while reviewers still need payment on failed attempts. A new hook/pool fragments liquidity and has no right to fees from other venues; the current frozen hook cannot become a general job-verification engine. Buying a proven external service or writing a small keeper may produce the entire benefit without a new network. POD's poster-refusal mechanism and Daydreams' settlement revisions are evidence that reproducibility and commercial acceptance remain different problems.

12. Open questions and everything not verified

Record / Claim boundary: all six supplied starting facts were checked: IMD capabilities/docs and launch rules; swarm plus an actual oracle signature; both Intakes; both identity/reputation addresses and absent listed validation deployment; CLAUS freeze/host/module fee boundary/current plan; and v4's router sender. Caveats remain explicit below.

• Not found: a qualifying AI-only recovery instance, a paying CREW customer commitment, a deployed crew escrow, a CREW timelock, an official validation-registry deployment address on the requested chains, and an independently verified POD production address. Do not substitute a null, burn or guessed address.
• Unverified: economically disinterested ownership of any proposed seats, model independence, cost of an independent rerun, bond sizing/liquidation protection, customer willingness to pay, and canonical-pool volume sufficient to fund recurring work. No price-page estimate fills these gaps.
• Incomplete universe: this research censused canonical Ethereum v4 initializations involving the verified token, not every CLAUS pool across venues and chains; no active-liquidity or swap-volume census was performed. An operator must define which additional factories/managers count. Pool inclusion alone is not legitimacy.
• Admin nuance: current hook proxy freeze was checked through implementation/admin slots, matched proxy source and admin ownership history. Token implementation was source-matched, but the token proxy's complete separate admin history and every ancillary contract were not audited. The instantaneous governance paths already suffice to fail requirement 4.
• Oracle limits: one real EIP-712 signature was verified. Its signer identity has API provenance and a valid recovery, not a separate claim of deployed contract code. Panel independence, signer custody, delivery availability and full historical oracle accuracy were not independently established. A signature is not a ZK proof or quorum of independently checked signatures.
• Registry limits: code at advertised identity/reputation addresses does not establish their upgrade governance, a particular agent's credentials, NFT fixed supply or validation trust. Robinhood Intake Sourcify returned not found; no claim of its independently verified source is made.
• Competitor limits: no independent financial audit or comparable paid-customer cohort was performed. Olas and ACP listed proxies have bytecode at the recorded pins, not a measured revenue guarantee. Daydreams revision documents and POD READMEs expose deployment/version ambiguities; latest source must not be equated with live code.
• Fairness limits: a no-issuance experiment avoids a new token opening; it does not certify CLAUS's historical opening. No anti-Sybil trader identity or bundle-proof auction was demonstrated. A per-wallet buy cap would not solve that.
• Access limits: browser retrieval failed for IMD API JSON and Etherscan code pages; direct read-only HTTPS fetched IMD JSON, and Sourcify supplied matched source plus deployment metadata. Some CLAUS requests initially returned HTTP 403; a later normal user-agent fetch retrieved the fee JSON. No login, private API, transaction, deployment or downloaded program was used.

Inference — conclusion boundary: missing commercial approval is a research finding, not a request to invent a wallet or block delivery. This is a no-launch recommendation under the stated hard requirements, with a concrete experiment only if someone chooses to fund it.

13. Sources with read dates

All entries were read 2026-10-23 UTC. Source references in earlier sections link directly to the relevant document. Local captures preserve the inspected bytes; they are evidence snapshots, not executable dependencies. research/manifest.json records capture hashes. research/contract-reads.json, research/source-runtime-checks.json, research/pool-initializations.json and research/oracle-signature-check.json preserve the original checks. These are this researcher's checks, without independent review authority.

Source	Exact source / pin	Evidentiary use
IMD documentation	Docs — snapshot read date above; no publication commit exposed	Ordering, launch restrictions, swarm allocation, oracle typing, Intake revision date are publisher Claims unless directly checked
IMD capabilities	JSON — saved snapshot	Record of advertised prices, chain/kind support, cadence and addresses; not guaranteed delivery
IMD swarm	JSON — API timestamp 2026-10-23T19:43:00.645Z	Claim of current activity/counters
IMD oracle requests and attestation	Requests, exact attestation — attested 2026-10-23T18:58:46.234Z	One signed payload cryptographically verified; no claim its unrelated task was true
Intake verified source	Ethereum Intake — deployment block 26,164,897, compiler 0.8.26	Record; Robinhood source match not found
ERC-8004 official repository	Pinned README — commit b9e466c250744a7e06b13dff9d3c2844ed64f825, last commit 2026-08-15T16:26:49Z	Deployment-list provenance; no listed validation deployment
CLAUS fee state	JSON — captured observedAt 2026-10-23T19:44:42.785Z, block 26,257,500, hash 0xfd7051c749da39f5e8ba98a1b263c03456da2074fd6a67c5a3e31180785911ba	Current published plan/processing claims; distinguished from later direct reads
CLAUS proxy	HookProxy — runtime match against Ethereum pin below	Proxy permissions and administrative forwarding
CLAUS implementation	ProtectedHook — deployed block 26,197,758; verified 2026-10-15T12:45:31Z; compiler 0.8.26	Permanent accounting/callback chain, constructor dependency pins
CLAUS host	TradeExtensionHost — deployed block 26,197,757; verified 2026-10-15T13:39:51Z; compiler 0.8.26	Allocation caps, bounded quotes, receipt execution, setter
CLAUS token	ProtectedToken, token proxy — source/runtime match at Ethereum pin	Ordinary transfers and inspected mint/admin surface
CLAUS governance	ClausGovernance — creation transaction 0x3a0d08db1c99accd23b6dcef9ca666f4cd27a074568a05f6c9bd1581266aea9f, block 26,233,391; compiler 0.8.26	Current authority and founder recovery paths
CLAUS compute collector	ClausComputeFeeProgram — same creation transaction/block as governance; verified 2026-10-20T11:25:02Z	Fixed recipient, claim baseline and fee slice
CLAUS active adapter	ComputeProtectedProgram — runtime match at Ethereum pin	Active-program indirection, protected compute settlement
Hook freeze transaction	Ownership renunciation — block 26,197,788, hash 0xa0c545a523c6a97f4459fd38e42dad74a3682b2dcf4802d9236248a96d33ce4d, 2026-10-15T12:03:11Z	Direct RPC logs and current admin owner verify the event, independently of page accessibility
Uniswap official hooks docs/source	Concepts, Hooks.sol, IHooks — commit bea7f6d1c11cd5dc4f0d5151ffa37a1c239feee6, last commit 2026-10-23T16:23:26Z	Sender forwarding and flag semantics; live CLAUS uses the matching vendored sources in its verified compilation
Olas docs	Mech client, marketplace	Claim of live service/chains and requester flow; numerical marketing totals not used
Olas contracts	Pinned repository — commit 5cf262d81dd3cb7d0faecc091b7a5ca3027ebcf2, last commit 2026-10-22T13:25:47Z	Public implementation and chain deployment-file provenance; listed proxies code-checked
Olas dated engineering article	Offchain requests — published 2026-09-11	Recent architectural Claim, not an independent latency benchmark
Bittensor official docs/source	Yuma, runtime — commit 5749dbfbe4a78ccd3938d46ffae45e059488feb7, last commit 2026-10-23T18:31:20Z	Consensus/reward comparison; no runtime deployment attestation asserted
Daydreams product	Task Market, official product page	Product availability and visible task records are Claims about activity
Daydreams contracts/security/revision	Pinned contracts, security, settlement revision — commit bbfb34a5d3198d3bab677a6247f766c2c7b8c004, last commit 2026-10-23T12:51:21Z	Source trust boundaries; revision's 2026-10-20 testnet status is not mainnet confirmation
Virtuals official docs	Overview, architecture, changelog	Current lifecycle and official Base core listing; changelog's April release is outside recent window
Virtuals current SDK	Pinned repository — commit 392dcc6eb17a6884c214c21aff31afa1b99f45ae, last commit 2026-10-05T06:49:03Z	Current event-driven interface, distinct from deprecated SDK
POD	README, sandbox, contract notes — commit a9ed4f75f7ee44417e90754d584f340423a8b749, last commit 2026-10-13T09:45:12Z	Rerun design and stated limitations; inconsistent deployment notes retained as uncertainty

Record — all chain-state pins used:

Chain / purpose	Block, hash, timestamp
Ethereum current-state checks, code matching, canonical-PoolManager census, Olas listed-proxy code	26,257,499; 0x24073ae44950839cbf79a2e8ee20a413489df677dad541f124e543add0f36d63; 2026-10-23T19:44:23Z
Robinhood Intake/identity/reputation and Olas listed-proxy code	96,191,644; 0x6e08f35eda9da33f068a7cf70ea8b1bbd1630fcf9941a36e35dd6b9b608a737a; 2026-10-23T19:44:29Z
Base listed ACP core-code check	52,997,787; 0x072feda804cccb8b8f686f2d5e30d5fc0288302f2fd898f85129bef772bc8a92; 2026-10-23T19:48:41Z
Hook admin initial ownership event	26,121,996; 0x5b21fb1cdab59b8c16c5f339d68a66ae04f9c570370620c84b613caad227dcc5; 2026-10-04T22:31:23Z
Hook admin transfer to finalizer	26,197,786; 0x21cb7ade9f3ad52db4a84398967b8a9aa0f7fc4457644ec3efe0081cba7de405; 2026-10-15T12:02:47Z
Hook admin renunciation	26,197,788; 0xa0c545a523c6a97f4459fd38e42dad74a3682b2dcf4802d9236248a96d33ce4d; 2026-10-15T12:03:11Z
Publisher fee-state pin, not a second direct-state read	26,257,500; 0xfd7051c749da39f5e8ba98a1b263c03456da2074fd6a67c5a3e31180785911ba; 2026-10-23T19:44:35Z
Example oracle's own state window, not a claim about CREW	26,042,096–26,257,254; end hash 0xe8abd1dcf21d728a19ee8c1f791a5bc9fa6b681a970b7134316cde42c6facb6e; attestation date above

The brief supplied no public Ethereum or Base RPC URL, so none is invented or attributed. Public source citations identify the verified records and contracts; read results and block hashes above identify the state used. Robinhood's public network endpoint is https://rpc.mainnet.chain.robinhood.com, as listed in the pinned Olas deployment configuration. No private infrastructure address or credentials are included.