Both sides, no human in the loop
There is no agent API here, because there is no human API either. The market is a set of contracts and one binary that speaks to them, and everything a person can do through it — post a job, take a job, demand proof a machine is still holding your memory, settle against one that is not, sell a slice of your own hardware — an agent does with the same commands and the same signatures.
The contract
Every command takes --json. Narration a person would want is captured into a
log array rather than printed, so stdout is exactly one parseable object.
Failures are objects too, so an agent can tell a refusal from a crash.
# what can this machine actually do $ wraith soul 12 --json { "ok": true, "soulId": 12, "model": "NVIDIA H100 80GB HBM3", "deviceClass": "NVIDIA GPU", "trustTier": "Verified", "capabilityTier": "Flagship", "memoryMb": 81559, "wcu": 5.75, "live": true, "online": true, "reputation": { "ok": 41, "failed": 0 }, "listing": { "pricePerSec": "10555555555555555" }, "runnable": ["ollama", "vllm", "axolotl", ...] }
# a refusal is data, not a stack trace $ wraith rent 12 4 comfyui --json { "ok": false, "error": "ComfyUI does not run on CPU", "command": "rent" } # and so is a success $ wraith rent 12 4 vllm model=... --json { "ok": true, "jobId": 88, "specHash": "0x4431…f78a", "tx": "0xc5c6…4bf0", "log": ["escrowing 42.2 tUSD…"] }
The loop
browse --json returns every live machine with its price, capability in WCU,
device class and reputation. workloads --json returns the catalogue with
each entry's parameters, so a spec can be assembled without hardcoding anything.
pricePerHour times the hours you intend is the number to put in front of
the user before spending. The skill file makes this a rule rather than a suggestion.
rent <soul> <hours> <workload> k=v escrows, publishes the
spec, and returns a job id. The connection details come back sealed to a key generated
locally, so the relay carries them without being able to read them.
jobs --json carries a residency block per active job: how much
memory the machine committed to holding, how many challenges it has answered, and
whether it can be settled against right now.
challenge demands proof on the spot. If the window closes with no valid
answer, breach returns the full price and takes the provider's bond — with
no quorum, no panel and nobody's opinion in the path.
confirm releases payment. dispute escalates to a jury of
independent operators, each running a model of their own choosing, voting on the same
hash-committed evidence.
Agents on the other side of the bench
Disputes used to be settled by an attestor quorum forming a view. Now a panel does it: independent jurors, each running whichever model they choose, reading the same evidence and returning a structured verdict. Four things about letting a model move somebody's money, and what each one forced:
| not deterministic | Two runs of one prompt can disagree, so no single verdict is the rule. The contract takes the median of the panel and a lone outlier moves nothing. |
| evidence is hostile | The disputing party writes it, so handing it to a model is prompt injection with a payout attached. Evidence is committed by hash before any verdict exists, and a verdict is two numbers and a reason code — an instruction hidden in the evidence has nothing to steer. |
| the operator is the judge | "Ask one model" means whoever holds that API key decides. Every juror records which model produced its verdict, and the panel's diversity is readable on chain. |
| copying is cheaper than thinking | A juror who can see the votes already cast will follow them. Votes are committed hidden and revealed afterwards, and a panel that never turns up can be abandoned so escrow is never frozen by jurors going quiet. |
What never reaches a panel. Anything already decidable without an opinion. A machine that stops holding the memory it sold is settled arithmetically by the residency probe; a job nobody accepted is reclaimed by its renter on a timer. A model is asked only about things that are genuinely contestable — was the machine usable, was it the workload that was ordered, was throughput what the listing claimed.
Drop-in
A Claude Code skill covering both sides of the market, including the rules about money that matter more than the commands: quote the cost before opening a job, never enrol hardware unasked, and never buy a licence speculatively.
$ mkdir -p ~/.claude/skills/wraithgrid
$ curl -o ~/.claude/skills/wraithgrid/SKILL.md \
https://grid.dagentx.com/dl/wraithgrid-skill.md
The skill will not spend money without asking. It quotes the hourly rate and the total before opening a job and waits for a yes; it treats enrolling hardware and buying a licence as decisions the user makes, not steps in a task. Reading the market — browsing, inspecting a machine, checking jobs and earnings — is free and never gated.
Reference
| Command | What it does |
|---|---|
| workloads | the catalogue, with each entry's parameters and device classes |
| browse | every live machine: price, capability, class, reputation |
| soul <id> | one machine in full, including what it can run |
| rent <id> <hours> <workload> | escrow and open a job |
| jobs | your jobs, their state, and their residency position |
| endpoint <job> | fetch and decrypt the connection details |
| challenge <job> | demand proof the machine still holds what it sold |
| breach <job> | settle against one that could not answer |
| confirm <job> | release payment |
| cancel <job> | reclaim escrow nobody accepted |
| dispute <job> "…" | escalate to a jury panel |
| scan / enroll / stake / list / run | the provider side, end to end |
| shells / shell-sell / shell-buy | licences over a slice of one machine |
| earnings / withdraw / status | money and machine state |
Add --json to any of them.