Circular Compute | Sovereign AI Infrastructure | Dweve Mesh

Choose the audience that matches your question

The page contains three selectable readings of the same subject.

Coding agent and operator assistance. Demo metrics are illustrative.

Terminal, search, lint, test, git, and more.

Remembers your codebase and team context.

Specialised agents collaborate across concerns.

Review diffs, request changes, final sign-off.

Replay any session bit-for-bit when something needs review.

Autonomous agents that write code and keep receipts

to handle network timeouts, 5xx responses, and idempotent-safe conditions. Pure helper, fully unit-tested.

CPU, GPU, NPU, FPGA announce what they can take

suitable AI work routed to suitable silicon

Working silicon draws more than idle silicon. The gain is everything else already paid for.

everything around the chip, already paid for

Your contribution covers Fabric Personal.

Idle machines lend a hand, so AI runs near you

the plan never changes underneath an active request

purpose: model evaluation, granted, revocable

read: dataset 14, principal named, timestamped

Evidence for demonstrating your policies. Not automatic compliance, not certification.

improved model, returned to every participant

individual updates masked, only the aggregate revealed

calculations over encrypted values where required

malicious or malformed participants, limited

malformed update, limited at aggregation

capacity under the published contribution terms

European compute, no new data centre first

current requirements shown before opt-in

A bounded share offered under personal rules

Availability schedule, SLA tier and jurisdiction

Subset authorised for the managed public Mesh

Rejected capacity stays outside the pool

Fabric Personal subscription while active

dweve-mesh node announce --cpu-cores 4 --storage-gb 20

covers your own Fabric Personal subscription

v1.0.0, peer to peer AI execution fabric

closed by default. Expansion path, not requirement.

your workload, inside the boundary you chose

same scheduling, settlement and evidence model in every posture

Public service credits and Dweve's managed constitution.

Customer fleet, with local controls and telemetry policy visible.

Own trust root, membership, pools, treasury, storage and audit.

Complete fabric, with every external socket sealed.

Required region, uptime, latency and evidence

Standalone is complete; federation is expansion, never a dependency.

available immediately, no compute contribution

then covered while its current terms are met

eligibility and contribution terms shown before opt-in

Fabric Personal covered; Aura not automatically included

A bounded share under your current rules

No files, history, passwords or accounts are contributed.

Aura, direct API access, organisation licences and Agent SDK rights are separate.

Reduce the contribution to zero and the route ends.

Memory, files, knowledge, helpers, workflows and sources.

Same Fabric Personal, different way of paying.

Choose the route whose current terms work for you.

while the contribution route stays active

a working machine draws more than an idle one

your machine, your limits, your local price, the work assigned

your limit dial sits on top of all of it

a bounded amount of spare capacity, in exchange for a product that otherwise costs EUR 19 every month

a lone machine waits while someone rents capacity elsewhere

connected spare hours become shared European capacity

the data centre that did not need building first

Measured energy and regional carbon, recorded against the actual workload and node.

One bounded source of qualified capacity

contributed work and consumed work, fairly, in credits you never handle

your contribution covers your subscription

no part time commodities trading while making coffee

a workload slice used the spare capacity you offered

resources flow back to what you are doing

work that no longer fits moves to another machine

in the same moment, not after a grace period

no queues, no dashboards, no server to babysit

a bounded slice of spare compute, sized by you

workloads get only the capabilities their job needs

A personal Fabric workspace with chat, files, memory and saved workflows.

Where did we leave the renovation budget?

Picking up your thread from Tuesday: the budget stood at the tiling quote.

Aura is not automatically included on the contribution route

managed through the public Dweve Mesh, within the processing boundary stated in the applicable terms

nothing about the computer is contributed

eligibility, requirements and controls shown before opt-in

processing boundary stated in the applicable terms

pixel for pixel the same workspace behind both doors

typed inference, generated from Protocol Buffers

