How it works

Discover deeply. Detect risk. Prevent unsafe actions.

The engine behind Track, end to end: how it builds an evidence-backed reachability map, inspects risky actions, enforces the decision inline, drafts missing policy, and turns every outcome into a checkable receipt with a one-line config change, not an SDK.

The core engine

Discover. Detect. Prevent. Prove.

Find the complete agent-to-resource graph, inspect the risks ordinary access controls miss, stop unsafe actions before execution, and keep signed evidence of every outcome.

Every path, allowed or denied, ends the same way: a signed receipt.

Boundary
The question it answers
Track's stance
The content boundary
Can what the agent reads change what it does?
Owns it
The runtime boundary
What can the agent's machine reach on its behalf?
ComposesTrack names the obligation; your runtime enforces it.
The action boundary
Who is asking, and may this specific action run?
Owns it
The build boundary
Is the agent running the software you approved?
ComposesTrack verifies the attestation; your pipeline produces it.
The record
Can you still prove any of it, later, without us?
Alone
Owns it: Track enforces this boundary directly. Composes: Track specifies the control; your infrastructure carries it out. Alone: not a boundary. It outlives them all.

Track deliberately does not own two of these four boundaries. The record is not a boundary at all, and the four-tier framing has no answer for it.

Discover

Anchor
IdP, OAuth grants, cloud, CI, repos, endpoints, and MCP registrations.
↓
Reconcile
Compare configuration and grants with live traffic through the decision point.
↓
Map reachability
Agents, identities, tools, resources, write paths, and delegation chains.
↓
Keep watching
Flag new, changed, ungoverned, and stale surfaces with their source.
No install. Paths hashed, secret values never read.

Detect

Normalize
Turn MCP, HTTP, shell, GitHub, and custom calls into one typed action.
↓
Inspect
Check injection, traversal, SSRF, PII, secrets, destinations, and other risk signals.
↓
Decode and reinspect
Base64, hex, and URL-encoded content does not bypass the same checks.
↓
Carry the findings
Risk signals become deterministic inputs to the policy decision.
Inbound and outbound inspection on one policy surface.

Prevent

Resolve
Who's asking, under what authority, on what.
↓
Apply policy
Your rules, plus the session's context.
↓
Enforce
Allow, deny, restrict, or escalate to a person before execution.
↓
Bind it
A one-time, payload-bound token, not advice.
Runs in your environment, inline on the action path. Unsafe requests never reach the resource.

Prove

Bind
Request, decision, execution: one hashed artifact.
↓
Sign
Every mediated action: allows too, not just blocks.
↓
Verify offline
Signature, chain, timestamp: re-derived with Track off.
↓
Keep it
Yours, even if you stop being a customer.
Tamper-evident, portable. Your keys throughout.

Where policy comes from

Drafted by Track. Promoted by a person.

Deciding needs rules, and day one starts without them. Autodraft turns the discovered estate and the traffic Track has already seen into reviewable draft policy, while keeping a hard line between drafting and deploying.

No model writes a rule, and no draft deploys itself. The loop ends with an explicit decision made by a person, just like the runtime.

Drafted is not deployed.
A draft can't enforce anything. It becomes policy only when a named reviewer promotes it. The promotion is signed and attributed, like every other admin action.
Templates, not a model.
Rules are emitted from a fixed library of archetypes mined from hardened production policy. The same estate always drafts the same rules: deterministic, diffable, reviewable.
Proved on your own traffic.
Before a draft enforces, Track replays it against recorded decisions and shows which past actions it would have changed. The first day of enforcement holds no surprises.
It can't weaken what you shipped.
A draft that would shadow or soften an existing protection is dropped and flagged, never merged. A rejected draft is remembered and not re-proposed until the surface materially changes.

The estate keeps moving: Autodraft re-checks coverage as agents and tools appear, and flags rules whose surfaces have gone stale.


Getting it running

Turn it on without touching the agent.

No SDK. No code change. Just point the agent's MCP config at Track.

Same agent, same server: only the path between them changes.

Works with what you already run.
Claude Code, Copilot, Cursor, Codex, LangChain, CrewAI: any MCP client.
Your cloud. Your keys. Your rules.
Self-hosted, single-tenant. Nothing leaves your environment: ever.
Complements, doesn't replace.
Sits beside your IAM, SIEM, DLP. Governs the one thing they don't: the action.
Observe first, enforce when ready.
Read-only to start. Enforcement, one policy at a time.

Inline on the action path. Latency measured against your traffic, not a headline number.

See it decide on your own actions.

Pick one agent with real write access. We'll map it and show you the receipts.

Design a pilot