Mycelia

Inspiration

AI is becoming bottlenecked by compute.

Every major AI lab is racing to train and serve larger models, while hyperscalers spend billions on datacenters, compete for scarce GPUs, and consume massive amounts of energy and water. At the same time, hundreds of millions of gaming PCs, laptops, workstations, and dorm-room machines sit idle for most of the day.

That idle hardware is not useless. It is an untapped global compute layer.

Volunteer projects like BOINC proved that distributed consumer compute can work. Commercial compute-sharing platforms proved that people are willing to exchange idle GPU time for rewards. But the hardest problem remains unsolved for serious AI workloads:

How do you pay untrusted machines for useful work, verify they did not cheat, and coordinate heterogeneous consumer devices over slow home internet?

Rendering a fake image tile wastes a few pixels. A poisoned gradient can corrupt a model. A dishonest worker can drain a marketplace. A slow worker can block a training round. A bad ledger can destroy trust.

Mycelia exists to solve that full stack: distributed compute, AI training, verification, escrow, reputation, and marketplace economics in one runnable product.

The name comes from mycelium networks: many small independent nodes, no central brain, yet a resilient organism emerges. Mycelia applies that architecture to compute.

Many small devices. One living cloud.

What it does

Mycelia is a B2B distributed compute marketplace that turns idle consumer CPUs and GPUs into a verified compute cloud for AI, rendering, simulation, and batch workloads.

There are two sides of the market:

Contributors, called Cultivators, join the mesh and contribute idle compute from a browser, native daemon, or external training worker. They earn MYC credits only when their work passes verification.

Requesters submit compute jobs, prepay into escrow, and receive verified results. Funds are released only after the network proves the work was completed correctly.

The core product is not just “rent someone’s GPU.” Mycelia is a trust layer for untrusted compute.

Today, the live system supports:

Browser-based WebGPU workers with CPU fallback
Native multicore daemon workers
Plain-English job submission
Escrow-until-verified settlement
Append-only ledger accounting
Reputation, staking, slashing, and spot checks
Deep-zoom fractal rendering through real local compute
Distributed LoRA training with a live validation-loss curve
Canary-loss verification for training contributions
Refereed recompute for cheating detection
MCP read-only tools for AI agents
Health checks and ledger reconciliation
Postgres-compatible persistence designed for Aurora DSQL migration

The result is a production-shaped distributed systems product: requesters submit work, the mesh executes it, verification decides who gets paid, and the ledger proves the economics balance.

The problem Mycelia solves

The world is compute-constrained, but compute is also massively underused.

Large companies can buy access to hyperscaler clusters. Smaller AI teams, researchers, startups, creators, and independent developers often cannot. They face high prices, GPU waitlists, quota limits, and cloud bills that make experimentation expensive.

Meanwhile, consumer hardware is everywhere. Gaming GPUs, laptops, desktops, and workstations are already purchased, already powered, already cooled, and often idle.

The obvious idea is simple: use that idle compute.

The hard part is making it trustworthy.

A real compute marketplace must answer five questions:

Correctness: Did the worker actually run the computation?
Security: Can an untrusted machine corrupt the result or steal funds?
Economics: Can contributors be paid fairly without overpaying cheaters?
Scalability: Can many heterogeneous nodes coordinate without datacenter networking?
Usability: Can requesters submit jobs without learning distributed systems?

Mycelia was built around those constraints from day one.

Core innovation

Mycelia combines four systems that are usually separate:

A two-sided compute marketplace
A server-authoritative escrow ledger
A distributed AI training fabric
A multi-tier verification and anti-cheat system

The innovation is not just that idle devices can compute. The innovation is that idle devices can become economically useful, verifiably correct, and safe enough for business workloads.

Every workload class declares its own verification primitive:

Fractal rendering uses deterministic self-checks and refereed recompute.
Monte Carlo simulations can be reseeded and reproduced.
LoRA training uses canary-loss acceptance tests and reputation-weighted payouts.
Batched inference can use deterministic recomputation.
Future training attestations can use zero-knowledge proofs.

This makes Mycelia a verification-first compute marketplace, not a generic job queue.

How users interact with it

Contributors: earn from idle hardware

A contributor opens the Network screen and joins the mesh. Their browser becomes a compute node with no install required.

The worker pulls real jobs from the coordinator. In the live demo, it computes deep-zoom Mandelbrot tiles using a WGSL WebGPU shader, with a CPU Web Worker fallback when WebGPU is unavailable. The result is hashed, submitted, verified, and paid through the ledger if accepted.

For more serious contribution, the native daemon can harvest idle multicore CPU without browser throttling.

