How a photograph settles

The standard is frozen before anyone spends time

The acceptance test is written when the task is funded, published on the task page, and is the exact text handed to the graders. Nobody can move the bar after the work is done

A model reads it first and refuses a test too vague to grade from a photograph, before a single coin is committed. A test that leans on words like clean or tidy without saying what those look like never becomes a task at all

The before frame belongs to whoever is paying

The poster photographs the place when they fund the task. A worker who supplies both frames can shove the bags into shot, clear them, and be paid for work nobody needed - taking that frame at posting time removes the whole class of fraud

It also gives the worker the better half of the deal. They can see the exact state they are measured against before they walk anywhere

The challenge code cannot be known in advance

The contract issues a six character code when someone claims, derived from the task, the worker and the moment. It must be legible in the photograph they take

That is what proves the frame was shot after the claim. A photograph recycled from last month carries the wrong code, and the grader is already looking for it. The alphabet drops I, L, O, U, 0 and 1, because this is written by hand and read back by a machine

Every validator grades identical bytes

Photographs go into content addressed storage before the transaction is sent, so the url is derived from the file itself. The contract refuses any other kind of url

A mutable link would let the leader and the validators grade two different photographs, which would make the whole thing theatre

No single party decides

Independent validators fetch the same two photographs and grade them against the same written text. They reach their own verdicts and the verdicts are compared - a validator is never asked simply to bless the leader's answer

All of them must agree on three things before a coin moves: the code is legible, both frames show the same place, and the acceptance test passed. Not the poster, not one model, not one node

Nothing costs the worker a wasted trip

The contract opens the photograph and checks it before it pays for a grader. Unopenable, or too small for a six character code to be legible, and it comes straight back with an instruction rather than a verdict

A rejection does not cost the claim either. Most failures are lighting and framing, so the task stays with the worker and they can retake it inside the same window. And the poster cannot withdraw a task out from under someone who is still holding it

The judgement is public, on purpose

Every settled task leaves a page carrying both photographs, the exact text they were graded against, the three judgements and the reason the worker was given. Rejections are published beside payments

A verdict anyone can check against the evidence is a stronger thing than a verdict somebody promises to review

This deployment runs on a development network

The grading, the verdict and the receipt are all real here. The transfer is not: on GenLayer's Studio network a payout is delivered as a contract call, and an ordinary wallet is not a contract, so the balance does not move. The verdict is final before the transfer is even attempted, so it stands either way

Said plainly because someone doing real work should know which network they are on. On a live network the same transaction pays