Agents can buy creative work. They can't prove they got what they ordered. Grain is the verification layer: a deterministic grader checks a delivered 3D asset against a machine-checkable spec, and settlement releases on a pass or refunds on a fail — no human, inside a hard custody boundary.
Not "a 3D checker." A reusable primitive: verify a unit of creative work against an objective spec, sign the verdict, and let payment settle on it. 3D is the wedge; the rails generalize.
A deterministic floor that settles money — triangle budget, watertight/manifold, valid-GLB, named editable params — plus a benchmarked semantic layer that catches "you delivered a chair when a barrel was ordered."
USDC escrow on Base, gated by the grader's signed verdict. Pass releases to the seller; fail refunds the buyer. Inside a hard custody boundary — the releasing key can never pay itself.
An on-chain receipt at settlement — creator, asset hash, verdict — so verified work is ownable and creators keep a royalty trail. Verification is the precondition for trustworthy creative commerce.
A Requester states intent and budget, a Generator delivers, a Grader verifies and signs — and the escrow settles on the verdict.
The Requester Mind states intent + budget + an acceptance profile (e.g. game-ready-prop).
The Generator Mind produces a candidate via a commodity 3D model (fal Rodin) → a GLB with declared params.
The Grader Mind runs the deterministic predicates + the semantic check and signs a pass/fail verdict.
The escrow verifies the signature on-chain — releases to the seller on pass, refunds the buyer on fail.
On a fail, the loop regenerates within budget and re-grades — automatically, until it passes or the budget is spent. No human in the loop.
Grain ships as a Skill on the Minds Bazaar and (roadmap) an MCP server — the grader is a capability your Mind, or any agent, calls. The predicate code is open; the acceptance-profile data is the moat.
Equip it on a Mind; give it a GLB + a profile; get a signed pass/fail with per-predicate evidence — and gate settlement.
Parse once, run tri_count · manifold · valid_glb · named_params, compose pass/fail, sign the verdict.
Thin generation: fal Rodin → GLB, then attach Grain's declared editable params so the spec is meaningful.
Submit the signed verdict to GrainEscrow on Base — releases to seller (pass) or refunds buyer (fail).
≤10k tris · watertight · valid GLB · required accent_color. The public shape is open; the thresholds are the moat.
The same tools exposed to Cursor, Claude Code, and any MCP client — verification others build on.
Validators check files but don't move money. Payment rails move money but never check the deliverable. Provenance layers attest origin, not fitness. Grain is the weld.
The grader signs the verdict. It can route money to the buyer or the seller — never to itself.
Verdict authority and custody are different powers, held by different code paths. The escrow has no owner, no setter, no withdraw. Even a fully compromised grader key can only mis-grade — pay the wrong one of two pre-agreed parties — never exfiltrate. This is the "execution separated from custody" property Animoca rewarded with its first Minds investment, native to Grain's contract.
A deterministic floor settles money; a benchmarked semantic layer adds "is it the right thing?" We measured it as a verifier — confusion matrix, threshold sweep, calibrated boundary.
Honest v0 (N=5, visually-distinct categories) — proves the method + the deterministic floor, not the hard cases. Next: ~30+ assets incl. confusable pairs, published as an open verification benchmark.
Because we sign a verdict and release USDC on it. A verdict you settle money on must be reproducible — a hosted, drifting LLM can't be the thing you sign. So the settling checks are deterministic code plus a pinned local CLIP model; the Mind's Brain narrates the "why," but never decides the verdict.
The contract. The grader key's only power is one binary verdict on a pre-funded order; release and refund go only to the buyer or seller recorded at funding. No owner, setter, or withdraw. A compromised key can mis-grade, never exfiltrate.
The predicate code is commodity — and open. The defensible asset is the acceptance-profile library: what real buyers (TADs, QA leads, marketplace inspectors) actually accept. Accumulated from real rejection data, not scrapeable, and mapped to willingness-to-pay.
3D is the proven wedge. The substrate — escrow, custody boundary, verdict signing, profiles, the loop, the Skill — is vertical-agnostic. A new creative vertical is a new predicate set on the same rails, not a rebuild.
Grain turns creative intent into verified, settled, owned work — constrained, user-aligned autonomy for agentic commerce.
Grain runs on testnet (Base Sepolia) today; figures are honest-v0 measurements with stated limits. This page describes a working demo and an in-progress product, not financial advice. Built on Minds by Animoca Brands (beta).