governed scope · the power to build

The governed edge-compute node.

The power to build in your own network — bounded by exactly what you allow.

Tap your running systems, question the facts, move them within your network and beyond. A governed workspace, not a dashboard.

The unit

Three things, deployed as one.

Three things arrive together — and none of them is the hardware. A scoped builder, a private overlay that binds it to your node, and a governed door onto your systems. One unit, not three vendors to wrangle.

01 · governance

Governance

The builder: a workspace fully scoped and locked down, ready for your Claude Code. Your own intelligence, free to build anything within the grant — and nothing outside it.

02 · connectivity

Connectivity

A private, identity-based overlay binds the builder to the node — and locks everything else out. Low-overhead, and it survives flaky, distributed links; not a flat network you hope stays safe.

03 · the door

The door

On the node, a governed door onto everything behind it — the power to tap running systems and move the facts out where you need them. Scoped, time-bound, revocable, audited. Raw stays put; facts flow.

How it works

A dock for your machines.

A dock gives a vessel power, data, and controlled access to shore. A node is the same thing for a sensor, a camera, a PLC — or, one day, a humanoid. Power and link go in; governed facts come out.

power inPoE
link inoverlay · Zenoh
→

the node

edge compute at the seam

door · tap() · question()
→
outfacts, not footage
governedscoped · revocable · audited

Now → Next

Start where you are. The unit doesn’t change.

The node you deploy today on PoE is the same unit that docks an autonomous machine tomorrow — same power-plus-connectivity-plus-door. The capture device swaps; the governed memory stays constant.

now · deployable today

PoE nodes on networks I build & reach into

  • Cameras, sensors and small compute, powered over one cable
  • Reachable, segmented networks — governed, not flat
  • Facts pulled through the door: tap what happened, question it later
  • OT-grade practice (GICSP), real working lab behind it

What you get

A memory of your world only you can question.

▸ Facts, not footage

Raw stays on the node. What leaves is the answer to a question you asked — cheap to keep, compounding in value.

▸ Scoped & revocable

Access is a grant on a door — verbs, scope, expiry. Expand it by editing a grant; cut it the same way.

▸ Deployed as one unit

Power, connectivity and governance arrive together, installed like structured cabling. One thing to own.

Behind it

Built and proven, not pitched.

This is a working project, not a slide. The nodes, the overlay, the door and the question path run in my own lab today — and the roadmap is a certification path, not a funding round.

GICSP — OT security, in progress Working OT lab — nodes, overlay, door, live Integrator — devices in, facts out

Build a node

Start with the builder, not the box.

The service is governance. The hardware is only where it starts — what compounds is the facts and the network knowledge, held and managed for you through the builder.

start here · on our server

The builder

A governed workspace running your intelligence — your own Claude subscription — bounded by a grant we control. Through it you tap systems, question the facts, and manage what's known. Scoped, revocable, audited.

  • Facts — the governed memory of what your systems did; cheap to keep, compounding in value
  • Network knowledge — what's reachable, what's tappable; held and managed for you
  • Scope — widen, narrow or revoke in one line. The node can be swapped; this stays
then attach

A node

Generic hardware is the starting point, not the point. Pick a body for the job — the same builder operates all of them; only the reach and capacity change.

TierBody · reach
Basic leafPi Zero 2W / Pi 4 · 1 PoE · one sensor or camera
Standard leafPi 5 · 1 PoE · multiple sensors + light local processing
Gatewaydual-NIC, inline · taps & governs a downstream private network
High-specN100 / multi-NIC · many simultaneous taps · can host the builder on-node

Put a governed node where it matters.

Tell me what you need to see — I’ll build the node, power it, connect it, and hand you the door.

Start a build