Written by

Threatmatic

At

Thu Sep 17 2026

Deep Dive: ZeroProbe™ — Experience Monitoring Without a Single New Probe

The question every inline-inspection customer eventually asks — "did this slow us down?" — and why the answer was already sitting in data π collects on every request.

Back

Every customer evaluating inline HTTPS inspection eventually asks the same question, in one form or another: will this slow anything down? It's a fair question — decrypting, classifying, and re-encrypting traffic inline is real work, and "trust us, it's fine" isn't an answer a security team can act on. This piece covers ZeroProbe™, a small, deliberately narrow feature that answers it with actual numbers instead of a promise, and — more interesting than the feature itself — why it needed almost no new code to build.

Comparison of running synthetic monitoring bots forever versus reading the latency Threatmatic's π inspector already measured on real traffic

The data was already there

π classifies every HTTP(S) flow that passes through it: host, path, method, status code, an entropy score, a threat classification — and, less loudly, how long the whole round trip took. That last field, durationMs, gets computed on every single request whether or not anyone ever asked for it:

now := time.Now()
durationMs := now.Sub(data.startTime).Milliseconds()

It's been flowing end-to-end since before this feature existed — from the pi agent, over its own gRPC metrics stream to the engine, through a message queue, into a payload_inspection_events row — purely as a side effect of π doing its actual job. Pull it from a live database today and it already tells a real story. Here's what π has already measured, this week, for two apps almost every customer runs:

hostrequestsp50p95error rate
outlook.office.com66391ms20,090ms17.0%
api.github.com760218ms547ms10.8%

Look at that outlook.office.com row. The median request is fine — 91ms, nobody notices. The 95th percentile is twenty seconds. An average, or even a p50 alone, would have hidden that completely. That gap between "looks fine" and "the tail is brutal" is exactly the kind of thing a security team gets blamed for after the fact, and exactly the kind of thing they currently have no way to check before someone complains.


Why passive, not synthetic

The obvious way to answer "will this slow things down" is to build synthetic checks — deploy probes that ping each app on a schedule and watch the response times. It's the standard playbook, and it's also the wrong shape for this problem:

  • It's not real traffic. A bot hitting a login page at 3am measures a bot hitting a login page at 3am, not what an actual user experienced during business hours.
  • It's infrastructure that runs forever, on apps nobody may be actively using right now, whether or not anyone ever looks at the results.
  • It duplicates data π already has. Every field a synthetic probe would measure — latency, status code — π already computes on every real request, for free, as a byproduct of inspecting it.

So the design constraint was simple: no new probes, no new agent-side instrumentation, no new traffic sent anywhere. Just a different lens on data that's already streaming. "Test now" doesn't trigger anything — it queries the last few minutes of payload_inspection_events, fresh, the moment someone asks.


Surgical, not blanket

Turning this on for every host an org has ever talked to would just be a second version of the noisy π Inspection dashboard that already exists — more numbers, not more insight. The actual feature is narrower and more deliberate: an org picks the specific apps it wants watched, and only those apps get the rollup.

The picker itself is the detail that makes this usable rather than theoretical. The obvious version — type in the domains you want monitored — has the same problem blockedDomains/allowedDomains already have: it asks an admin to know, from memory, every hostname a modern SaaS app actually uses (Slack alone spans several). Instead, the picker is populated from hosts π has already observed for that org. Check a box next to outlook.office.com because π has already told you traffic goes there — don't type it and hope you got it right.

That's the whole mechanism: one opt-in list of hosts, one rollup query scoped to exactly those hosts, a button that re-runs it fresh. Precise because it's scoped to what someone actually chose to watch — not a blanket "monitor everything" that buries the one app that matters under twenty that don't.


Where to find it

This is live, not a proposal. Head to π Config → ZeroProbe™, check off the hosts you want watched — picked from traffic π has already seen, not typed from memory — and save. Then open π Inspection, where a new ZeroProbe™ card rolls up p50/p95 latency and error rate for exactly the hosts you opted in, with a Test now button that re-runs the query on the spot.

Nothing here required touching the agent, the engine, or the gRPC pipeline that carries this data today — the entire surface is new schema and a query in the console, because the hard part — actually collecting the numbers, in production, on every real request — was already solved before this feature was ever scoped.


Threatmatic. threatmatic.ai