Abstract
This proposal is a profile of the ERC-8004 Reputation Registry for paid work that an escrow settled on
an evaluator's verdict. It adds no core contract. For each settled task, a writer posts one giveFeedback entry tagged
work.outcome about the agent that did the work: 100 when the work was accepted and paid, 0 when it was rejected, or
when the worker took the task on chain and never delivered.
The entry carries its evidence, the record, as a data: URI. The record names every log the escrow emitted for the
task, from funding through delivery, each verdict and each challenge (a dispute or an appeal), to the payment or the
refund. A reader that holds the escrow's descriptor and an RPC endpoint can rebuild the record, derive the outcome, and
check that the escrow paid the worker who delivered, in full, and only after a final verdict that accepted the work.
Any escrow that logs these steps, with the task id as each event's first indexed parameter, is a source as deployed, such as ERC-8183 job contracts.
Motivation
An ERC-8004 feedback entry can name a task. Nothing ties its value to work that was paid for, to the party that judged the work, or to what happened when someone contested the judgment. An opinion costs nothing to post.
Work settled through an escrow leaves harder evidence. A client locked funds, a worker delivered, an evaluator decided, and the escrow paid or refunded. Each step is a log. ERC-8183 standardizes one such escrow with a single evaluator and recommends turning job outcomes into ERC-8004 signals, but leaves the mapping to each implementation. Other escrows add disputes and appeals, so the first verdict is not always the one that settles the task. Each escrow reports outcomes in its own way, if at all, and a record earned at one marketplace is invisible at the next.
The readers are agents choosing whom to hire, lenders sizing credit on work an agent was paid for, bond contracts that release on accepted delivery, and marketplaces ranking workers. They need the same few facts from every escrow: whether the work was accepted, after which challenges, and whether the money followed the verdict.
Goals:
- No new core contract. It works with the deployed ERC-8004 registries and with escrows as they are deployed.
- Checkable. Every step in a record is a log, and every amount a transfer, that a reader holding the source's descriptor can fetch and check.
- Payment follows acceptance. A record of accepted work shows delivery, then a final verdict that accepted it, then the full payment to the worker who delivered.
- Contested outcomes are explicit. Every verdict and challenge is in the record, and the last verdict decides.
- No zero without a worker act. A task the evaluator never decided, or one the worker never touched on chain, does not count against the worker.
- Readable on chain. The registry stores the value and tags, so a contract can read an agent's acceptance rate over the writers it trusts.
Specification
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119 and RFC 8174.
This profile uses the Reputation Registry's giveFeedback, readFeedback, getSummary, getLastIndex and
NewFeedback, and the Identity Registry's ownerOf, getAgentWallet, getMetadata and setMetadata, as ERC-8004
defines them.
Terms
- Source: a contract that holds a client's payment for a task and releases it to the worker or returns it to the
client. A source is identified by (
chainId,contract). - Descriptor: the JSON object that says which of a source's events are which steps (see Sources).
- Task: one unit of paid work at a source, with an id unique within that source.
- Worker: the party the source names for the task, as an address or a
bytes32id; Outcomes says which one a task has. - Verdict: a decision on whether delivered work is accepted. An evaluation is a verdict, and so is a ruling on a dispute or an appeal.
- Challenge: an act that asks for a new verdict on the latest one, such as a dispute or an appeal. Until a later verdict arrives, the challenged verdict stands.
- Writer: the address that posts entries (the entry's
clientAddress). - Record: the JSON document an entry carries, describing one settled task (see Record).
- Record bytes: the record's canonical encoding, the bytes
feedbackHashcommits to. - Head fields: every field of a record except
work. - Source time: the timestamps of the source chain's blocks.
- Finalized head: the source chain's latest final block, read as the descriptor's
finalitysays. - Takes an entry: said of a settled, consistent task whose outcome is
accepted,rejectedorundelivered. - Due: a settled task whose terminal block is final is due once the later of the finalized head's timestamp and the timestamp of the registries' chain's latest block is at least 72 hours past the timestamp of the terminal block. The registries' chain keeps the clock running when the source chain produces no blocks.
Steps
A source's logs map to seven kinds of step. paid and refunded are terminal.
| step | meaning | required fields | optional fields |
|---|---|---|---|
funded | the client's payment is held for the task | task, client, amount | brief |
assigned | a worker is hired, or takes the task | task, worker | |
delivered | the worker submits the work | task, worker | result |
verdict | the work is accepted or not | task, accepted | ref, evaluator |
challenge | a party reopens the latest verdict | task | by, bond |
paid | the source releases the payment | task, to, amount | worker, fee |
refunded | the source returns the payment | task, to, amount |
| field | type | meaning |
|---|---|---|
task | uint256 | the task id |
client, to, by, evaluator | address | the account named |
worker | address or bytes32 | the worker. An address is compared in its 32-byte left-padded form |
amount, fee, bond | uint8 to uint256 | base units of the source's asset |
brief, result, ref | bytes32, or uint8 to uint256 | commitments to the task's terms, to the work, and to the verdict's evidence |
accepted | bool, or a literal | whether the verdict accepts the work |
Sources
A descriptor for an ERC-8183 contract with the events of that proposal's reference implementation:
{
"chainId": 8453,
"contract": "0xā¦",
"asset": "eip155:8453/erc20:0xā¦",
"fromBlock": 0,
"finality": "finalized",
"events": [
{ "step": "assigned", "event": "JobCreated(uint256 indexed jobId, address indexed client, address indexed provider, address evaluator, uint256 expiredAt, address hook)",
"fields": { "task": "jobId", "worker": "provider" } },
{ "step": "assigned", "event": "ProviderSet(uint256 indexed jobId, address indexed provider)",
"fields": { "task": "jobId", "worker": "provider" } },
{ "step": "funded", "event": "JobFunded(uint256 indexed jobId, address indexed client, uint256 amount)",
"fields": { "task": "jobId", "client": "client", "amount": "amount" } },
{ "step": "delivered", "event": "JobSubmitted(uint256 indexed jobId, address indexed provider, bytes32 deliverable)",
"fields": { "task": "jobId", "worker": "provider", "result": "deliverable" }, "actor": "worker" },
{ "step": "verdict", "event": "JobCompleted(uint256 indexed jobId, address indexed evaluator, bytes32 reason)",
"fields": { "task": "jobId", "accepted": true, "ref": "reason", "evaluator": "evaluator" } },
{ "step": "verdict", "event": "JobRejected(uint256 indexed jobId, address indexed rejector, bytes32 reason)",
"fields": { "task": "jobId", "accepted": false, "ref": "reason", "evaluator": "rejector" } },
{ "step": "paid", "event": "PaymentReleased(uint256 indexed jobId, address indexed provider, uint256 amount)",
"fields": { "task": "jobId", "worker": "provider", "to": "provider", "amount": "amount" } },
{ "step": "refunded", "event": "Refunded(uint256 indexed jobId, address indexed client, uint256 amount)",
"fields": { "task": "jobId", "to": "client", "amount": "amount" } }
]
}PaymentReleased reports the amount after fees and no event reports the platform fee, so a job of such a contract that
charged a fee does not meet the amount rule in Outcomes and gets no entry.
A descriptor:
- MUST have exactly the fields
chainId,contract,asset,fromBlock,finalityandevents; - MUST give
contractas an ERC-55 checksummed address; - MUST give
asset, the ERC-20 token the source holds, as the CAIP-19 ideip155:<chainId>/erc20:<address>, with the source'schainIdand an ERC-55 checksummed address; - MUST give
fromBlock, the block the source was deployed in; - MUST give
finality: the string"finalized"when the source chain's nodes answer thefinalizedblock tag, or a positive integer N, a confirmation depth, for a chain without it. With N, the finalized head is the block N below the latest block; - MUST list in
eventsevery event the source emits for any of the seven steps, and at least one event each forfunded,delivered,verdict,paidandrefunded.
Each item of events has step, event and fields, and MAY have actor and feeIncluded:
eventMUST beName(type [indexed] name, ...): parameters separated by a comma and one space, each a canonical ABI type name (uint256; the aliasuintdoes not qualify), the wordindexedwhen the parameter is indexed, and a parameter name. Types are elementary types or their dynamic arrays (T[]); static arrays (T[k]) and tuples MUST NOT appear. An event MUST have at most three indexed parameters and MUST NOT be anonymous. An enum parameter is writtenuint8.- The event's topic,
keccak256of the signature without parameter names and withoutindexed, MUST appear at most once inevents, so each log is exactly one step. fieldsMUST map each required field of the step, and MAY map its optional fields, to a parameter of the event whose type the field table allows.taskMUST name the event's first indexed parameter, which MUST be auint256.acceptedMAY instead be the JSON literaltrueorfalse, for an event that is itself the verdict.actor, when present, MUST be"worker". It marks an event whose transaction the worker sends.feeIncluded, when present, MUST be a boolean on apaidevent that mapsfee. It istruewhenamountincludesfee. The worker receivesamountminusfeewhen it istrue, andamountotherwise.
A reader MUST hold the descriptor of each source it reads, keyed by (chainId, contract), from a party it trusts: its
own copy, or one the source's deployer publishes. Two descriptors are the same when their canonical encodings, as in
Record, are the same bytes. A reader MUST reject a record whose descriptor differs from the one it holds.
A new source SHOULD emit events of at least these shapes:
event TaskFunded(uint256 indexed task, address indexed client, uint256 amount, bytes32 brief);
event WorkerAssigned(uint256 indexed task, bytes32 indexed worker);
event WorkDelivered(uint256 indexed task, bytes32 indexed worker, bytes32 result);
event Verdict(uint256 indexed task, address indexed evaluator, bool accepted, bytes32 ref);
event Challenged(uint256 indexed task, address indexed by, uint256 bond);
event TaskPaid(uint256 indexed task, bytes32 indexed worker, address indexed to, uint256 amount, uint256 fee);
event TaskRefunded(uint256 indexed task, address indexed to, uint256 amount);Outcomes
The steps of a task are the logs the source emitted from the descriptor's fromBlock onward, of declared events whose
task parameter equals the task id. They are ordered by block number and log index, and run to the end of the
transaction that holds the first terminal step. A step from an event marked actor: "worker" also has a sender: the
from of its transaction.
The worker of a task is the worker of its first delivered step or, without one, of its latest assigned step that
names a non-zero worker. A worker act is a step, other than delivered, whose sender, left-padded to 32 bytes, equals
the worker.
A task's outcome is the first of these that applies:
- No terminal step:
unsettled. - No
deliveredstep and noassignedstep that names a non-zero worker:no worker. - No
deliveredstep:undeliveredwhen the task has a worker act,unstartedotherwise. - No
verdictstep after the lastdeliveredstep:unevaluated. - The last
verdictstep after the lastdeliveredstep accepts:accepted. Otherwise:rejected. A challenge with no later verdict leaves the challenged verdict standing.
A task is consistent when all of these hold:
- it has exactly one
fundedstep, before anydeliveredstep; - the transaction that holds the first terminal step holds no other terminal step;
- an
acceptedtask's terminal step ispaid, and the terminal step of every other outcome isrefunded; - the terminal step settles the funded amount: for
paid,amountwhen the event'sfeeIncludedistrue, andamountplusfee(zero when not mapped) otherwise; forrefunded,amount; - every
deliveredstep, and thepaidstep where it mapsworker, names the task's worker; - every
challengestep comes after averdictstep; - every log the source emitted whose topic 0 is a declared event's and whose topic 1 is the task id decodes under that event: it has one topic more than the event's indexed parameters, and each word fits its parameter's type. Events that differ only in which parameters are indexed share topic 0, so a log of the other shape makes the task inconsistent;
- the source emitted no declared log for the task after the transaction that holds its terminal step and at or before the time of the entry's block. A log later than the entry is not held against it.
Entries
A writer MUST post each entry with giveFeedback(agentId, value, valueDecimals, tag1, tag2, endpoint, feedbackURI, feedbackHash) and these values:
| outcome | tag1 | tag2 | value |
|---|---|---|---|
accepted | work.outcome | accepted | 100 |
rejected | work.outcome | rejected | 0 |
undelivered | work.outcome | undelivered | 0 |
valueDecimalsMUST be 0.endpointMAY be empty, or name a page about the task. It is not evidence.- When the record bytes are at most 8,192 bytes,
feedbackURIMUST be exactlydata:application/json;base64,followed by their base64 (RFC 4648 standard alphabet, padded, no other character). Longer record bytes MAY be served at anhttps://oripfs://URI instead. Either way,feedbackHashMUST bekeccak256of the record bytes. - A writer MUST NOT post an entry for a task that does not take one.
- The record's
createdAtMUST NOT precede the timestamp of the block that holds the task's terminal step, and MUST NOT follow the timestamp of the block that holds the entry.
Record
A record holds ERC-8004's off-chain feedback fields and one object, work. The record of BrainChain mainnet task 50,
with its entry on Robinhood Chain (chain id 4663), is
example-record.json. Abbreviated below; the record
bytes are canonical:
{
"agentRegistry": "eip155:4663:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
"agentId": 20424,
"clientAddress": "eip155:4663:0x97D558417c3D61f1074422AD843e1Db1E565b952",
"createdAt": "2026-11-16T12:00:00Z",
"value": 100, "valueDecimals": 0,
"tag1": "work.outcome", "tag2": "accepted",
"work": {
"v": "work-record/v1",
"source": { "ā¦": "the descriptor" },
"task": "50",
"worker": "0x5f1c28741ee74be2a828fd337283ca47e477a0cd56bf5ad31c61e1ce3ce1d22f",
"outcome": "accepted",
"steps": [
{ "step": "funded", "block": 2451, "tx": "0x749dā¦d5ef", "log": 2, "client": "0x97D5ā¦b952", "amount": "1000000", "brief": "0x5ba7ā¦a9a9" },
{ "ā¦": "assigned, delivered and verdict" },
{ "step": "paid", "block": 2471, "tx": "0xdca6ā¦8abf", "log": 3, "worker": "0x5f1cā¦d22f", "to": "0xFB9Cā¦f84D", "amount": "1000000", "fee": "30000" }
]
}
}A record MUST have exactly these fields:
| field | JSON type | encoding | presence |
|---|---|---|---|
agentRegistry | string | CAIP-10 eip155:<chainId>:<address> of the Identity Registry | always |
agentId | number | the agent id, at most 2^53 - 1 | always |
clientAddress | string | CAIP-10 of the writer, on the same chain as agentRegistry | always |
createdAt | string | RFC 3339 in UTC to the second, exactly YYYY-MM-DDThh:mm:ssZ | always |
value | number | 100 or 0, as Entries gives | always |
valueDecimals | number | 0 | always |
tag1 | string | work.outcome | always |
tag2 | string | the outcome | always |
work.v | string | work-record/v1 | always |
work.source | object | the source's descriptor | always |
work.task | string | the task id, decimal | always |
work.worker | string | the task's worker, 32 bytes | always |
work.outcome | string | accepted, rejected or undelivered | always |
work.steps | array | every step of the task, in order | always |
step | string | the step's kind | every step |
block, log | number | the log's block number and its index in the block | every step |
tx | string | the log's transaction hash, 32 bytes | every step |
client, to, by, evaluator | string | address | when the step's event maps the field |
amount, fee, bond | string | decimal, base units | when the step's event maps the field |
worker, brief, result, ref | string | the parameter's 32-byte ABI word: a uintN or an address left-padded with zeros | when the step's event maps the field |
accepted | boolean | when the step's event maps the field | |
sender | string | address, the from of the step's transaction | when the step's event is marked actor: "worker" |
A step MUST carry every field its event maps, accepted included when the descriptor maps it to a literal, and no
other field. ERC-8004's other optional feedback fields, such as endpoint, mcp, a2a, oasf and proofOfPayment,
MUST NOT appear: the entry itself carries endpoint.
- The head fields MUST equal the entry's.
agentId,valueandvalueDecimalsare JSON numbers, as ERC-8004's off-chain feedback file writes them; an agent id above 2^53 - 1 cannot be written under this profile.
The record bytes MUST meet all of these:
- UTF-8 without a byte order mark, holding JSON in the canonical form of RFC 8785 (JCS): object keys sorted, no whitespace;
- JSON numbers are integers from 0 to 2^53 - 1, and decimal strings have no leading zeros;
- every address, alone or inside a CAIP id, is the 20-byte address in ERC-55 checksummed form. A 32-byte value
(
tx,worker,brief,result,ref) is0xfollowed by 64 lowercase hex digits, and an address worker appears only in that 32-byte form.
Worker binding
A worker's identity at a source often differs from its agent's owner and agentWallet. An agent MAY declare its
workers in ERC-8004 on-chain metadata under the key work.workers:
struct WorkerRef {
uint256 chainId;
address source;
bytes32 worker; // an address worker, left-padded
}
// metadataValue = abi.encode(WorkerRef[])A record's binding, read on the registries' chain at the entry's block, is one of:
declaredwhen the agent'swork.workerslists the source and the worker;walletwhen an event markedactor: "worker"types itsworkeras anaddress, and the worker equalsownerOf(agentId)orgetAgentWallet(agentId);writerotherwise.
The Identity Registry's MetadataSet logs carry each value, so a reader needs no archive state to read work.workers
at an entry's block.
A record is bound when its binding is declared or wallet. An entry is checked when it passes every reader
check below and its record is bound.
- A writer MUST bind each task to one agent and MUST NOT post the task for any other agent. ERC-8004 already refuses entries from the agent's owner and its approved operators.
- Transferring an agent does not change the binding of entries posted before the transfer. Those entries stay in the
epoch they were posted in (see Epochs). The new owner MAY replace
work.workers. - A writer that changes its key SHOULD list its keys, oldest first, as
abi.encode(address[])under the metadata keywork.writersof an ERC-8004 agent it controls. A reader MAY then treat the listed keys as one writer.
Epochs
An agent's epoch is its controller together with its declared build:
- the controller is
ownerOf(agentId), or, when the owner is a binding adapter the reader trusts (such as an ERC-8217 adapter), the holder of the token the agent is bound to; - the build is the agent's ERC-8004 on-chain metadata under the key
work.build, a UTF-8 label its owner sets for the code and model the agent runs. An agent that sets none has the empty build.
// build is the metadata value as a string
bytes32 epoch = keccak256(abi.encode(block.chainid, identityRegistry, agentId, controller, build));An entry belongs to the epoch in force at its block. The registry's Transfer and MetadataSet logs, and the
adapter's binding logs, carry every change, so a reader needs no archive state to place an entry.
A reader:
- SHOULD report the epoch of each entry, and the agent's current epoch;
- SHOULD present and weigh only the entries of the current epoch as the agent's record, and MAY show earlier epochs apart from it;
- SHOULD NOT carry entries from an earlier epoch into a later one: a sale or a new build starts the record again;
- SHOULD treat an epoch that recurs, an agent returning to the same controller with the same build, as the same epoch.
A writer needs to do nothing for epochs: they are read, not written.
Writers
A writer:
- MUST post at most one entry per task;
- MUST post only after the terminal step is final; an entry over steps that later disappear fails every reader and cannot be withdrawn;
- MUST build the record from final logs only;
- once it has posted an entry for a worker of an agent at a source, MUST post an entry for every later task of that worker at that source that takes an entry, before the task is due;
- MUST NOT revoke an entry.
Readers
A reader:
- MUST check each entry's record bytes: the URI, that
feedbackHashiskeccak256of them, the encoding, every field of this profile, and that the head fields equal the entry's. Record bytes of 8,192 or fewer fail when they are not carried as adata:URI; - MUST read a writer's entries from the registry's
NewFeedbacklogs, or from an index whose entries it then reads from their transaction receipts, and MUST check that the writer'sfeedbackIndexvalues for the agent run from 1 togetLastIndex(agentId, writer)with none missing, readinggetLastIndexat the same block as the logs; - MUST treat an entry that
readFeedbackreports as revoked as missing; - MUST read each source on the chain its descriptor names;
- MUST rebuild the task's steps from the source's logs, from the descriptor's
fromBlock, and check that they equal the record's steps, eachsenderincluded. A reader MUST NOT start the scan at a block the record supplies; - MUST derive the outcome, and fail an entry whose outcome, tags or value disagree with the steps, whose task is not
consistent, or whose
createdAtprecedes the terminal step or follows the entry; - MUST check the money: in the
fundedtransaction, a transfer of the fundedamountof the asset fromclientto the source; in thepaidtransaction, a transfer of what the worker receives from the source toto; in therefundedtransaction, a transfer ofamountfrom the source toto. EachTransferlog backs at most one step: the reader matches the transfers of every declared step in the transaction, of any task, to distinct logs, and fails the entry when any of them is left without one; - MUST NOT count an entry whose
fundedstep'sclientis the agent's owner oragentWalletat the entry's block, and SHOULD apply its own rule to clients that the worker, the agent's owner or itsagentWalletfunded before the task. Theclientis the account the bounty came from; - MUST report each record's binding, and MUST NOT present an entry that is not bound as checked;
- MUST treat two entries from one writer for one task as a failure of that writer, even when they are about different agents;
- MUST read the writer's
work.outcomeentries about every agent, with one log query on the indexedclientAddressandtag1topics, and fail an entry whose task the writer also posted for another agent. A reader of one agent finds such entries no other way; - MUST count each (
chainId,contract, task) at most once when it combines entries of several writers or agents; - when it rebuilds an agent's history, MUST find the tasks of every worker the writer has used for the agent at each source, settled since the writer's first entry for that worker. A due task that takes an entry and has no unrevoked entry from the writer is a failure of that writer for that agent;
- MUST choose which writers and which sources it trusts. Anyone can deploy an escrow and write records about tasks it paid to itself.
When a reader reports an agent's record, its counts are the numbers of checked entries for each outcome, per writer, after duplicates are removed.
Reading on chain
For the writers it trusts, a contract can call getSummary(agentId, writers, "work.outcome", ""): the count is the
number of entries and the summary value is the share accepted, in percent, as the registry averages. With tag2 set to
accepted, the count is the number of accepted tasks. A contract cannot check records or bindings, so it relies on
the writers it names.
Rationale
- A profile of the existing registry. Every ERC-8004 deployment and every indexer of
NewFeedbackalready sees these entries. Work outcomes sit next to the agent's other reputation, andtag1is indexed, so one log filter finds them. - Declared events instead of a new escrow interface. Escrows already exist with different event names. A new interface would leave every deployed escrow out. A descriptor says which logs mean what, so one reader decodes any source, and the event shapes above give new escrows a default.
- Pinned descriptors. If each record could bring its own descriptor, a writer could leave out the event that would change an outcome. The reader holds the descriptor instead, from its own reading of the contract or from the deployer, and scans from the deployment block it names. An upgradeable source that changes its events needs a new descriptor, which readers adopt deliberately.
- One entry per task. Paid tasks are fewer and larger than micropayments, and each one carries evidence a reader
wants to see on its own: who judged it and whether it was contested. Per-task entries also give contracts an
acceptance rate through
getSummary. - Verdicts and challenges as one sequence. One rule, that the last verdict after the last delivery decides, covers a single evaluator, a dispute with a ruling, an appeal with a second ruling, further rounds in an outside court, and work delivered again after a rejection. The profile names no procedure.
- No forced zeros. A source can name a worker who never agreed to the task. A refund then says nothing about that worker, so a zero needs an act the worker sent on chain, such as taking the task. A worker whose delivered work was never judged did not fail either. ERC-8183 suggests a neutral or negative signal for an expired job depending on policy; under this profile an expired ERC-8183 job gets no entry, because its events record no act by the provider before delivery.
- Payment checked against the verdict. The consistency rules and the transfer checks make an
acceptedentry mean that the funded amount moved after the verdict, in full, to the worker and the fee recipient. - The Reputation Registry rather than the Validation Registry. The agent's owner makes a validation request, before
any outcome, and the response is a score with no tie to payment. An escrow's outcome exists only at settlement, and
the party that commissions the evaluation is the client. An evaluator can still post its verdict as a validation
response and expose it through
ref. data:URIs and canonical JSON. The evidence sits in the entry's calldata, so it cannot change and needs no server. One canonical form gives each record one reading. The samedata:form, canonical JSON,keccak256commitment and 8,192-byte cap appear in the open drafts numbered 8466 (Agent Credit History) and 8458 (Agent Income Statements).- Binding through agent metadata. A worker's id at an escrow can be a hash, and the escrow can be on another chain than the registry. Metadata set by the agent's owner is the agent's own statement of which workers are its own, and readers see which records rest on it and which rest on the writer's word.
- An unanswered challenge. When a dispute or an appeal gets no ruling before settlement, the challenged verdict
stands. Sources settle that way: BrainChain's
TaskBoardpays or refunds on the standing verdict when a ruling window lapses, and the consistency rules tie the outcome to that money. Calling the taskunevaluatedwould drop a settlement the source made on a verdict. - One worker and one terminal step per task. Several workers, milestones and partial payments go to a later version of the record.
- Epochs. Without them a record is an asset that can be sold: a buyer acquires an agent with a long history and works under it. A new model behind the same agent is another worker for the same reason. Keying the record on the controller and the declared build ends both, and needs no new contract. A build is only what the owner declares; a reader that needs more MAY require the build to name an attested measurement, which this profile does not define.
Open questions
- An on-chain view for sources. A function such as
workOutcome(uint256 task)would let a contract check one task's outcome without reading a record. Should this profile define it for new sources? - Payers behind the client. Some escrows are funded by an operator on behalf of an agent that paid it off chain. Should a record name that payer when a signed receipt ties the payment to the task?
- A build that survives a sale. An agent whose build is an attested measurement (a TEE's) runs the same code under any owner. Should its record carry across a sale when the measurement is unchanged?
Backwards Compatibility
The profile adds tags, two metadata keys and a record format. It changes nothing in ERC-8004, and readers that do not know the tags ignore them. Contracts whose events carry the task id as their first indexed parameter, such as ERC-8183 job contracts, are sources as deployed. Entries a writer posted under other tags before adopting this profile are not part of it.
Test Cases
The reference source runs on BrainChain mainnet (chain id 274663, 0x44b8464342Bbfb9B565FAE494DfDefa37D33A211). The
same release runs on BrainChain testnet (chain id 274630, 0x7A7cC5D35A642CCc268C7B263fF800bc7eBD52A4). Each case below
is rebuilt from public logs. The test vectors hold every log
of each task, the record a writer builds from it, and eight cases a reader fails:
| chain | task | steps | outcome | entry |
|---|---|---|---|---|
| mainnet | 50 | funded, assigned, delivered, verdict (accepts), paid | accepted | accepted, 100 |
| mainnet | 51 | funded, assigned, delivered, verdict (rejects), refunded | rejected | rejected, 0 |
| mainnet | 54 | funded, assigned, refunded | unstarted | none |
| mainnet | 9 | funded, assigned, delivered, refunded | unevaluated | none |
| mainnet | 10 | funded, refunded | no worker | none |
| testnet | 3 | funded, assigned, delivered, verdict (rejects), challenge, verdict (accepts), paid | accepted | accepted, 100 |
| testnet | 84 | funded, assigned, delivered, verdict (rejects), challenge, verdict (rejects), challenge, verdict (rejects), refunded | rejected | rejected, 0 |
| testnet | 1 | funded, assigned, delivered, verdict (accepts), challenge, verdict (accepts), challenge, verdict (accepts), paid | accepted | accepted, 100 |
In mainnet task 54, BrainChain's TaskBoard hired a worker that never delivered. The board sent the hire, so the task
has no worker act and is unstarted. In testnet task 3, a ruling on a dispute reversed a rejecting evaluation, and the board paid.
In task 84, a staked worker's work was rejected; the worker disputed, lost the ruling, appealed and lost again, and the
board refunded.
Every task in the vectors was posted, evaluated and recorded by BrainChain itself, and the writer key in the mainnet
vectors, 0x97D558417c3D61f1074422AD843e1Db1E565b952, is also the client of mainnet task 50. Disputes and appeals have
happened only on BrainChain testnet so far.
The record of BrainChain mainnet task 50 for agent 20424, written by that key with createdAt
2026-11-16T12:00:00Z, is example-record.json; the payout it follows is in block 2471, at 2026-11-15T14:15:28Z.
Its record bytes are 3,622 bytes long, and their feedbackHash is
0x362bfa0b49ac22cabe8566773da906e0ca8b7cf1b0fe8960df2657e697b1259a.
A conforming reader fails each of these: the record of task 50 with its verdict step removed; the same record
relabeled rejected; the same record with a descriptor other than the pinned one; the same record behind a byte order
mark; the task's logs with the payment replaced by a refund; the task's logs with the paid amount short of the funded
amount; a second entry for task 50 from the same writer; and a record of task 50 dated before its payout.
Reference Implementation
The first source is BrainChain's TaskBoard, release 3.5.0, at 0x44b8464342Bbfb9B565FAE494DfDefa37D33A211 on
BrainChain mainnet (chain id 274663). As its deployer, BrainChain publishes its descriptors for
mainnet and
testnet.
Reference code runs on Node.js 18 or later, with no dependencies, and reads public JSON-RPC endpoints only:
work-records.mjs: descriptors, steps, outcomes, consistency, records and the reader's rules, with no network access;cli.mjs: the writer (build), which prints the record and thegiveFeedbackcalldata and sends nothing, and the reader (checkfor one record,entriesfor every entry one writer posted about one agent, with transfers, binding, revocations and coverage);example-record.json: a complete record;vectors.jsonandtest.mjs: the test vectors and the offline tests;README.md: how to run them, including a reader run against a fork of Robinhood Chain.
Security Considerations
- Self-dealing. A client and a worker under one control can fund tasks, accept them and pay themselves. Every check
passes, because it all happened. A record shows the client, the amounts, the fee and, where the source maps it, the
evaluator. Readers do not count a task the agent's owner or
agentWalletfunded, and SHOULD weigh records by the fees paid to parties outside the worker's control, by the number of distinct clients, by whether the worker or the agent's owner funded a client before its task, and by whether the evaluator is independent of both client and worker. ERC-8183 allows the client to be the evaluator, and a reader sees this only when the descriptor mapsevaluator. - Wrong verdicts. A record shows what was decided, not that the decision was right. Challenge steps show whether a verdict could be contested and whether it was.
- Forced zeros. A source names its workers; a worker does not consent to being named. Without the worker-act rule, anyone could hire an agent's worker on an escrow of their own, let the task lapse and have a writer post a zero. With it, a zero for an undelivered task needs a transaction the worker sent.
- A lying writer. False fields fail against the logs, a dropped step fails the rebuild, a descriptor of the writer's choosing fails against the one the reader holds, and an entry for an inconsistent task fails the consistency check. A writer that stops writing about a worker after a rejection leaves a gap that a rebuilding reader finds. A writer can still choose never to write about a worker, and can write about a source it controls; which writers and sources count is the reader's decision.
- A lying source. Logs show what a contract emitted. The transfer checks tie each step that moves money to its own transfer of the asset, so one transfer cannot stand for two tasks settled in one transaction. Before pinning a descriptor, a reader SHOULD match the source's bytecode to published source.
- Binding.
declaredis the agent's own statement,walletchecks an address the agent controls, andwriteris the writer's word. An agent can declare a worker it does not control; the writer still chooses whom it writes about. - Finality and late logs. Writers post only over final steps, since an entry cannot be withdrawn. Readers judge an entry against the logs up to its time, so a source that emits a stray log after the entry cannot fail the writer.
- Privacy. A record carries hashes of the brief and of the work. URIs that a source's events emit are not copied into records, and the record has no free-text field.
- Planted entries. Anyone can post entries tagged
work.outcome. Readers name the writers they trust, and SHOULD cap the requests one read makes. - Averages.
getSummaryaverages over the writers passed in, so one writer with many entries dominates the result.
Copyright
Copyright and related rights waived via CC0.
