Ghost SDK is Tenet AI's integration layer for capturing AI agent decision records. It uses a fire-and-forget, background-queue architecture so that monitoring calls never block your agent's decision path. Your agent calls tenet.trace(), the decision is captured and queued in memory in under 0.1ms, and the rest of the monitoring pipeline — signing, network write — happens asynchronously in the background.

How does Ghost SDK achieve less than 5ms overhead?

The less-than-5ms figure refers specifically to the blocking portion of the SDK call — the work that happens before tenet.trace() exits. That work is: serializing the decision snapshot from in-memory data, computing a SHA-256 hash, generating an Ed25519 signature, and placing the signed record on an in-process queue. All of it is CPU-bound memory operations. The network write — which is where typical SDK latency lives — happens after the call returns, on a background thread, and adds zero time to your agent's critical path.

What happens to the decision queue if the Tenet backend goes down?

The queue accumulates in memory. Your agent continues running normally — the background queue is completely isolated from your agent's execution thread. When Tenet's backend comes back online, the queue flushes in order. If the backend is unreachable long enough that the queue reaches its configured maximum size, new records are dropped (this behavior is configurable). Your agent is never blocked, in any scenario.

Why does monitoring latency matter for AI agent decisions?

AI agents making real-time decisions — loan evaluations, claims routing, fraud detection, medical triage support — often have latency SLAs in the 200–600ms range. A synchronous monitoring call that adds 100ms to every decision can break SLAs, trigger cascading timeouts, and degrade user experience in ways that cause teams to disable monitoring entirely. An agent running without decision records is running blind to compliance risk, drift, and debugging.

Can I sample only some decisions with Ghost SDK?

You can, but with Ghost SDK there is no performance reason to do so. Sampling with synchronous SDKs is a latency optimization — you reduce monitoring calls to protect agent performance. With Ghost SDK, monitoring every decision adds less than 5ms to the critical path. Teams using Ghost SDK can capture every decision by default and treat sampling as a storage cost question, not a performance question. For compliance use cases, capturing everything is typically the correct answer.

How is Ghost SDK different from OpenTelemetry or standard observability SDKs?

OpenTelemetry and standard observability SDKs are built for infrastructure telemetry — traces, metrics, logs — and their data models reflect that. Ghost SDK is purpose-built for AI decision records: it captures reasoning chains, context snapshots, tool calls, and input/output payloads in a structure designed for the Reasoning Ledger. It also adds cryptographic signing (SHA-256 + Ed25519) on every record, making the ledger tamper-evident in a way that standard telemetry pipelines do not provide.

Ghost SDK: Why AI Agent Monitoring Shouldn't Cost You Latency

Ghost SDK is Tenet AI's fire-and-forget integration layer for AI agent decision monitoring. It uses an in-process background queue to capture full Reasoning Ledger records — context snapshot, reasoning chain, SHA-256 + Ed25519 signature — while adding less than 5ms to the agent's decision path. Your agent never waits. If the Tenet backend is unreachable, the agent runs unaffected.

The Observability Tax Problem

Standard observability SDKs use synchronous writes on the critical path, adding 50–200ms per event under normal conditions. Teams either accept the latency penalty, sample decisions (creating audit gaps), or disable monitoring entirely. Ghost SDK resolves this with a fire-and-forget architecture: the SDK call serializes the decision snapshot, queues it in memory, and returns in under 0.1ms. All I/O happens on a background thread.

What Ghost SDK Captures

Full context snapshot (agent in-memory state at decision time), reasoning chain (LLM response structure including chain-of-thought), input/output and tool calls, and SHA-256 + Ed25519 cryptographic signature. All components are CPU-bound memory operations. The cryptographic signing — which makes the Reasoning Ledger tamper-evident — takes 1–3ms on modern hardware and is the largest single component of the sub-5ms budget.

Sampling vs. Full Capture

Ghost SDK eliminates the performance reason to sample. With synchronous SDKs, sampling is a latency optimization. With Ghost SDK at sub-5ms blocking overhead, teams can capture every decision by default. Full capture is required for regulatory compliance audit trails and for reliable semantic drift detection — a 5% sample creates signal gaps that mask early drift patterns.

How Ghost SDK Handles Backend Failures

When the Tenet backend is unreachable, Ghost SDK queues events in memory up to a configurable limit (default: 10,000 events). The agent's critical path is never blocked by backend unavailability. When connectivity is restored, the queue drains automatically. If the queue limit is exceeded, oldest events are dropped with a configurable alert threshold. This design means monitoring failures never affect agent availability — the observability tail never wags the production dog.

Compliance Implications of Sub-5ms Overhead

Many regulated-industry teams avoided adding observability SDKs to production AI agents because the latency cost was unacceptable in time-sensitive workflows: prior authorization decisions, real-time fraud detection, live trading recommendations. Ghost SDK's sub-5ms overhead removes the latency barrier. These teams can now capture complete decision audit trails for compliance without acceptable performance degradation — satisfying HIPAA, EU AI Act, and SOC 2 logging requirements without sacrificing SLA.