The compute layer connecting your devices
cadencIA turns browsers, phones and owned nodes into a web-safe worker network coordinated by Cloudflare. Real jobs, scraper-fed local memory and lightweight models first; deeper native nodes and cooperative compute next.
✓ Detect · WebGPU/Wasm · battery · visibility
✓ Pair · PWA heartbeat · temporary claimToken
✓ Route · requires · models · memory
✓ Complete · resultToken · optional embedding
This is how the live network appears
Each dot is a real device publishing capabilities: PWA browser, PC, phone, native node, local scraper or a provider such as ML Trainer. Pulses represent jobs, memory and results flowing through the control plane.
What already holds the CadencIA network together
Real jobs and measurable capabilities first; deep P2P comes later.
Global control plane
CoreCloudflare Worker + Durable Objects keep presence, job queue, leases, temporary results and rate limits. Devices do not need to share the same WiFi.
PWA workers and native nodes
The PWA detects WebGPU/Wasm, loads lightweight models and claims foreground web-safe jobs. The native node is reserved for durable work, local memory and longer tasks.
Capability routing
Each job declares requirements and each worker announces real capability: runtime, loaded model, foreground state, tokens and max job time. If it does not fit, it waits or takes another path.
Local memory, scrapers and cloud fallback
MiniLM in the browser indexes snippets and results imported from local scrapers. Native nodes will own durable memory; the Gateway decides cloud fallback within quotas.
ML Trainer joins as a live node capability
A local PC or server can train large/custom models with ML Trainer and publish them to CadencIA as an OpenAI-compatible provider. The Gateway still governs permissions, quotas and fallback; the node only announces that the capability exists and is ready.
The lifecycle of a distributed job
From the Assistant to the best visible device and back through the global control plane.
Assistant creates the job
The sending browser posts prompt, model and web_safe requirements to the public endpoint.
Result token
The API returns a temporary jobId and resultToken scoped to that result.
Capability filter
The scheduler compares runtime, foreground state, loaded model, tokens and max lease.
Worker claim
A visible PWA with Accept web jobs enabled claims the work using its claimToken.
Local execution
The receiver uses a local rule, Transformers.js or an already loaded WebLLM model; no downloads after claim.
Complete and poll
The result returns to the coordinator and the Assistant reads it with the resultToken.
Every node emits a Health Vector
The network does not assign tasks at random. It combines runtime, memory, battery, visibility, loaded models, benchmark and history to decide who processes what.
+ w₂ · Battery%
+ w₃ · 1 / Latency
+ w₄ · Stability
The network is the infrastructure, not the spectacle
The UI should show which device is alive, what it accepts and why it did or did not receive a job.
Capability map
The dashboard shows local browser, registered workers, available models and foreground state so the user understands the network without reading logs.
Operational memory
Local embeddings, telemetry and scraper data turn results, errors, documents and benchmarks into reusable signals for the next routing decision.
Quota economy
Cloud models enter as a fallback governed by budget, provider and organization; the node does not hold keys or decide spend alone.
Before promising science fiction,
cadencIA measures what it can already run.
The browser can already be a web-safe worker. The phone can accept jobs when it is visible. The PC can load lightweight models. Memory can be fed by local scrapers without exposing provider keys or forcing small devices. CadencIA orders those capabilities so Cadences can spend less, preserve more privacy and use hardware that already exists.
From local workers to a useful hive
Bootstrap from real devices: PWA, native nodes and owned hardware before promising massive distributed compute.
Phase 0 · Sentinels
Real PWA workers coordinated by Cloudflare: health, benchmark, web models, local memory, scraper connector and web_safe jobs distributed from the Assistant.
- Pairable PWA worker
- Assistant distributes compute
- Memory + scraper connector
Phase 1 · Closed alpha
Nodes authenticated in cadences.app accept small jobs, durable memory, scraper/document sources and hybrid routing to cloud models within cheap or free quotas.
- Node identity
- Durable scoped memory
- Local triage + cloud fallback
Phase 2 · Swarm memory
Nodes generate embeddings for telemetry, results and capabilities. The scheduler learns which device fits each kind of work.
- Local embeddings index
- Hybrid event search
- History-based trust score
Phase 3 · Cooperative compute
Opt-in distributed inference for concrete tasks. Lightweight and medium models first, with result verification before complex sharding.
- Multi-device scheduler
- Output verification
- Local hive federation