A service account reads the bucket it was provisioned to read. A researcher pulls from the repository they were granted. The agent you wired into the warehouse queries the warehouse. Nothing here trips a rule, because no rule was broken. Then the bytes leave, and the disclosure letter goes out, and every line of the audit log says the access was permitted. It was. The breach was never one move. It was the shape they made together.
"Runtime" is the word vendors reach for when they want to sound like they catch this. Most of them mean something slower. So pin it down.
You can look at a data move in one of three moments. Before it, a predictive tool classifies the data, writes a policy, and guesses whether some future action should be allowed. DLP lives here. It guesses ahead of time, it guesses wrong often, and the move that hurts you is the one it was configured to wave through. After it, the audit log tells you weeks later exactly which records left and when. Accurate. Too late. You are writing notification emails to a dataset that is already on someone else's disk.
Runtime is the third moment: during the move, while it forms. You score the move against how data actually moves in this environment, for this identity, through this job. The question is not "was this allowed." It was. The question is "does this fit." Only runtime can ask that question while there is still something on the host worth protecting.
The vantage is the kernel
Plenty of tools say they watch data. What separates them is where they stand relative to your traffic and what they have to crack open to do the job.
Hilt watches at the kernel. Low enough that the move shows up no matter which application started it, which protocol carries it, or whether it ever lands in a SaaS audit log. A transfer that goes file to process to socket through a channel nobody flagged is still a transfer. The kernel sees it. The SaaS dashboard never will.
That vantage buys two things, and both are load-bearing.
The collector stays off the path. It does not sit between your data and its destination. It does not block, drop, buffer, or rewrite a single packet. It watches. The cost of watching is roughly 0.1% of one core and 4 to 8 MB of memory per host. Nothing sits inline to add latency, fall over, or get vetoed by the team that owns uptime.
The collector reads metadata, by default. Seeing that a pattern is wrong does not require reading what is inside the move. Which identity. Which job. Source, destination, volume, hour, weighed against months of how this environment behaves when nothing is wrong. That surfaces the anomaly without anyone opening the payload. Content inspection is there if you turn it on. It is not the toll you pay to get in the door, and most days you never reach for it.
A move is meaningless until it has an owner
"Bytes left host A for endpoint B" is true and worthless. The work is resolution: tying the move back to an identity and the job behind it.
For a given move, that means naming the user or service account or agent driving it, the task it belongs to, where it is headed, and whether any of that matches what this identity usually does. The match is probabilistic and only as good as what the source can tell us. It is not a claim to read your data or to stamp every event with certainty. It is a confidence-scored account of who moved what, where, as part of which job.
Give a move an owner and a job, and deviation surfaces on its own. Access that is routine for one identity is a flare for another. Volume that is unremarkable at noon on Tuesday is a flare at 2am. No rule was written for any of this, which is exactly the point. The move that hurts you is the one no rule anticipated, because it ran on permission you handed out on purpose.
One signal is noise. A pattern is a case.
An off-hours read. A transfer a little larger than usual. A job touching a path it had not touched before. Each of these fires constantly in a live environment. Page a human on every one and they stop reading by Wednesday.
Hilt does the opposite. It watches the move across layers at once and raises something only when the signals converge: an odd job, for this identity, reading high-value paths, inside a tight window, to a destination whose volume does not add up, through a channel that was technically approved. That convergence is not an alert. It is a case, written up with the narrative of what happened and why it does not fit, so the analyst reads a finding instead of reconstructing one from ten thousand log lines.
The response stays off the path too
The collector never sits inline, so the response cannot either. When a case crosses from anomalous to acted on, Hilt applies host-level network isolation, quarantine, from the control plane. The host gets cut off at the control-plane level. The collector still never touches a packet, never filters, never enters the data path.
That is what lets latency-sensitive and infrastructure-heavy environments run this at all. You are not dropping a chokepoint into your traffic and praying it keeps up. You observe off the path and isolate from the side. The worst case for your throughput is identical to the collector not being installed.
The path never leaves your account
Done right, the events stay home. The collector runs single-tenant inside your own cloud: AWS, GCP, Azure, Ali Cloud. From a kernel-level move to a finished case, the whole path runs inside your environment. No vendor SaaS sits in the middle siphoning your most sensitive movement metadata through it. That is the line between something a regulated, residency-bound shop can actually deploy and something that only demos well.
The blind spot here belongs to everyone. Every company moving valuable data across cloud, SaaS, endpoints, and AI agents has already granted the access the bad move will use. The permission will check out. Only the behavior will be wrong. And the behavior is the part nothing else is watching while it is still happening.
If you want to see where this would sit in your own stack, the next step is a 30-minute call, engineer to engineer. No demo theater. Just how the collector deploys and what it would have seen in your environment last week.