Different front doors, the same workload and evidence objects.

type specific handler applies the change; the result is gossiped and logged

reputation and stake, combined under a cap; delegation with scope, expiry and cycle detection

Two peered meshes exchange work. Neither inherits the other's constitution.

automatic rollback restores the prior version

together or not at all; failure rolls back both

named states, no limbo; double settlement is impossible by construction

u64 with checked arithmetic, four implicit decimals, no floating point anywhere in settlement

never retried until it accidentally passes

exceeded: the subsystem steps down to degraded instead of pretending

syscalls filtered to granted capabilities

deny by default, rechecked at invocation

limit hit: run terminated, recorded in the receipt

hash committed to the audit chain: independent proof this receipt existed in this form

separate evidence layers, added where workloads demand them

independent cipher state and nonce counter per direction

old key, bounded grace period, then destroyed

Ed25519 + ML-DSA-65, together on every record

cumulative expenditure, three accountants, most conservative wins

threshold reconstruction survives dropout

FedAvg, weighted, FedProx, FedAdam, Krum, Multi-Krum, median, trimmed mean

Prove an update lies inside permitted bounds without revealing it.

the capacity Fabric announced is carrying a workload slice

draining: every request that started here finishes here

computed asynchronously, takes all new work

A short disconnection holds the node's assignment, model cache and session cache for sixty seconds. A returning node resumes in place; when the window expires, checkpoints and the successor plan take over.

session sticky: tokens return to the warm cache

Loom, 528 domain specialists, distributed over Mesh

hole punching bridges the NAT hidden nodes

hash committed to the tamper evident audit chain

That the record has not been changed since signing

That the output was correct, compliant or good

powered, maintained, secured, depreciating

because the estate cannot operate as one system

rented while the first invoice sits idle

nothing safely discovers, allocates and accounts for the estate's capacity

escrow locks the credits before the job begins

the job executes against reserved credits

on success, credits settle to the contributors

on failure, credits return to the requestor

The exciting parts are absent on purpose.

expiry sweep armed: an escrow that is never settled returns by itself

consumption is counted against the reserve while the job runs

reward = base rate x quality x peak bonus x demand bonus

fixed point arithmetic, no floats in settlement

tier missed: premium removed, reputation affected

a missed deadline can trigger a partial or full refund

wired into scheduling, settlement and reputation

True peer-to-peer topology, Raft consensus with Byzantine-robust federated aggregation, federated learning as a workload class, and homomorphic encryption, secret sharing, and zero-knowledge proofs in the scheduler. Read the architecture, then talk to an engineer.

Peer-to-peer compute. Privacy by primitive.

Binary operations vs traditional float AI

The substrate numbers the architecture rests on.

Prometheus-compatible scrape and OTLP push, with cost surfaced per cycle.

Register, drain, and audit nodes through authenticated operator endpoints.

Bidirectional streaming with token and budget tracking.

Submit, cancel, and monitor jobs over async and streaming calls. gRPC and REST.

A unified API exposes job submission, model inference, node management, and metrics over both gRPC and REST. Protocol Buffers definitions are generated from source, so the client surface never drifts from the implementation. Bidirectional streaming is supported for real-time inference, with token-by-token output, cooperative abort, and per-cycle budget tracking.

Configurable backoff with backup execution and checkpoint recovery on failure.

Default per-job ceiling, overridable when a workload needs longer.

Default per-task ceiling, with per-task overrides available for long workloads.

A job auto-decomposes into tasks across up to one hundred nodes by default. Operator-tunable.

Mesh offers multiple scheduling algorithms, load-balancing strategies, and fault-tolerance modes so operators can tune for latency, throughput, or utilisation. Caching, connection pooling, and hardware-aware optimisation are handled below the workload. Binary operations consume 96 percent less energy per operation than traditional float-based AI, which is what makes idle-device participation sustainable. The defaults below are sane, and every one of them is tunable per task or per job.