Every hospital campus runs on three separate kingdoms that were never supposed to know about each other. Physical security owns the cameras and the badge readers. Facilities owns the chillers, the air handlers, the lighting panels. IT owns whatever's left. Each kingdom bought its own vendor, its own console, its own login, across a decade or two of procurement cycles that never once asked "will this talk to the other two?"
Nobody built it wrong. It's just what happens when three departments solve three problems on three different timelines. Twenty years later, the result is a director with three tabs open, three different alert sounds, and no single place to ask the only question that actually matters: is something happening on this campus right now that shouldn't be?
We spent the last few weeks proving that question has one answer, not three — on a real testbed, watching real traffic, not a slide.
Three kingdoms, one signal
Point a network sniffer at the traffic between a camera and its recording server, and you can tell someone walked into an empty room — not by watching the video, by watching how hard the stream is working. An empty room compresses to almost nothing; movement costs real bits, on the wire, before anyone ever unlocks a frame. It's a small, concrete case of a much bigger idea: get the true answer without ever exposing what's underneath it. Fully homomorphic encryption is the extreme version of that same instinct — computing directly on encrypted data, correct answer out, the data itself never in the clear along the way. The bitrate trick and FHE are cousins, not the same technique, but they're solving the same discomfort: security shouldn't require someone, somewhere, to be trusted with the raw thing.
Point the same kind of watching at a badge reader and a turnstile, and the story barely changes vocabulary. A door open ninety seconds with no badge event reads as an anomaly whether or not you know what a "badge event" is. Five failed reads at a narcotics vault in three minutes is the same shape of signal as five failed logins on a laptop — a rate, a threshold, a pattern that doesn't care what kind of door it happened at.
Point it at the chillers and air handlers, and it barely even feels like a different sensor. A compressor that short-cycles fourteen times in an hour, or a lighting panel that stops reporting entirely, throws exactly the kind of "this isn't what normal looks like" signal a security team already knows how to act on — except now it's coming from equipment that was never wired for security at all, because nobody ever thought it needed to be.
None of these three systems know the other two exist. From the network, in the middle, watching traffic instead of trusting whatever's plugged into it, they all reduce to the same three questions: is this normal, is this new, and does anyone need to know right now.
Signal in the noise
None of this works if it just adds a fourth dashboard to the three the director already has. The actual design philosophy underneath every piece of it — the bitrate trick, the badge-pattern matching, the chiller-cycling detector, the single reasoning layer, the instant enforcement — is the same thread pulled through every layer: find the signal, and only the signal, so nobody on a real security team has to go hunting for it themselves.
That's a harder promise than it sounds. Most "more visibility" tools solve the wrong problem — they add more telemetry, more charts, more places to look, and quietly hand the actual hard part, deciding what matters, back to a human staring at a wall of green dots waiting for one to turn red. A director who now has cameras, badges, and chillers in one place has made zero progress if that one place is still a firehose of the mundane with the one real alert buried three scrolls down.
So the philosophy has to live at every layer, not just the top one. It's why the camera detector doesn't surface "197,000 packets today" — it surfaces "motion, 117x baseline, this room, right now." It's why the badge system doesn't log every swipe as an event worth a human's attention — it surfaces exactly the one that doesn't fit the pattern. It's why a chiller cycling normally never appears anywhere, and a chiller cycling fourteen times in an hour appears exactly once, with the number attached. Every layer here is built to subtract, not add — to get quieter as it gets smarter, not louder.
That's the real bet behind "instantaneous," too: it was never just about speed. It's that an organization running this should never feel disillusioned by constantly searching a bigger haystack with a slightly better flashlight. It should feel like the haystack stopped being their problem — because the one thing worth knowing finds them, and everything else stays exactly as quiet as it should be.
The parts that make "instantly" true
That last question is the one three separate vendor consoles are worst at answering, because none of them were ever built to see the whole picture at once. A few specific choices are what turn "instantly" from aspiration into fact.
Every device on the network — a camera, a badge reader, a BMS controller, someone's laptop — is treated the same way: unproven until it proves itself, on every connection, not just the first one. That's zero trust applied literally, not as a label. Nothing gets a permanent hall pass just because it behaved yesterday.
The tunnel carrying all of it back to one place — every camera's traffic shape, every badge event, every chiller's cycling pattern — is built on cryptography designed to still hold up after machines exist that can break today's encryption. Protecting this signal fabric isn't a this-quarter problem; it's a decade problem, treated like one from day one.
And the model doing the actual "is this normal" judgment isn't three separate models trained by three separate vendors on three separate slices of the world. It's one statistical reasoning layer, looking at rate, shape, and timing the same way no matter what kind of device produced the traffic — which is exactly why a chiller anomaly and a tailgating alert can land on the same screen as the same kind of thing, instead of needing three specialists fluent in three different dialects.
Put those together — trust nothing by default, protect the signal for decades not quarters, reason about anomalies the same way regardless of source — and the response to something crossing the line doesn't wait for a ticket, a shift change, or a human noticing the twelfth red dot in a bank of twelve monitors. It happens at the network, in the same motion that noticed it.
What "simple" actually means here
The simplicity was never about having fewer dashboards for their own sake. A campus doesn't actually have three security problems — it has one: visibility into things that were never built to be watched. Solve that one problem instead of three, and the guard's job stops being "remember which console shows which alert" and goes back to what it was always supposed to be: notice, and respond.
That's the whole bet. Not a smarter camera. Not a better badge reader. One patient, always-on layer that already knows what quiet sounds like for every kind of device on the campus — and says something the instant it doesn't.