Your idle GPU, earning quietly.
Run AI inference jobs on hardware you already own. Workers earn credits redeemable for cash or TRD build credits — no middleman, no markup, no auction games. Built on the open decentralized stack.
No config files. No tuning passes. Run one command, the worker benchmarks itself, picks safe defaults from your GPU class, and starts earning. Adjustments via dashboard — never required.
What's live now, in-flight, and next.
Worker reliability surfaces
Public worker cards + bench-class chips. Customers see uptime, P99, success rate before assigning jobs.
Warm-model preference ranker
Routes jobs to workers that already have the model in VRAM. ~3× faster first-token; zero customer config.
Predictive engine · 10 rules
Long-job re-queue, worker update notices, smart onboarding, scale-to-zero — all signed and chained.
Worker revenue share Phase 1
Demand-backed share of customer rate × tier multiplier (0.9 / 1.0 / 1.15). Auto-records per completed job for enrolled workers.
No-charge cold-start policy
Module shipped + audit-gated. Customers won't pay for the milliseconds workers spend waking up from paused state.
Verified worker badge
90-day clean-audit badge. Phase 1 cache + countdown shipping today; auto-promotes as audit history accumulates.
USDC payout reconciliation
Daily settlement cron + Coinbase/Stripe rail. Worker earnings settle on-chain or off-chain by their enrollment preference.
Federated dispatch + governance
Pod-to-pod chain-head attestations + operator governance pane. Foundation for sovereign compute pools.
Worker reputation SBT · Base mainnet
Contract 0xbDd1f5fC349D9a8EfCEb07Edbd491233b2540f5F live on Base. First mint executed. Worker reputation anchored on-chain.
Developer marketplace · submit + review
Public submit page live. Reviewer queue at compute.trdn.io for community agent contributions.
EU passive region · api-eu.trdn.io
trd-backend-eu deployed. GHCR images now public: ghcr.io/trdnetwork/{orchestrator,receipt-signer,ipfs-gateway,predictive-engine}:0.1.0.
Three commands. Then your GPU earns while you sleep.
No web forms, no rate negotiations, no proprietary runtimes. Install the open-source worker, register once, run the daemon. Jobs flow in when there's demand; you keep the credits.
Install the worker
One pip command. Python 3.9+, NVIDIA CUDA or Apple Silicon. The worker is open source — read every line if you want.
pip install trd-worker
Register your machine
One-time login with your email. The worker auto-detects your GPU, picks compatible models, and sets a fair earning rate based on the hardware tier.
trd-worker login
Start earning
Run the daemon and walk away. It heartbeats, polls for jobs, executes inference, submits results. Pause on battery, schedule windows, model whitelists — all configurable.
trd-worker start
Five things every other GPU marketplace
made harder for the worker.
TRD owns the demand side — every site built on trdn.io is a real job. That changes the worker economics from speculative to guaranteed. These five mechanics are already coded; this is where they show up.
Public reliability score SCORED LIVE
Each worker gets a public 0–100 reputation badge — "98% reliable, 1,240 jobs" — so renters know who they're hiring and good workers stand out.
From Vast.ai · already computed by TRD reputation engineWarm-model preference + reward DISPATCHED
Workers that already have the right model loaded get prioritized — and rewarded. Cuts p50 build time and pays the worker a warm-pool credit bonus. is_warm already returned by dispatch RPC.
Worker trust tiers 3 BANDS
Reputation buckets workers into Probation → Verified → TRD Trusted. Trusted workers get sensitive jobs and higher base rate. Earned, not bought.
From Vast.ai · gated by reputation engineZero-config worker setup ONE COMMAND
No Docker. No Kubernetes. No YAML. One pip install trd-worker and it auto-detects your GPU, runs the bench, registers, and starts earning. The whole onboarding is 4 commands.
Un-spoofable capability score MEASURED
We don't trust your self-reported GPU model. We measure tokens-per-second on a benchmark and auto-calibrate your rate. Faster GPUs earn more, slower ones earn less, no one games it.
From Vast.ai DLPerf · trd-worker bench commandA network designed for operators, not gamblers.
Transparent pricing. Settings the daemon actually honors. Realtime balance updates. Everything below is either live in production today or arriving in the next 90 days.
NVIDIA + Apple Silicon Live
Workers auto-detect GPU vendor, VRAM, CUDA version. Both consumer cards and Apple Silicon Macs are first-class.
User-set pause & schedule Live
Pause on battery, set daily windows, whitelist specific models — daemon honors your settings within five minutes of saving.
Realtime balance updates Live
Dashboard pushes balance and worker state via Supabase Realtime. Your credits tick up the moment a job submits.
Two redemption paths Live
Convert credits to TRD build credits instantly (1000 credits = $8 of build), or queue for cash payout via batch processing.
Open-source worker Live
Every line of the worker daemon is public on PyPI and GitHub. No telemetry, no closed binaries, no hidden phone-home.
Front-of-chain inference Live
TRD's own AI website builder routes a percentage of inference through the network. Real demand, not synthetic load.
Stripe Connect cash payouts Soon
Direct bank transfer in 30+ countries. Credits auto-convert at scheduled cadence. KYC flow handled per region.
Org workspaces & team caps Soon
Owner sets per-member daily earning caps and concurrent worker limits. For datacenter operators or studios pooling hardware.
Multi-model worker support Soon
One worker serves multiple model classes (7B + 13B) by VRAM tier. Better matching, fewer no-worker-available misses.
Worker reputation & slashing Soon
Workers that submit garbage results get reputation-scored. Below threshold = shadowbanned from new jobs. Honest workers earn more.
Real GPU benchmarking Soon
Workers run a standard llama.cpp benchmark on registration. Pricing scales with measured tokens/sec — fair to fast hardware, transparent to all.
Filecoin proof of work Soon
Each completed job's input + output pinned to Filecoin. Workers can prove later 'I produced this output at this time' — useful for arbitration and audit.
What your idle hours could be worth.
Earnings depend on hardware tier and active hours per day. Below is a fair estimate based on current network rates. Real earnings vary with demand, model availability, and your worker's uptime.
Rate estimate based on rate of 60 credits/hour for selected tier. 1000 credits = $8.00 USD equivalent. Earnings are best-effort — depend on real-time job volume, your worker's model coverage, and network availability.
Workers we support out of the box.
Auto-detected on registration. Suggested model coverage shown — workers can opt into lighter or heavier models depending on VRAM and thermal headroom.
RTX 3060 12GB
RTX 4070 / M3 Pro
RTX 4090 / M3 Max
A100 / H100
Wired into real demand, not synthetic load.
TRD Compute is the first paid customer of TRD Compute. Every site built through TRD's AI website builder routes a portion of inference through community workers. As we open the API, more partners join.
TRD AI website builder Live
Every TRD-built website fires 18+ inference jobs. A configurable percentage routes through the compute network.
TRD Storage Soon
Each job's input/output pinned to Filecoin via TRD's storage layer. Audit trail and arbitration without trust.
Public API Soon
Open inference API for third-party developers. Same network, same reliability cascade, same transparent pricing.
Every job, signed and pinned.
Front-runs Filecoin's 2026 verifiable-compute roadmap. Every dispatched inference job emits a signed ed25519 receipt — worker ID, model tier, tokens, duration, output hash — and the receipt is pinned to TRD Storage on Filecoin. Customer holds a verifiable artifact, not a marketing claim. Same receipt chain spans Compute + Storage + OS + Platform — the unified 4-product audit story no horizontal compute marketplace can match.
Ed25519 signed receipts Live
Every compute_inference job signed at execution time with the published trd-receipt-key-2026 private key. Canonicalized JSON envelope (sorted keys, no whitespace) — anyone can recompute the bytes and verify the signature.
Filecoin pinning via Lighthouse Live
Each signed receipt is content-addressed (CID) and pinned to the public Filecoin network through TRD Storage. Independent of TRD's servers — receipts survive vendor shutdown.
verify.trdn.io · client-side Live
Public verifier runs entirely in the browser. Paste any session ID — every signature validated client-side against the published public key. No trust in TRD's servers required. The trust is in math.
Audit-grade chain certificate PDF Live
Per-session PDF with stats grid, chain head CID, QR to verify, event breakdown. Send to compliance teams, regulators, or skeptical customers — they don't need a TRD account to validate.
Public network stats + JSON export Live
Live network rollup at trdn.io/stats, embeddable badge SVG, versioned JSON download at /api/storage/stats/public/network.json. CC BY 4.0 attribution — journalists and auditors quote freely.
Demand-backed worker revenue share Soon
Counter to GPUnex's three-sided model. Their investors fund speculative supply. TRD workers are backed by guaranteed existing demand — every trdn.io build is a job. Predictable revenue share tied to real platform volume, not utilization speculation.
What runs under the hood.
Five components, each in production today. The interesting boundary is the one between Compute and Storage: every job emits a receipt, and the same chain head CID surfaces in the OS dashboard and verify.trdn.io.
01 · Orchestrator (dispatch + reputation)
f_eligible_workers_for_dispatch RPC returns eligible workers per job, surfacing is_warm flag and reputation score (0-100). 8-tier reward formula (H100 → M2/M3 Pro) priced per measured tokens/sec, not self-reported specs.
02 · trd-worker (Python CLI daemon)
Open-source on PyPI. Auto-detects GPU vendor + VRAM + CUDA version. Honors user settings within 5 minutes (pause on battery, schedule windows, model whitelist). v0.3.x watchdog detects + reports stalled jobs.
03 · 5-tier inference cascade
TRD-CN (own community workers) → Cerebras (fastest qwen-3-235b) → Together / Gemini (balanced) → DeepSeek (cost-sensitive batch) → SambaNova (Llama 3.3 70B fallback). Routing decision per job class. Workers compete on tokens/sec, not vendor relationships.
04 · Receipt signer + Lighthouse pinning
Ed25519 signer normalizes PEM (handles BOM, quotes, escape patterns), canonicalizes envelope, emits receipt + Filecoin CID. Lighthouse SDK 0.4.5 for auto-pin. Public key at trdn.io/keys/trd-receipt-key-2026.public.pem.
05 · Stripe Connect + crypto payouts
Two redemption paths — instant conversion to TRD build credits (1000 cr = $8) or queue for cash payout via Stripe Connect (30+ countries). USDT/USDC withdrawal arrives next. Per-second billing on the renter side; per-job earning on the worker side.
Named, dated, honest.
Five phases from Stage 6 (closed) through full public-API distribution. We tell you what ships when, and the substrate behind each phase is already in production — phase milestones are productization steps, not invention.
Phase 1 · Stage 6 closed Shipped
End-to-end dispatch verified in production. Job submission → router selection → worker pickup → execution → result return — all paths green. trd-worker v0.2.0 verified on Apple M4 Pro. SSO between compute.trdn.io and /app22.
Phase 2 · Proof-of-Compute receipts Shipped
Every compute_inference job emits a signed receipt pinned to TRD Storage on Filecoin. Same chain spans Compute + Storage + OS + Platform. Front-runs Filecoin's own 2026 verifiable-compute roadmap.
Phase 3 · Wire BE→trd-cn dispatch In flight
Single highest-value pending item. Currently Stage 6 is "proven"; this turns it into every build is a real job. trd-backend-clean fires inference through trd-cn workers instead of paid providers wherever feasible.
Phase 4 · Demand-backed worker revenue share Soon
"Your GPU earns because TRD generates the jobs" — predictable revenue share tied to real platform build volume, not speculative utilization. Counter to GPUnex's three-sided investor-funded model.
Phase 5 · Worker scale-to-zero + warm pool Soon
Consumer-Mac availability windows. Worker declares hours, carries zero cost when idle, earns warm-pool credit bonus for being instantly ready when a build lands. Worker-side equivalent of RunPod FlashBoot scale-to-zero — for consumer hardware.
Phase 6 · Agent-aware dispatch (inverted MCP) Soon
io.net built MCP so strangers' agents could buy GPUs. TRD's 641 agents are already the buyers — wire the rest of the loop. Every TRD agent can call into trd-cn dispatch directly via MCP. Workers earn from agent-driven demand.
What TRD Compute won't do.
We've watched too many DePIN products oversell. Here is the honest list of things Compute is not built for, and won't pretend to handle.
Rent your whole machine to one tenant
RunPod and Vast.ai do that. TRD Compute runs short inference jobs (seconds to minutes) on your idle GPU while you keep using the machine normally. Different model entirely — pause for battery, schedule off-hours, throttle when you're gaming.
Run any arbitrary workload
Inference only. No mining, no training runs, no SSH tunneling. The worker daemon only accepts signed dispatch jobs from the TRD orchestrator — anything else gets refused. Predictable scope keeps the audit trail clean.
Promise speculative returns
No "stake your GPU and earn tokens." No yield-farming pitches. No revenue-share fund where investors fund speculative supply hoping renters appear. TRD generates the demand — workers earn from real platform build volume.
Train your model on customer data
Inference doesn't write back to model weights. Customer prompts and worker outputs are not used to train any model. Receipt chain proves what ran — and what didn't.
Hidden phone-home or telemetry
The worker is fully open source on PyPI + GitHub. Every network call documented: heartbeat (30s), poll for jobs, submit results, fetch your settings. No closed binaries, no anti-detection, no hidden phone-home. Sandbox it if you want.
Browser automation / RPA
TRD Compute is the inference layer. Browser-driving and platform-actions live in TRD Pilot — different product, different audience. Workers don't run a browser stack.
The questions that actually matter.
How much can I realistically earn?
What are credits worth?
Will this drain my electricity?
Can I trust the worker software?
What models does my worker run?
trd-worker models pull qwen2.5-7b-instruct (or whichever). Workers only claim jobs for models they've actually downloaded — no half-finished claims. You can whitelist specific models from the dashboard if you want a tighter allow-list.
What happens if my worker fails a job mid-execution?
Is this just RunPod / Vast.ai with extra steps?
Who pays for the inference?
What's the catch?
Your GPU is already on. Why not let it earn?
Sign in, register your worker, and the first credits land in your account before the kettle finishes boiling.