The distributed execution plane I built to connect workers, storage, inference services and tools across machines and providers.
Fabric moved from individually tested components to a repeatable distributed system with explicit identity, observable routes, verified transfers and evidence which survives the test run.
A five-coordinator reference environment now bootstraps from empty state, registers each role, establishes mutual-TLS links, converges on the expected routes and verifies that traffic follows the intended cross-link.
Metrics, process evidence and coverage-aware soak analysis distinguish healthy quiet periods from dead processes, stalled routes and measurements which only look reassuring.
Fabric brokers a direct client connection when possible and falls back to a cut-through relay when it is not. Both ends retain independent audit evidence for the path and payload they verified.
The distributed acceptance environment held 10,000 authenticated sessions, completed the balanced workload without loss and retained the one skewed-run timeout which occurred during the intentional final drain.
On a private 10 Gb/s network, direct transfer reached 97.8% of the measured network baseline. Relay performance remained bounded and useful, while a 5.5% endpoint-replacement shift narrowly missed the provisional repeatability gate.
Fabric is related to SkyeEngine, but it has its own protocol, trust boundary, topology, failure modes and acceptance evidence. It is useful anywhere durable work has to span machines without teaching every service about the physical network underneath.
Fabric began at the point where model-building work stopped fitting on one machine. GPU workers, storage, inference services and tools could live in different racks, providers or countries. Connecting them with one-off tunnels and service-specific discovery would have pushed the physical network into every application.
I built a separate execution plane instead. SkyeEngine can use it, but Fabric does not depend on SkyeEngine’s dataset or training tools. That boundary is important enough that Fabric belongs here as its own project.
Coordinators form root, distribution and access tiers. The root owns signed identity and global state without becoming the transit path for every byte. Distribution coordinators carry routes between regions; access coordinators attach workers, storage and tools at the edge.
Services ask Fabric for a verified peer and route instead of learning which provider, address family or tunnel happens to sit underneath it.
The control plane authorizes and introduces endpoints. File data then moves directly between clients when they can reach each other. When they cannot, the fallback is a bounded cut-through relay across the coordinator path rather than buffering the complete object in memory.
That keeps central coordination from becoming an accidental universal bottleneck while retaining a working path through less convenient networks.
Acceptance checks prove whether a transfer was direct or relayed, compare independent integrity records from both ends and retain coordinator evidence for every relay hop. The telemetry covers routes, links, handlers, queues, authentication, verification, process resources and test-generator state.
A throughput number without that evidence would only prove that some bytes moved quickly somewhere.
The reference and rented environments are scripted from empty state through credentials, immutable images, firewalls, verification and evidence export. That repeatability exposed hard-coded development paths, misleading status, certificate-cache failures and several assumptions which unit tests had politely ignored.
The operational material and private endpoints remain private; this page documents the architecture, outcomes and lessons rather than publishing a runbook.
The network now has a tested control plane, direct and relayed transfers, signature enforcement, recovery exercises and serious throughput evidence. The next work is broader integration with the systems which schedule inference, storage and durable jobs, plus more transport characterization on independent hardware.
Fabric remains a first-class system while it becomes a more useful execution layer beneath SkyeEngine.