AI and ML
From a hall of GPUs to the edge
Train, serve and run AI on hardware you own.
Training runs, inference and edge AI run as one system with one operator: accelerators, the power and cooling they depend on, the data they read and the models they produce. The open base serves verified models on any node. Praecise Furcate adds what production ML needs: goodput, checkpoints, interconnect-aware placement, queues, forecasting and energy accounting, from a single Furcate Hub to a hall of GPU servers.
01
A model at every tier(4)
Small at the sensor, large at the top, one registry for all of it.
Each tier answers what it can, and passes up only what it cannot.
Every tier runs a model server sized for it, fed from the Furcate model registry: a tiny classifier on the leaf, larger models on the gateway, perception and language models at the edge, the largest on Furcate servers and Praecise Cloud. Each does real work on its own, classifying, scoring, predicting and watching for trouble. When a tier is unsure, or sees something new, it sends a short summary of the event one step up, and the step above either answers or sends it on.
Raw data is born at the lowest tier and, by default, stays there. What travels is the result, its confidence and, where policy allows, a compact description of the event. If the step above is missing, a tier keeps working and sends later.
| Tier | Runs | Sends up |
|---|---|---|
| Furcate Leaf | tiny models: an event, a presence, an anomaly score | a label and a confidence, when unsure |
| Furcate Node | larger classifiers, forecasting, small language models | what it cannot settle, with a short event note |
| Furcate Hub | multi-camera detection, vision-language and language models | what needs the view of the whole fleet |
| Servers and Praecise Cloud | the largest models, fleet-wide analysis, training | verdicts and better models, back down |
- 01
Models only from the registry
One entry per model, with a signed variant for each tier. Nothing is sideloaded, at any tier.
- 02
Escalation by policy
Which parent a machine asks, what it may send and which models it may load are operator-signed grants.
- 03
Analysis at every level
Prediction, monitoring and anomaly detection run where the data is, not only at the top.
- 04
Useful on its own
Every tier keeps working when the one above is gone, and queues what it would have sent.
02
Learning that leaves the data behind
Updates up, models down, both signed.
The ladder improves at the sites it serves without collecting what they see.
Each tier improves its models on its own data. What goes up is the update, never the data, signed by the device's hardware key. Updates are combined at each step, tested, signed for release and sent back down through the registry as better models. Larger models teach smaller ones too: the verdicts that come down the ladder become the labels a leaf learns from.
Air-gapped
Learning ends on site. A site's combined update leaves only if the operator exports it as a signed bundle.
Connected
Updates travel up to Praecise Cloud, where more than one aggregator must agree before a combined model is signed.
Status
Every Furcate node serves models today, with a receipt on each result, and asks a larger model when it cannot answer. The ladder across Furcate Leaf, Node and Hub, and federated learning across it, are available soon with Furcate hardware.
03
Edge AI(4)
Models next to the cameras, microphones and machines.
Inference where the data is, with a receipt for every result.
Vision, audio and sensor models run on Furcate Hub, or any machine with a GPU or NPU, next to the devices they read. Every detection carries the model's hash and, where the node can attest, its boot state, and inferred values are marked as inferred rather than passed off as measured.
- 01
Video and audio
Detection, tracking, acoustic events and search on the node, with redaction before anything leaves it.
- 02
Sensors and time series
Anomaly detection and forecasting on readings with their rung attached, so a model never learns from a value it should not trust.
- 03
On the leaf
Small models for vibration, thresholds and events, signed with the model's hash.
- 04
Accelerators, detected honestly
GPUs and NPUs, each detected with its runtime; work for a missing runtime is refused, not run slowly on a CPU.
04
Training and ML operations(4)
Distributed runs on machines you own.
How much of a run made progress, who held it up, and whether the answers can be trusted.
Praecise Furcate measures what an ML fleet actually achieves rather than what it was allocated: goodput per run, what the interconnect will really carry, checkpoints with integrity-verified restore and tiered placement, fair queues and what stopping a job costs. Replica answers are compared so silent corruption shows up as a finding, not a mystery.
- 01
Goodput
The share of each run spent making progress, and what stalled the rest.
- 02
Checkpoints
Durable, tiered and verified before a restore is trusted.
- 03
Fabric-aware placement
Parallel groups placed on links measured to carry them.
- 04
Queues
Whose turn it is, how much anyone may take, and the cost of preempting.
05
Serving and infrastructure
Verified, local, answerable.
Weights checked against their source before they run.
Each node serves the models it can answer on an OpenAI-compatible endpoint and asks the fleet when it cannot. Energy is read at the supply and priced against the grid it came from; energy per token is measured, not declared; thermal headroom is reported per domain, tightest first.