Plate I The katar, the Indian push-dagger the agent is named after
FIG. 1 — Katar, the Indian push-dagger the agent is named after. Held fist-forward; the blade extends from the punch, not the wrist.

One agent, measured.
Every path it can reach, catalogued.

Katar is a single hyper-lightweight agent that captures every signal modern security tools need and exposes it through one GraphQL surface. What follows is not a pitch — it is the specimen record: what it maps, how it replaces five collectors with one, and what it can already prove.

5+agents replaced
1GraphQL surface
eBPF+ ETW + XDP
mTLS+ Ed25519 actions
Trajectory of an external finding to the internal asset it reaches ON-PREM CLOUD (VPC PEERING) ATTACKERINTERNET EXT-FW-001 EXT-FW-002 LB-001 AT-APP01 1 PATH VPC-PEER-01 CLOUD-LB-01 CLOUD-APP-04 1 PATH
Hover or focus any node for the specimen note.
Topology, surveyed Active path, traced
Plate II

Trajectory of an external finding.

Hand Katar an external IP and it surveys the trail live — firewalls, NAT, load-balancer pools — to the exact process and identity it reaches. Surveyed the way your NOC already draws it: VLANs, physical firewalls, bare-metal racks.

  • Walk forwardExternal IP → NAT → load balancer → backend pool → process → identity → data reachable.
  • Walk backwardPick any internal asset; surface every external path that reaches it.
  • Choke pointsWhich one fix removes the most paths — surfaced in a single query.
  • Time travelThe path that existed the day of the pentest, not today's path.
Plate III

Exploded view. Five collectors, one mechanism.

EDR, FIM, vulnerability scanner, DLP, and CSAM collector — five overlapping kernel hooks, five pipelines, five failure modes, multiplied across the fleet. Katar's single hyper-lightweight agent (eBPF on Linux, ETW on Windows) captures the same signal once. This is the mechanism that makes Plate II possible: you cannot walk a path across five disconnected collectors.

EDRendpoint detection FIMfile integrity VULN SCANNERCVE + EPSS DLPdata-loss prevention CSAMasset inventory KATAR one mechanism FIG. 2 — assembly diagram, agent consolidation
5+agents replaced
0unused modules loaded
1failure mode, not five
Provenance RecordFleet, current
FLEET SURVEYED 0
linux-prod-01RHEL 9
app-server-04Ubuntu 22.04
win-dc-01Windows · ETW
k8s-prod54 pods
oracle-db-01OEL 8
edge-cache-03Debian 12
TRIAGE, BY PRIORITY
CRIToracle-db-01
CVE-2026-1188 — internet-reachable
HIGHapp-server-04
EPSS 0.71 — no compensating control
MEDk8s-prod
exposed only inside VPC
OKwin-dc-01
patched — verified 2m ago
Plate IV

Every asset finds itself. Every finding earns its priority.

Enroll one binary and Katar fingerprints the host, its packages, its listening services, its identities — no manual CMDB entry. Findings are scored by a declarative risk engine, not raw CVSS: exploit likelihood, exposure, and the blast radius from the same graph Plate II just walked. Provenance, in the catalog sense and the audit sense, are the same record here.

  • Zero-touch enrollmentOne binary fingerprints packages, services, and identities on install.
  • Risk, not just severityEPSS and environmental exposure feed a configurable scoring policy.
  • Deduplicated across feedsOS packages, language deps, and known-vuln databases reconciled into one finding.
Specimen Dataquery.graphql
{
  host(hostname: "app-server-04") {
    packages(severity: [CRITICAL, HIGH]) {
      cve
      epssScore
      exploitPriority
    }
    reachableFrom { externalIp }
  }
}
0hosts in the graph
1schema, same shape
Plate V

The catalogue grows. The entry format doesn't.

Every signal Katar collects — inventory, events, vulnerabilities, identities, reachability — lands in one GraphQL surface. Query exactly the fields you need, scoped to a key, audited per request. Ten hosts or ten thousand: the schema doesn't change shape, only the graph beneath it grows.

01
Customer creates a keyscoped to read:inventory, read:events, action
02
You query GraphQLexactly the fields you need — no overcollection
03
Every request auditeddurable consent log, per key, per scope, per query
Ed25519every action signed
±5sreplay window, then rejected
HMACchained audit log, per host
mTLSbidirectional, everywhere
Cutaway

Proto-first. Standard-defined, end to end.

The Katar protocol contract lives in kos/proto/ as the single source of truth. The Rust agent does kernel-adjacent work; the Go control plane is the integration hub. Vendors integrate against the contract, not against any one product.

Security Tools
SIEM
SOAR
VM
DLP
CSAM
EASM
Patch
Container
GraphQL · scoped keys · per-query audit
Katar Control Plane — Go
GraphQL API
Asset Registry
Attack-Path Engine
Action Signer
Push Pipeline
mTLS gRPC · bidirectional
Katar Agent — Rust
eBPF Sensor
WASM Engine
TPM Identity
XDP Enforcement
Inventory Scanner
HMAC Audit Log
kernel-resident · zero-copy
OS Kernel
Linux eBPF
Windows ETW
XDP / LSM
Container cgroups
Acquisition Record

Where we are. Where we're going.

Shipped

Foundation

Signed actions, mTLS, audit chain, conformance harness.

In progress

Asset graph

Inventory, listening services, expanded GraphQL surface.

Next

Vendor integration

Per-tool scoped keys, durable consent log.

Soon

Attack-path engine

End-to-end exposure mapping, hybrid estate.

Horizon

Hardening

Production scale, vendor conformance suite.

Colophon

This specimen is pre-release. Katar has no paying customers yet — the record above is what the agent and control plane can already do, run side by side on a laptop, not a projection. We're taking on a small number of design partners with legacy or hybrid estates who want a hand in what gets catalogued next.