01
Protection without conversation retention
Security should not require a chat archive. We record connection and decision facts so you stay in control without storing prompts or completions.
Vantio · Architecture
How Optics, Gate, and Phantom Engine fit together
This page is the map: how visibility, policy on the wrap, and a host stop fit together, plus named workflows, Continuous Assurance, evidence, and where each piece actually deploys. Continuous Assurance keeps Optics, Gate, and Phantom Engine true after install: it detects drift, heals what it can, and exports evidence. It is how the suite stays healthy — not a fourth product you buy.
Where each layer sits
Observe on the agent path. Enforce on that same path. Control on the host.
Optics and Gate ride the agent path — Sight Loop, then rules that stick. Phantom Engine protects machines you own: host-level control when the app layer never records the call. Phantom Engine →
Control topology
Agent → Vantio → Destinations
Your stack
- Agent process
Frameworks, tools, MCP, scripts — whatever ships autonomy - App-layer controls
SDKs, allow-lists, prompts — useful, and skippable - Host & runtime
Where Phantom Engine catches paths the app layer never saw
Vantio planes
01 · Observe
Optics
Sight Loop
The watch. Destination, process, volume, timing, and trace — reported live. Never steers. Never blocks. Never stores the chat.
02 · Enforce
Gate
Rules that stick
Policy on the same path. When a line is crossed, Gate can block the request, redact PII, or enforce a spend limit. No mandatory proxy hop.
03 · Control
Phantom Engine
Rogue Reconciliation
Host stop on Linux you enroll. Rogue Reconciliation names the gap when the host sees traffic with no app record. Runs on your hosts — on-prem or VPC.
Destinations
- Model APIs
OpenAI, Anthropic, Google Gemini, Amazon Bedrock, Vertex AI, and the other model APIs on the wrap - Tools & systems
Payments, chat, CRMs, internal APIs, scrapers - Shadow paths
Skipped SDKs, unexpected sockets — named, then closed
No conversation warehouse. The control plane records connection and decision facts — not prompts or completions. No mandatory middlebox. Enforcement attaches where agents already run; Phantom Engine adds independent evidence when ordinary app controls miss the path.
Already on the wrap
Model APIs and runtimes we actually cover.
Optics records egress telemetry to these model APIs without keeping the conversation. Gate can block a destination, redact PII, or enforce a spend limit on the wrap. Phantom Engine is runtime enforcement on Linux you enroll.
Model APIs
- OpenAI, including regional endpoints
- Anthropic
- Google Gemini
- Google Vertex AI
- Amazon Bedrock
- Azure OpenAI
- Azure AI
- Cohere
- Mistral
- Groq
- Together AI
- Perplexity
- xAI
- DeepSeek
- Fireworks
- OpenRouter
- Cerebras
- Voyage AI
- SambaNova
- DeepInfra
- Hugging Face Inference
- Replicate
- Ollama
- NVIDIA NIM (hosted)
Agent runtimes
- Node fetch
- undici.fetch
- undici.request
- undici.stream
- Node http/https
- Node http2
- Node net/tls
- Node WebSocket
- Node-spawned curl/wget
- Python urllib (vantio run / shield())
- Python http.client (vantio run / shield())
- Python requests (vantio run / shield())
- Python httpx (vantio run / shield())
- Python aiohttp (vantio run / shield())
- Python urllib3 (vantio run / shield())
- Python sockets (vantio run / shield())
- Python-spawned curl/wget (vantio run / shield())
Hosts you own
- Linux
Named workflows
Sight Loop · Rules that stick · Rogue Reconciliation
Optics
Sight Loop
Sight Loop is how Optics works day to day: wrap the agent process, watch outbound connections, report where they went and how much moved, and show you what still sits outside that watch without stopping anything.
Optics →Gate
Rules that stick
Gate’s enforce cycle finds where agents connect, writes policy as code (destination allowlists, PII redaction, spend limits), keeps that policy in Git so CI can push it to Gate in one step, previews decisions on live traffic, then turns enforcement on so Gate only acts when a line is crossed — no one has to monitor every session.
Gate →Phantom Engine
Rogue Reconciliation
Rogue Reconciliation compares what Optics saw, what Gate decided, and what Phantom Engine saw on the host, and names the gap when the host sees traffic with no matching app-layer record.
Phantom Engine →Platform layer
Continuous Assurance
Continuous Assurance keeps Optics, Gate, and Phantom Engine true after install: it detects drift, heals what it can, checks posture, and exports evidence while production agents keep working. Depth grows with what you buy: Optics checks Sight Loop; Gate adds enforce checks and evidence; Phantom Engine adds Rogue Reconciliation and full three-layer assurance.
Design vows
Fixed rules the platform is not allowed to break.
02
No mandatory proxy hop
Rebuilding the network just to get teeth is a non-starter. Enforcement attaches where agents already run — no forced middlebox to operate or fail.
03
Gaps are named, then closed
App-layer tools can be skipped. We show where coverage ends, then close those paths under control when rogue agents are unacceptable.
04
Add authority without rip-and-replace
Start with Observe, add Enforce, then Control — same shape, more protection. Continuous Assurance deepens with each layer.
Trust boundary
What the control plane sees — and what it refuses to keep.
Recorded
- DestinationWhere the agent tried to connect
- Process contextWhat ran, under what identity
- Volume & timingHow much moved, and when
- DecisionOBSERVED, ALLOWED, BLOCKED, REDACTED, or a named host gap
- TraceEnough to match events across layers
Never retained
- PromptsUser and system instructions stay out
- CompletionsModel output is not stored in the control plane
- Tool payloads as chatWe don’t build a conversation warehouse
- Customer secrets by designRedaction is a Gate action — not a retention strategy
Why this shape
What we chose on purpose — and what we still leave open.
Common pattern
Chat-logging “governance”
Vantio
Egress telemetry + policy decisions only
You get an audit trail without turning every agent session into a liability archive. The trade: you cannot replay the prompt from Optics.
Common pattern
Mandatory outbound proxy
Vantio
Rules where the agent runs
On Node, fetch, undici, http/https, http2, net/tls, WebSocket, and spawned curl or wget share one wrap — no new hop to certificate-pin. Browser paths stay outside this wrap; Phantom Engine on Linux you enroll closes paths that never load it.
Common pattern
Hope the wrap is always on
Vantio
Independent control on enrolled hosts
When app controls miss a path, Phantom Engine still matches host evidence and names that gap. The trade: that control is customer-hosted Linux on machines you enroll.
Definitions
What each name actually means.
- Vantio Optics
- Vantio Optics is free egress monitoring: wrap an agent process, record where it connects when it calls LLM APIs through fetch, undici.fetch, undici.request, undici.stream, or Node http/https (and urllib, requests, httpx, or aiohttp via vantio run python or shield()) — destination, process, volume, timing, and trace — never store prompts or completions, and never block a request. Learn more →
- Vantio Gate
- Vantio Gate turns the policy you already wrote into live decisions on the agent path: allow, block, or redact PII — including spend limits and destination blocking that still hold when nobody is watching. Learn more →
- Vantio Phantom Engine
- Vantio Phantom Engine is runtime enforcement on Linux servers or VPC you enroll, at $799 per governed node. It can block unauthorized file access and outbound connections when a process skips ordinary app controls, and it names the gap when the host sees outbound traffic the app layer never recorded. Learn more →
- Rogue Reconciliation
- Rogue Reconciliation compares what Optics saw, what Gate decided, and what Phantom Engine saw on the host, and names the gap when the host sees traffic with no matching app-layer record. Learn more →
- Sight Loop
- Sight Loop is how Optics works day to day: wrap the agent process, watch outbound connections, report where they went and how much moved, and show you what still sits outside that watch without stopping anything. Learn more →
- Rules that stick
- Gate’s enforce cycle finds where agents connect, writes policy as code (destination allowlists, PII redaction, spend limits), keeps that policy in Git so CI can push it to Gate in one step, previews decisions on live traffic, then turns enforcement on so Gate only acts when a line is crossed — no one has to monitor every session. Learn more →
- Continuous Assurance
- Continuous Assurance keeps Optics, Gate, and Phantom Engine true after install: it detects drift, heals what it can, checks posture, and exports evidence while production agents keep working. Learn more →
Capability reference
What each layer provides
Optics free, Gate $499, Phantom Engine $799 per node.
| Capability | Optics | Gate | Phantom Engine |
|---|---|---|---|
| Live watch on agent / LLM outbound traffic | Yes — report only | Yes | Yes |
| Prompt & completion capture | Never | Never | Never |
| Action labels | OBSERVED | ALLOWED / BLOCKED / REDACTED | ALLOWED / BLOCKED + named coverage gap |
| Policy as code · preview → enforce | — | Yes | Yes (suite) |
| Enforce on the agent path | — | Block, redact PII, or enforce spend limits | Yes (on-prem Gate) |
| Runtime protection on machines you own | — | — | Yes — $799 / node |
| Rogue Reconciliation | — | Report names gaps Gate cannot see | Gap named + ledger |
| Multi-tenant cloud control plane | — | — | Not offered today |
Next step
Start with Optics — or talk through Phantom Engine.
Optics is free. Gate when a line must be enforced. Phantom Engine when the wrap never loaded and the Linux host still has to say no.