External AI training workers can also join through the Python worker flow. They pull LoRA training rounds, run local optimization, submit compressed adapter deltas, and receive payment only if verification accepts the contribution.

Requesters: submit work in plain English

A requester opens Marketplace and describes the job, for example:

“Render a 4K deep zoom into the Seahorse Valley and keep it cheap.”

Mycelia turns that request into a structured job spec, validates it, debits escrow atomically, fans the work out to the mesh, and updates the job as tiles move from pending to claimed to verified.

The requester does not need to understand worker scheduling, distributed verification, or payment settlement. Mycelia abstracts that away.

Researchers: run distributed LoRA training

The Network screen includes a distributed training panel where validation loss drops round by round. Heterogeneous cells contribute different amounts of work, faster nodes receive larger shards, and bad updates can be rejected by canary-loss checks.

The training architecture is based on a WAN-friendly insight:

Split data often. Split models only when forced.

For models that fit on a single GPU, each cell trains a LoRA adapter on a local data shard, runs multiple local steps, and sends a compressed adapter delta back to the coordinator. This avoids the constant high-bandwidth synchronization required by traditional datacenter training.

For models larger than one device, Mycelia includes proof-complete pipeline and tensor parallelism modules that validate gradient equivalence in-process, with peer-to-peer activation transport on the roadmap.

Distributed training architecture

Most hackathon AI projects fine-tune on one GPU and show a chart. Mycelia builds toward a distributed training fabric where consumer hardware can contribute to real model improvement.

The system uses two regimes.

Regime 1: WAN-friendly LoRA training

This is live.

Each cell trains the same LoRA adapter on a different data shard. Cells run local steps, compress their adapter deltas, and submit them to the coordinator. The coordinator merges accepted deltas using an outer optimization loop.

This works over home internet because the system ships megabytes occasionally, not gigabytes every microsecond.

Key pieces:

LoRA/QLoRA-style trainable surfaces
Heterogeneous shard assignment
Capability-weighted contribution
Top-k and int8 compression
Error feedback
Canary-loss verification
Reputation-weighted payouts
External Python worker support

Regime 2: model-parallel cells

This is proof-complete and roadmap-ready.

When a model is too large for one device, a cell can become a group of devices that hold different parts of the model. Mycelia includes pipeline-parallel and tensor-parallel gradient-equivalence proofs, showing that the distributed computation matches monolithic training under controlled conditions.

The production roadmap adds WebRTC peer-to-peer activation transport, stage-level verification, and cryptographic attestations.

Verification moat

Compute is commoditized. Trust is the product.

Mycelia’s main technical moat is its verification stack. A compute marketplace fails if it pays cheaters, allows overdrafts, or cannot explain settlement. Mycelia treats verification as the foundation of the product.

The system uses four escalating trust tiers:

L0 — Economic trust Stake, reputation, slashing, and dynamic spot-check rates.

L1 — Deterministic verification Self-checks for deterministic workloads and canary-loss bounds for AI training contributions.

L2 — Refereed recompute A cheaper dispute mechanism that binary-searches to the first divergent operation instead of recomputing an entire workload.

L3 — Cryptographic attestation A zero-knowledge proof roadmap using SP1-style attestations for honest local training steps.

Every job follows the same economic rule:

Prepay into escrow. Verify the work. Pay only accepted results.

The ledger is server-authoritative, settlement is idempotent, and reconciliation checks prove that jobs cannot overspend escrow.

Product surface

Mycelia is not only a backend prototype. It is a full product with multiple live surfaces:

Landing Shows mesh stats and introduces the compute marketplace.

Marketplace Lets requesters submit jobs, validate specs, debit escrow, and fan out work.

Network Allows contributors to join the mesh, compute WebGPU tiles, watch job progress, and observe distributed training.

Trust & Economics Demonstrates staking, slashing, referee verification, region-aware payout logic, and unit economics.

Earnings / Ledger Shows credits, settlement, redemption paths, and contributor balances.

Dashboard Displays node telemetry, contribution controls, and hardware participation.

Health Runs reconciliation checks, liveness checks, and invariant validation.

Cloud Documents the production migration path, including Postgres-compatible persistence and Aurora DSQL readiness.

Sign-in and roles Supports requester, provider, and hybrid roles with server-side gating.

MCP agent surface Exposes read-only tools so AI agents can inspect the mesh, explain settlements, and monitor training without being able to move money.

How we built it

We built Mycelia as a full-stack distributed systems product with a trust-first architecture.

