Most data security tools start from one belief: to know whether data is leaving, you have to open it. Inspect the file. Scan the payload. Match the bytes against a policy. The DLP world runs on that belief. It is also why DLP sits in the path, runs slow, and still waves through the move that costs you.
The belief is wrong. You can see data move, see where it is going, and see at what scale, without ever reading it. Those three facts catch the dangerous pattern. Reading the content turns out to buy you the least of all.
What metadata actually tells you
A move leaves a shape. Which identity started it. Which job was running. Where the bytes were headed. How much went, over what window, on what channel. None of that needs the file opened.
Your bank flags the charge that does not fit, and it never sees what you bought. It sees the amount, the merchant category, the location, the time, and how that lines up against the thousands of charges before it. The pattern is enough. The bank never reads the receipt.
Metadata-only security works the same way. Hilt watches data movement at the kernel, metadata only by default, off the path. It resolves each move to a probabilistic, source-dependent identity: which user, which job, which destination, and whether this fits what that identity normally does. The resolution comes from the shape of the move, not its contents.
Your most valuable data leaves on access you granted on purpose
This is where content inspection loses.
Your most sensitive data does not leave through a hole in the wall. It leaves through a door you opened. The researcher reads the model code because her work needs it. The service account reaches the customer table because the pipeline depends on it. The integration pushes to the external endpoint because that is the whole point of the integration.
Every one of those moves is permitted. Every tool you own waves it through, correctly, because nothing about the permission is wrong. The breach does not live in any single move. It lives in the pattern across moves: the same approved channel, fired at an odd hour, at an odd volume, by an identity whose normal day does not include this.
Content inspection cannot see that pattern. It can confirm the file held source code or a customer record. It cannot tell you this identity has never moved this much of it, this fast, to here, before. The dangerous signal sits in the metadata, not the bytes.
What reading the data costs you
Content inspection is not free. It carries costs metadata-only does not.
Start with privacy. Inspect payloads and you build a system that reads your most sensitive data to protect it, which is its own exposure and its own compliance burden. Metadata-only flips that. It sees a pattern is wrong without ever opening the content, so "what does the security tool see inside my data" gets a clean answer: by default, nothing.
Then performance. Inspecting content at volume means standing in the path of the data, buffering it, parsing it, becoming a point of failure when it stalls. Hilt stays off the path. It watches the move instead of stepping into it, on the order of 0.1% of one core and 4 to 8 MB of memory per host. It never sits inline, and it never blocks, drops, or alters traffic.
Then coverage. Content matching breaks easily. Encrypt the file, compress it, rename it, split it, encode it, and the signature is gone. Metadata holds. The move still has an origin identity, a destination, a volume, and a time, however the payload is dressed. The pattern survives what defeats the signature.
Metadata-only is the default, not the ceiling
Say this plainly so no one reads it as a limit. Metadata-only is the privacy lead. It is not the cap on what Hilt can do.
Content-aware inspection is there when you want it, for the cases where the contents themselves drive your decision. You do not have to read the data to catch exfiltration, so by default Hilt does not. The capability exists; the default is restraint. Where your environment sits on that line is your call, not the toll for entry.
What metadata catches that content scanning misses
Put the two against the move that actually hurts.
A quantitative researcher copies proprietary code over two weeks. Small chunks. Off-hours. Through an approved channel built for legitimate transfers. A content scanner sees source code crossing a permitted path and lets it through, correctly, every time. There is no policy to break.
Hilt resolves each of those moves to her identity and the job behind it, then scores it against how her data normally moves. The deviation lands across layers at once. The job is unusual for her identity. The access is a bulk read of high-value paths in a short window. The destination volume runs high despite the approved channel. One signal alone is noise. Stacked, they are a pattern, and a pattern is a case, not an alert.
None of that read a single line of the code. The metadata told the whole story.
When the content does not exist as content
A growing class of moves gives content inspection nothing to inspect. An AI agent holds database credentials, issues queries, ships results. A model reads from one store and writes to another. The valuable thing is no longer a file with a recognizable signature. It is the access pattern itself, run at machine speed through a permission you granted on purpose.
Metadata is the only vantage that holds here. The move still resolves to an identity, a job, a destination, a volume. How an agent reaches your data, and how that compares to how it reached it yesterday, is the signal you need. Metadata-only captures exactly that.
So read less, see more
The pull to read the data comes from a fair instinct. Opening it feels like the most direct way to know what left. But the direct way is also the most invasive to run, the most expensive to operate, and the easiest to dodge, and it still misses the permitted move that is the real threat.
You do not need to read your data to see it move. You need to see who moved it, where it went, and at what scale, resolved to the job behind it and scored against how it normally moves. That is metadata, and it is enough.
When the pattern forms, Hilt writes the case and responds with host-level network isolation, quarantine from the control plane, without reading deeper than it has to and without stepping into the path.
If you want to watch the resolution run on your own data movement, the fastest path is a 30-minute call, engineer to engineer. We will trace a real move from the kernel to the case, no content required.