Intelligence. At Light Speed.
Switching, redefined.
A 1 Pb/s wafer-scale photonic fabric with an AI control plane — one device where a three-tier electrical network used to be.
We keep the light as light, fiber-in to fiber-out, and let software predict congestion before it forms. One hop. Zero conversions. Deterministic by design.
Predictive control · All-photonic fabric · Open SONiC/SAI · UALink + Ultra Ethernet
The bottleneck has moved
AI clusters got faster.
The network stayed electrical.
Optics carry the data between racks — then hand every packet to an electrical switching fabric to decide where it goes. That fabric is the network: leaf and spine switches, wired in a multi-hop tree. At AI scale it's the ceiling. Training traffic doesn't behave like the internet — tens of thousands of GPUs fire synchronized all-reduce bursts at the same instant, and every path has to cross the same congested spine.
“Reaction in milliseconds.
Damage in nanoseconds.”
Why electrical switching stops here
Three walls. Each rooted in physics, not engineering.
Each card shows the same shape of failure: demand for petabit-scale AI climbs — and slams into a hard physical limit that no amount of tuning can move.
Wall 1
The Power Wall
Switching a petabit electrically needs kilowatts per device — straight past any cooling envelope. Today's largest ASIC already burns hundreds of watts to move a fraction of the bandwidth.
Wall 2
The Latency Wall
Every optical→electrical→optical conversion costs nanoseconds, and a spine-leaf fabric forces four hops per GPU-to-GPU path — stacking up far above what synchronized training can tolerate.
Wall 3
The Complexity Wall
No single switching device on the market exceeds ~100 Tbps. A petabit needs ten of them — so the fabric explodes into thousands of switches and a hundred thousand cables, each a failure point.
You cannot optimize your way through a wall. You have to remove it.
From reactive to predictive
Don't manage congestion. Prevent it.
Today's fabrics wait for a queue to overflow, then signal backward and hope — ECN and PFC arriving milliseconds after the damage is done. We flip the model. An embedded control plane reads the fabric's own signals and predicts the micro-burst before it forms, reconfiguring the path in sub-microseconds. Not statistical multiplexing. Deterministic traffic engineering.
We don't only predict the burst — we pre-build the path for it. When a training job declares its next collective, PetabitSwitch pre-provisions the optical circuits before the traffic arrives.
We don't route packets faster. We route them before they collide.
- packets lost
- tail latency spikes
- 0 loss
- deterministic latency
- line held
Same triggering event · synchronized timeline
One device, in four numbers
PetabitSwitch.
1 Pb/s
Aggregate switching
~10× today's largest merchant ASIC.
< 1 ns
Per-hop latency
~100× lower than a four-hop electrical fabric.
0
O/E/O conversions in the switch path
All-photonic, fiber-in to fiber-out.
5
Integrated layers
From photonic fabric to AI engine, in one wafer-scale device.
Not an increment. A reset.
Six advantages, structural — not tuned in.
~10×
power efficiency
Under 500 W of switching power for a petabit of bandwidth, where an equivalent electrical multi-hop fabric burns tens of kilowatts.
~100×
lower latency
A single sub-nanosecond hop replaces the four-hop electrical path.
~10×
bandwidth density
A petabit per second in a wafer-scale footprint; one device stands in for a shelf of spine switches.
Zero
packet loss
Deterministic traffic engineering instead of statistical multiplexing.
Zero
O/E/O
Photons never leave the optical domain inside the switch.
40–60%
lower operating cost
With an order-of-magnitude fewer link failures to chase.
Where PetabitSwitch sits
Scale-up. Scale-out. Scale-across. One fabric, one hop.
Modern clusters scale three ways at once — up inside a GPU domain, out across the cluster fabric, and across halls and buildings. Every direction adds endpoints, cables, and hops to the electrical spine. PetabitSwitch collapses the scale-out tier into a single petabit-class device: the domain gets larger, the fabric gets simpler, and no path ever grows past one hop.
Electrical
PetabitSwitch
Beyond the copper wall
Grow the super-GPU past copper.
Inside a GPU domain, accelerators don't send packets — they share memory. NVLink and UALink bind them into one coherent machine, and today that machine stops at the edge of a rack or two: copper can't carry coherent memory traffic any further. PetabitSwitch carries it in light.
A direct-circuit, zero-conversion load/store path holds cache-coherent memory semantics across the fabric — so the coherent domain grows from a rack to a row without leaving the optical domain or crossing an electrical hop.
The super-GPU gets bigger. The reach wall disappears.
One data plane, both dialects
Memory traffic and message traffic, on the same light.
Scale-up speaks memory-semantic — UALink, NVLink. Scale-out speaks message-passing — Ultra Ethernet, RoCE. Most fabrics pick one and bridge to the other through a gateway that adds a hop and a conversion.
PetabitSwitch runs both on one protocol-agnostic optical data plane: UALink circuits and Ultra-Ethernet flows sharing the same wavelengths, switched as light, with no gateway tier between them. One fabric for the whole cluster — not one per domain.
The traffic that breaks everyone else
All-reduce. All-gather. In lockstep, without collapse.
AI training isn't random traffic — it's synchronized collectives, where every GPU in a job hits the fabric at the same microsecond and the slowest path sets the pace for all of them. Statistical fabrics assume randomness and choke exactly here. PetabitSwitch is built for the opposite: deterministic, lossless paths that hold their timing when ten thousand ranks fire together — so a straggler link never stalls the whole job.
Electrical · one slow link
PetabitSwitch · ring completes
In-network reduction · N in → 1 out
Reduce on the way through. PetabitSwitch can combine gradients in-network as they pass, so the collective completes with less data crossing the wire and less waiting on the slowest rank.
Bandwidth and latency, not either-or
Petabit bandwidth for training. Sub-nanosecond paths for inference.
Training is bandwidth-bound — terabytes of gradients across huge GPU domains. Modern inference is latency-bound — disaggregated serving, KV-cache transfer, and expert routing that live or die on tail latency. Most fabrics optimize for one and tax the other. A single all-photonic hop delivers both at once: the raw bandwidth training needs and the deterministic, sub-nanosecond latency that keeps token generation fast and steady.
Same device · both modes
GPUs should compute, not wait
Every stalled GPU-hour is capital burning idle.
Your most expensive asset is the GPU — and it sits idle every time the network stalls a collective or drops a packet into a retransmit. PetabitSwitch attacks that waste at the source: zero packet loss and deterministic latency mean more of every GPU-hour spent computing instead of waiting. On a 100,000-GPU cluster, every 1% of utilization recovered is roughly $30M a year of GPU capital put back to work — and the switching fabric itself draws under 500 W instead of tens of kilowatts.
Recovered GPU capital
$30M
GPU capital back to work · per year
Many tenants, one fabric
Slice the light. Prove the isolation.
A shared or sovereign cluster has to guarantee that one tenant's traffic can't perturb another's. PetabitSwitch partitions the fabric by wavelength — each tenant gets its own graded-isolation slice of the optical spectrum — and then proves it.
A falsifiable isolation probe drives every slice to saturation and checks, byte for byte, that a noisy neighbor changed nothing. Isolation you can attest, not just assert.
Wavelength slices · graded isolation
Tenant A
Tenant B
Tenant C
Tenant D
SOLO · TENANT A
1,048,576 bytes
CO-RESIDENT · ALL SATURATED
1,048,576 bytes
Byte-identical · isolation attested
Beyond telemetry
Seeing the stall isn't stopping it.
A new class of tools can finally see congestion across GPUs and switches in fine detail — and that's real progress. But observation still arrives after the damage: you learn which collective stalled once the tokens are already lost. PetabitSwitch closes the loop inside the fabric — predicting the micro-burst and re-routing before it forms — so the stall never happens in the first place. Visibility tells you what went wrong; we make sure it doesn't.
Observe
Prevent
The scale that's coming
Built for the cluster you'll run in 2028, not the one you run today.
Frontier clusters are heading from 100,000 toward a million GPUs, and required bisection bandwidth with them — from tens to hundreds of petabits per second. An electrical spine answers that curve with exponentially more switches, cables, and hops. A petabit-class photonic fabric answers it with capacity, not sprawl — which is what makes million-GPU scale-out physically buildable at all.
Cost & complexity vs cluster scale
Bisection bandwidth required: 10 Pb/s → 100+ Pb/s
The architecture, at altitude
Three primitives. One closed loop. A deliberately quiet middle.
PetabitSwitch stands on three independent capabilities — each defensible on its own, and far stronger together. Light is switched and steered without ever converting to electrons. Packets are held in the optical domain when timing demands it — no retiming, no buffering detour through memory. And an embedded intelligence watches the fabric's own signals to route around congestion before it exists.
Those three run as a single sub-microsecond cognitive loop: sense, predict, actuate — continuously, on every path.
How we tune light this fast, how we hold a photon without losing it, and how the engine sees a burst coming — that's the part we keep. The moat isn't any single layer. It's the combination.
Standards-aligned by design
Built to drive an unmodified open SONiC / SAI network OS · carries UALink (scale-up) and Ultra Ethernet / UEC (scale-out) · interoperates with NVLink domains.
SONiC / SAI
UALink
Ultra Ethernet / UEC
NVLink
No forklift
Your network OS, unchanged.
PetabitSwitch is built to be driven by an unmodified open SONiC / SAI control stack — the same NOS the industry already runs — so the photonic fabric drops into an existing network operationally, not as a rip-and-replace.
The control plane and the fabric are exercised end to end against a contract-accurate digital twin, so the software that will run the switch runs today.
Exercised on a contract-accurate twin
The collapse
One device where a fabric used to be.
Every 1% of utilization recovered on a 100,000-GPU cluster is ~$30M/year of GPU capital put back to work.
We don't compete with the field. We complete it.
CPO solves I/O. We solve switching. The industry needs both.
Higher-radix ASICs, co-packaged optics, optical circuit switches, photonic interconnects — each moves the ball, and each validates the same truth: the fabric is the bottleneck. None of them changes the fact that the switching itself is still electrical. That's the layer we replace.
They carry light to the switch. We keep it light through the switch.
Our point of view
Photons are becoming a commodity. Control is not.
Raw optical bandwidth is getting cheaper every year. The scarce, defensible asset is the integrated stack that turns that raw light into predictable AI training — the tuning, the timing, and the intelligence, fused into one device. Anyone can add more optics. Almost no one can govern the photons that carry the traffic in the first place.
The moat is the combination — not any single layer.
- Optics (commodity)
- Integration
- Timing
- Intelligence
- Predictable training
Built for AI infrastructure architects
Let's talk about your spine.
We work with AI infrastructure and network architects planning the next cluster generation. Bring your scaling roadmap; we'll show you where a petabit-class photonic switch changes the math.