The frontend is built with Next.js, React, TypeScript, Tailwind CSS, and Vercel-oriented deployment patterns. The backend uses API route handlers, Zod validation, server-side authorization, rate limiting, transaction wrappers, and a Postgres-compatible schema.

For the local demo, the database runs on PGlite. The schema and transaction model are designed around Postgres compatibility so the persistence layer can migrate to Aurora DSQL with a focused driver swap instead of a full rewrite.

The compute layer includes:

Browser WebGPU execution
WGSL compute shaders
CPU worker fallback
Native daemon worker support
External Python training workers
Pull-based work claiming
Deterministic verification paths
Coordinator-managed settlement

The AI training layer includes:

DiLoCo-style outer optimization
LoRA adapter training
Heterogeneous worker assignment
Compression with top-k, int8, and error feedback
Canary-loss acceptance
Pipeline-parallel proof modules
Tensor-parallel proof modules
Training status APIs
Checkpointing and metrics interfaces

The economics layer includes:

Escrow debits
Verified payouts
Append-only ledger entries
Idempotent settlement
Staking and slashing
Reputation updates
Spot-check scaling
Reconciliation sweeps

We scoped the project around one principle:

Build the hard trust path first, then attach workloads to it.

That is why the demo includes not only visuals, but also cheating detection, ledger invariants, payout logic, and health checks.

Technical depth

Mycelia includes:

54 API route handlers
17 distributed training modules
92 Vitest unit tests
Live smoke integration tests
Zod validation on write paths
Rate limiting on public endpoints
GitHub Actions CI
Browser WebGPU compute
CPU worker fallback
Native daemon support
Python external worker support
Rust native-cell and zk-related crates
gRPC protocol definitions
YAML training job configurations
Terraform, Kubernetes, and Prometheus production stubs
11 Mermaid architecture diagrams
Postgres-compatible persistence
Aurora DSQL migration path
MCP read-only agent tools

This is intentionally more than a UI demo. Mycelia combines distributed systems, machine learning, verification, marketplaces, and cloud architecture into one coherent application.

Challenges we ran into

PGlite transaction discipline

PGlite’s single-connection model made transaction discipline critical. Calling module-level query helpers from inside transaction callbacks could deadlock, so we enforced a strict pattern where writes go through transaction handles.

This also made the future Aurora DSQL migration cleaner because database access is centralized.

WebGPU precision differences

The GPU path and CPU path do not always produce perfectly identical floating-point results. Instead of pretending they would, we designed verification to tolerate acceptable numerical drift where appropriate.

That is the difference between a demo that works once and a system designed for real hardware variability.

Training over home internet

Distributed AI training is not mainly a FLOPs problem. It is a communication problem.

Consumer devices do not have InfiniBand. They have variable bandwidth, Wi-Fi, throttling, and unpredictable availability. This drove the design toward LoRA adapters, local training steps, compressed deltas, and WAN-friendly synchronization.

Heterogeneous workers

A gaming desktop, a laptop, and a slow CPU worker cannot be treated equally. Mycelia assigns work based on capability, allows slow nodes to contribute without blocking the round, and pays based on accepted useful work.

Trust and economics

The hardest part was not dispatching jobs. The hardest part was making sure the system does not pay for bad work, double-pay contributors, overspend escrow, or allow the ledger to drift.

That is why the Health screen and reconciliation checks are central to the demo.

Accomplishments we are proud of

We are proud that Mycelia is a real end-to-end system, not a mock dashboard.

The live flows include:

Submit a job
Debit escrow
Fan work out to the mesh
Execute compute in the browser
Verify results
Reject bad work
Slash cheating nodes
Update reputation
Pay accepted contributors
Reconcile the ledger
Display health and economics
Run distributed training
Show validation loss decreasing
Allow external workers to join

We are especially proud of the verification layer. Many distributed compute ideas assume honest workers. Mycelia assumes workers may be adversarial and builds the product around that reality.

We are also proud of the distributed training architecture. Instead of just showing a model-loss chart, we implemented the pieces that make consumer-hardware training plausible: LoRA deltas, WAN-friendly synchronization, heterogeneous cells, compression, canary validation, and model-parallel proof modules.

Finally, we are proud that the project is explainable. The README, diagrams, demo surfaces, tests, and health checks make the system auditable by judges, developers, and AI agents.

What we learned

The biggest lesson was that trust is the product.

A marketplace for compute is not valuable just because it finds machines. It is valuable if requesters can trust the results and contributors can trust the payouts.

We also learned that distributed AI training across consumer hardware requires a different architecture than datacenter training. Instead of frequent synchronization across high-bandwidth links, Mycelia minimizes communication by training small adapter surfaces locally and syncing compressed updates less often.

