Cells
Home · business · city
Every place runs itself. You own all of it.
A cell is a home, a shop, a factory floor or a district, run as a complete Furcate cluster of its own: a gateway at its head, leaves at the sensors and machines, edge AI where the cameras are. It keeps its own control, keeps working when it is cut off, and answers upward only to its owner. Cells sit inside cells, so one owner can run a house, a business and a city the same way and see all of it in one place.
- Scale
- home · business · city
- Control
- local, inside every cell
- Keys
- held in hardware at every link
- Visibility
- a cell sees itself; the owner sees everything
- Status
- the first cell runs today; nesting and scoped managers available soon
01
What a cell is(4)
A cluster, not a device group.
Each cell is a whole Furcate cluster, with its own head and its own rules.
Most fleet tools group devices under a label and run them from somewhere else. A Furcate cell runs itself. Its head keeps the membership, places the work, takes the updates, caches the models it needs and enforces its own policy, so a cut link changes nothing inside it.
- 01
A full cluster
Membership, placement, workloads, updates, a cache of the model registry, a console and policy, all inside the cell.
- 02
Its own control
The gateway at the head runs the cell. Nothing outside it is in the loop for what happens inside.
- 03
Sized to the place
Cells are typed by scale (home, business, city) for the views, policies and limits that suit each.
- 04
Cells inside cells
A city cell holds district and business cells, each with its own head. Ownership rolls up; control stays local at every level.
02
The chain of control
Every link is a hardware key.
Authority is a chain of signatures, and every one is made by a key nobody can read.
At the top is the owner's passkey or a controller's TPM. The controller signs the gateway's authority to head the cell. The gateway holds its key in its own silicon and owns the leaves beneath it, and each leaf answers only to the key it was told to trust. Ownership moves by a new signed delegation, never by copying a key.
No laptop sits in the path, and nowhere in the chain is there a raw key. The tree of cells is the chain of delegations itself, so the view of who controls what cannot drift from the truth.
| Link | Holds its key in | Answers to |
|---|---|---|
| Owner | a passkey | nobody |
| Controller, in the cluster or the cloud | a TPM | the owner |
| Edge AI | a TPM | its controller |
| Gateway, at the head of the cell | its own silicon | its controller |
| Leaf, at the sensor or machine | its own silicon | its gateway |
Running today
A cell headed by a gateway whose key lives in its own silicon, controlled from a server's TPM, on the owner's private overlay. On the bench, a leaf that refuses unknown keys and replayed messages, loads models at runtime, and accepts firmware only when two release keys, each in a server TPM, have signed it. Nested cells, scoped managers and the cell console are available soon.
03
Seen from above
A cell sees itself. Only the owner sees everything.
Managing a cell never exposes the rest of the infrastructure.
A cell knows its own controller's public key and address, and nothing else about the fleet. Upward it sends summaries, never its raw state. The people who manage a cell hold a passkey delegation scoped to that cell and the cells inside it. The nodes enforce the scope themselves, so a request outside it returns nothing at the source rather than being hidden by a screen.
The same rule holds when the layer above is Praecise. A customer's cell manages its own cluster and sees its own allotment and endpoints, never Praecise's infrastructure.
Cut off
When its link goes, a cell carries on with local control, its own registry cache and its own escalation, and catches up when the link returns.
One ownership view
The owner sees every cell, core cluster and machine they own in one place, with inventory, health, power and cost, through Praecise Metal. That view reads ownership. It never reaches into a cell's control.
Status
Scoped delegations and the ownership view across nested cells are available soon.
04
Inference in every cell(4)
Small at the sensor, larger at each step up.
Leaves classify, the gateway checks, edge AI sees, the cluster decides.
Each tier in a cell runs a model server sized for it, fed from one registry with a signed variant for every tier. A tier answers what it can and sends up only what it cannot settle. Raw data is born at the lowest tier and, by default, stays there.
| Tier | Runs |
|---|---|
| Leaf | a small model next to the sensor: an event, a presence, a score |
| Gateway | larger classifiers, forecasting, small language models |
| Edge AI | multi-camera vision, vision-language and language models |
| Cluster and cloud | the largest models, fleet-wide analysis, training |
Status
A leaf runs person detection on the device today, loaded at runtime as a signed model. The gateway's model server and the rest of the ladder are available soon.
05
Open foundation, our systems on top
Anyone can build a cell. Ours are built for production.
The foundation is open. What Praecise builds on it is tuned for the places that depend on it.
Identity, the signed link, the leaf's model server, signed updates and everything else that makes a trust claim are open source, and builders run them on boards they already own. Praecise Furcate is what Praecise builds on the same foundation for production.
Open foundation
Open source at furcate.org, stewarded by Praecise. Complete enough for a home, a workshop or a lab to run its own cell, with nothing to buy and nothing to register.
Praecise Furcate
Furcate Leaf, Node and Hub hardware designed by Praecise, tuned system images, optimised model serving, fleet rollout and operations, and support.