Questions a CISO asks first.

Latten is one live graph for every AI call your company makes. As your teams adopt agents, copilots, and a dozen models across every tool you own, Latten shows two things first: what that AI costs and where your private data flows. Every call is also attributed to the actor, the model, and the exact data it touched — so you can see how far any one of them reaches. You instrument it once and watch.

It is observe-only. Latten illuminates what your AI is already doing. It does not sit in front of your traffic, and it does not change a single answer your AI returns.

You install Latten the way your engineers already ship everything else: as a reviewable pull request. Point @latten/installer at your AI app and it opens a PR that adds the @latten/sdk instrumentation — seeding the actor, then recording the boundary crossings each call makes (the LLM call, the data it touches, the external APIs it hits, the handoffs between agents). Your team reads the diff, runs CI, and merges on their own terms.

“Observe-only” describes what that code is built to do once merged. The SDK records, it does not intercept. It emits one values-free event per crossing and gets out of the way — by design it does not block a request, rewrite a prompt, or alter a result. The only thing that ever changed in your codebase is a PR your own engineers approved.

Two separate questions — measurement and overhead — and Latten keeps them separate by design.

Performance. Latten is out of the request path. The SDK sits beside each call as a fire-and-forget recorder, not in front of it as a proxy. When your agent makes a call, the SDK notes the crossing — actor, model, data domain, token counts — and hands it off asynchronously. The AI call returns on exactly the path it always did. Nothing is queued in front of your model, nothing is re-routed, and the live graph is computed in the Console from those events — never by intercepting traffic. The result is governance visibility that stays off the critical path — negligible overhead, nothing proxied.

Unscoped access. Every crossing is attributed to an actor, on whose behalf it ran, and the exact object or data domain it reached. Because of that, the graph reveals reach you can't see from logs alone. The classic exposure: many distinct end-users' requests all flow through one shared service account that can read every record in the store. On the graph that shows up as a single node whose reach is the entire dataset, while any individual caller needed a sliver — unscoped access. Everything shown is computed from real observed traffic and labeled by fidelity — measured or estimated, so you know how each number was produced. We show you what we saw, not a claim we caught everything.

LLM observability answers operational questions: is the model up? how fast did it respond? how many tokens did this span burn, and what did it cost? It's per-request telemetry, organized around traces and spans, and it exists to help you tune performance and bill-back.

Latten answers a different, governance-shaped question: who is acting, on whose behalf, what can that actor reach, and where does that reach exceed what the task needed? The unit isn't a span — it's an actor and its authority, mapped persistently across sessions. Latten models the things generic tracing doesn't represent: the on-behalf-of identity, the access and tools an agent holds, the data domains it touches, and the handoffs between agents. That's the difference between a timeline of requests and a live map of reach.

Latten meters cost too — input, output, cached, and reasoning tokens, priced per model, with cached reads at their real ~0.1× rate rather than overstated — but it frames cost as governance: spend without an owner, made visible and cuttable. Observability optimizes the request. Latten governs the actor behind it.

No raw values, ever. Each crossing is recorded as types and counts, never the content — Latten knows that an actor read N records of customer-PII type, not what any record said. PII is structural: the SDK is built so only types and counts cross the wire, and it is local-first and zero-egress for the sensitive surface. Your prompts, completions, and customer-record values never leave your environment; what reaches the Console is types, counts, and cost. The full posture — what we persist, what a breach of us would expose — is on the security page.

Today, Latten is observe-only by design — it reveals the blast radius so you can decide what to bound, and that honesty is the point: every finding on the dashboard is computed from traffic Latten actually observed and labeled for fidelity — measured or estimated, so you know how each number was produced — never asserted. Enforcement — routing bounded calls through Latten so the boundary is live — is on the roadmap, built on the same attributed-crossing model. We lead with measurement because you should see the real picture before anything changes how your AI runs.

Seeing the dashboard is free. You instrument once, watch your live blast radius and AI spend, and pay only when you act on what you find. There's no card before you get value, and the install is a PR your own engineers review and merge.