Another lesson was that honest roadmap labeling is stronger than overclaiming. Mycelia clearly separates what is live today from what is proof-complete, stubbed, or planned. That makes the project more credible, not less.

We also learned that agent-native infrastructure needs strict boundaries. The MCP interface is read-only by design: agents can inspect the mesh and explain settlement, but they cannot authorize payments.

What is live today

Live today:

Browser WebGPU compute
CPU fallback workers
Native daemon worker
External Python training worker
Job submission
Escrow ledger
Verified payout flow
Deep-zoom tile rendering
Distributed LoRA training panel
Canary-loss rejection
Refereed recompute demo
Stake, reputation, and slashing
Health reconciliation
MCP read-only tools
Auth and role gating
Postgres-compatible schema
Unit tests and smoke tests

Roadmap-ready or stubbed:

Aurora DSQL production migration
Multi-region coordinator failover
WebRTC peer-to-peer activations
Production-grade sandboxing
SP1 zero-knowledge training attestations
Larger model-parallel training cells
Additional workload classes such as 3D rendering, ETL, and batched inference

The gap between the demo and production is infrastructure hardening, not a missing architecture.

Business model

Mycelia is designed as a monetizable B2B marketplace.

Requesters pay for verified compute. Contributors earn MYC credits for accepted work. Mycelia can monetize through platform fees, enterprise requester plans, higher-trust verification tiers, priority scheduling, managed training jobs, and redemption spreads.

The target customers are:

AI startups
Research labs
Universities
Indie AI builders
Rendering teams
Simulation-heavy teams
Data-processing teams
Companies priced out of premium cloud compute

The value proposition is simple:

Run latency-tolerant workloads cheaper than hyperscalers by using verified idle compute.

Why this matters

Mycelia matters because compute access is becoming one of the biggest barriers in AI.

If only the largest companies can afford training and experimentation, innovation narrows. A verified consumer compute mesh could help smaller teams fine-tune models, run experiments, render workloads, and process data at lower cost.

The sustainability story is also important. Mycelia does not require building a new datacenter to unlock more compute. It uses hardware that already exists and is often idle. Contributors can control power limits, schedule availability, and participate when it makes sense.

Most importantly, Mycelia treats correctness as a first-class requirement. A cheaper cloud is not useful if nobody trusts it. The verification stack is what makes the marketplace credible.

Why Mycelia should win

Mycelia is strong across the core hackathon judging criteria.

Innovation

Mycelia combines consumer compute, AI training, escrow settlement, anti-cheat verification, reputation, slashing, and agent-readable infrastructure in one product. It is not just another AI wrapper or CRUD app.

Technical execution

The project includes real compute workers, real API routes, real ledger logic, real training modules, real tests, and a clear database migration path. It demonstrates systems engineering, AI infrastructure, marketplace design, and security thinking.

Completeness

The end-to-end flow works: submit, escrow, compute, verify, pay, reconcile. The system includes contributor experiences, requester experiences, operator health checks, and agent read-only tools.

Impact

Mycelia addresses a major real-world problem: compute scarcity. It gives smaller teams a path to cheaper batch compute and AI experimentation while making use of idle hardware that already exists.

Demo quality

The demo is visual, interactive, and verifiable. Judges can join the mesh, watch real tiles compute, see training loss change, observe cheaters get rejected, and run tests that verify core invariants.

Differentiation

Most hackathon projects in AI infrastructure are either dashboards, wrappers, or architecture diagrams.

Mycelia is different.

A typical project says: “We would distribute compute.” Mycelia runs browser and external workers.

A typical project says: “We would pay contributors.” Mycelia implements escrow, settlement, ledger entries, and reconciliation.

A typical project says: “We would prevent cheating.” Mycelia includes deterministic checks, canary-loss rejection, referee recompute, slashing, and reputation.

A typical project says: “We support AI training.” Mycelia implements distributed LoRA training, compressed deltas, heterogeneous cells, and gradient-equivalence proof modules.

A typical project says: “We are cloud-ready.” Mycelia uses a Postgres-compatible schema with a clear Aurora DSQL migration path.

A typical project says: “AI agents can use it.” Mycelia exposes read-only MCP tools while protecting the payment layer.

That is the difference between a demo idea and a product architecture.

Built with

Next.js, React, TypeScript, Tailwind CSS, PGlite, Postgres-compatible SQL, WebGPU, WGSL, Node.js, Python, Rust, Vitest, Zod, Claude API, MCP, gRPC, Terraform, Kubernetes, Prometheus, GitHub Actions, Vercel, AWS Databases architecture planning, Aurora DSQL migration design.

Concepts used include distributed systems, compute marketplaces, escrow ledgers, LoRA, QLoRA, DiLoCo, pipeline parallelism, tensor parallelism, canary-loss verification, refereed recompute, staking, slashing, reputation systems, zero-knowledge proof roadmaps, SP1, WebRTC, consumer DePIN, and verification economics.

Try it out

Clone the repository, install dependencies, and run the app.

git clone https://github.com/GodlyDonuts/Mycelia.git
cd Mycelia/frontend
pnpm install
pnpm dev

Then open the app, go to the Network screen, join the mesh, and watch the browser compute real work.

Optional external worker:

pip install requests numpy
python examples/train_worker.py

Judges can also run the test suite and smoke checks to verify the core invariants.

pnpm test
pnpm test:smoke

Final summary

Mycelia is a verified distributed compute marketplace for AI and batch workloads.

It turns idle consumer hardware into a useful compute cloud, but its real breakthrough is trust: escrow-until-verified settlement, workload-specific verification, anti-cheat economics, distributed LoRA training, and a server-authoritative ledger.

The project is monetizable, technically deep, visually demonstrable, and architected for real-world deployment.

Mycelia is not just trying to make compute cheaper.

It is trying to make the world’s idle compute trustworthy.

Built With

account-balances
account-serialization
ai-infrastructure
amazon-aurora-dsql
amazon-web-services
analytics
anthropic-api
anthropic-api-key
anthropic-model
api-gateway
append-only-ledger
aurora-dsql-signer
aurora-postgresql
auth
aws-databases
aws-sdk
b2b-saas
backend
bank-redemption
base-ui
batch-compute
binary-search-recompute
browser-compute
browser-workers
canary-loss
capability-sandbox
cash-out
charts
cheat-rejection
ci-cd
class-variance-authority
claude
claude-opus
cloud-database
cloud-fallback
clsx
compute-client
compute-cloud
compute-marketplace
concurrency-control
connection-pooling
contribute-api
contribution-bars
coordinator
cpu-compute
crypto-redemption
css
daemon
dashboard
data-parallelism
database-ledger
database-migrations
database-url
deep-zoom
delta-rejection
deterministic-kernels
deterministic-self-check
deterministic-verification
diloco
distributed-computing
distributed-lora
distributed-rendering
distributed-systems
driver
duty-cycle
earnings-screen
economics-engine
edge-compute
embedded-database
environment-variables
escrow
escrow-debits
eslint
external-worker
feature-detection
fedavg
firebase
fractals
fraud-resistance
frontend
full-stack-app
fuzz-tests
gift-card-redemption
github-actions
gpu-compute
gpu-timing
health-monitoring
health-screen
hmac
hyperscaler-alternative
iam
icons
idempotency
idle-scheduling
in-process-simulator
infrastructure-marketplace
javascript
jose
json-rpc
jsx
jwt
keyword-parser
kyc
landing-page
ledger
local-first-development
lora
lucide-react
mandelbrot
marketplace
marketplace-screen
mcp
mesh-liveness
mesh-network
metrics
monte-carlo
monte-carlo-pi
myc-credits
mycelia-db-driver
native-daemon
natural-language-parsing
network-screen
next.js
node-heartbeats
node-postgres
node.js
npm-package-json
observability
occ
open-pull-api
payouts
pg
pglite
pnpm
polling
postcss
postgres-compatible-schema
postgres-in-wasm
postgresql
power-capping
provider-role
python
rate-limiting
rbac
rds
rds-ca
react
react-dom
read-path
recharts
reconciliation
refereed-delegation
reputation-scoring
reputation-system
requester-role
rest-apis
route-handlers
saas
sandbox
sandboxed-kernels
schema-validation
sellable-fraction
serializable-transactions
server-authoritative-ledger
serverless-functions
sessions
shadcn
shared-db-connection
shell
sign-in-flow
slashing
smoke-tests
spot-checks
sql
sqlstate-40001
staking
state-machine-tests
streamable-http
structured-output
supply-engine
tailwind-css
tailwind-merge
tailwindcss
tax-disclosure
tile-assembly
tile-rendering
tls
token-bucket
train-worker
training-pipeline
transaction-retries
trust-economics-screen
trust-engine
tsx
tw-animate-css
typescript
ui-components
unit-economics
unit-tests
v0
validation-loss
vercel
vercel-analytics
verification
verification-registry
verified-payouts
vitest
wasi
wasm
wasmtime
web-app
web-workers
webassembly
webgpu
wgsl
worker-threads
write-endpoints
zod