Agent-payable observability — your agent runs it, pays for it, and reads from it

TL;DR. Sutrace exposes a metered, machine-payable observability surface. An agent can spin up a workspace, register the devices or services it cares about, and pay per device, per trace, or per LLM call — programmatically, with no human-in-the-loop on the billing side. Three SKUs, all priced for autonomous workflows. Discovery via /.well-known/{api-catalog,ucp,acp.json} and /platform/v2/x402/discovery/resources. Integration is a five-line SDK call.

Why this exists

The four-surfaces thesis is that hardware, software, web, and AI agents all need observability. AI agents specifically have a problem nobody else has: they spawn workloads they then need to observe, with no human there to click "subscribe." A LangGraph supervisor that decides to provision three new microservices needs a place to send the traces from those services. A multi-step researcher that crawls 200 URLs needs a way to alert when one of those routes 5xx-spikes. Today, that means a human creates a Datadog account ahead of time and shares the API key.

Sutrace removes the human. The agent discovers Sutrace via standard well-known endpoints, signs up via OAuth client credentials, picks a metered SKU, pays via x402 / ACP / Stripe, and gets a workspace token in the same conversation.

The three machine-payable SKUs

Per-device (industrial / fleet)

sutrace.observe.device

• $0.50 USD / device / day, billed daily in 24-hour increments.
• Each device gets up to 100k samples/day, all 28 protocols supported, on-host redaction default-on.
• Useful for an agent that provisions IoT devices on demand (a robotics fleet manager spinning up new sensors; a building-automation agent enrolling a new chiller).
• Settlement: x402 with USDC (testnet today, mainnet at GA), or Stripe metered subscription if your stack speaks invoices.

Per-trace (software / web / API observability)

sutrace.observe.trace

• $0.10 USD / 1,000 spans ingested, billed in 1k-span batches.
• OpenTelemetry-native ingest. No cardinality bill surprise — labels are tokenised before ingest.
• Useful for an agent that spawns short-lived microservices and only wants to pay for the spans they produce. Linear scaling, no per-host cap.

Per-call (AI agent observability)

sutrace.observe.llm_call

• $0.001 USD / observed LLM call, billed per 1k calls.
• Token, latency, cost, prompt-injection probability, on-host prompt redaction, multi-provider routing visibility.
• Useful for the recursive case — an agent that wants to observe itself. The entire EchoLeak / CamoLeak / runaway-loop class is detectable here. See /blog/echoleak-camoleak-prompt-injection-shipping-this-year and /blog/hard-budget-caps-for-ai-agents-the-architecture-options.

How an agent integrates

Five lines of TypeScript. The SDK handles discovery, payment, token rotation, and ingest:

import { Sutrace } from "@sutrace/agent";

const sut = await Sutrace.connect({
  payment: { method: "x402", asset: "usdc" },     // or { method: "stripe", customer: "cus_..." }
  budget:  { limit: 50, currency: "USD", per: "day" },
});

const workspace = await sut.workspaces.create({ sku: "observe.llm_call" });
sut.attach({ openai });   // wraps the OpenAI client; every call is observed + paid for

The budget clause is enforced server-side: if the agent's day-rate exceeds the limit, ingest pauses and the SDK returns a structured error rather than running up a surprise bill. This is the same mechanism documented in /blog/hard-budget-caps-for-ai-agents-the-architecture-options — applied to its own observability vendor, not just to OpenAI.

Discovery — what an agent fetches first

Every one of these is live today (preview status, Sutrace brand resolvable). The metering plumbing — the actual 402 → pay → token loop — lands at agent-billing GA.

Why x402 specifically

Three reasons the original team picked it over per-call API keys:

1. Refunds for the failure case. If an agent's call fails or is rate-limited, the x402 contract supports automatic refund. API-key billing makes this an off-line FinOps job; x402 makes it a same-second protocol move.
2. Per-device receipts. Each metered batch returns a signed receipt. Auditable in a way per-call telemetry isn't.
3. No shared key sprawl. Every agent identity gets its own short-lived client_credentials token. No "the agent leaked our org-wide API key" incident class.

Trust + safety

• No silent billing. Every charge is signed, returned to the agent, and logged in the customer-of-record's billing audit (the human or org that owns the OAuth client).
• Hard budget caps (server-side, not just client-side) prevent runaway loops that bankrupt the agent. Same architecture as the LLM budget-cap pattern at /blog/hard-budget-caps-for-ai-agents-the-architecture-options.
• EU residency by default (europe-west3). Pay-via-EU-bank rails for ACP customers who need it.
• DPA — every workspace, agent or human-provisioned, is processed under the same DPA at /legal/dpa.

When to pick this

• ✅ Your stack provisions infrastructure programmatically and you want observability that scales the same way.
• ✅ You're building an agent that spawns subagents and don't want to pre-provision per-subagent observability.
• ✅ You need to observe an agent's own LLM calls and want metered, predictable cost.
• ✅ You want a vendor that publishes a real x402 / ACP / UCP discovery doc, not a "contact us" page.

When the regular plan still wins

• 🟡 Steady-state load with predictable host count → flat-rate Team or Business plan is cheaper. See /pricing.
• 🟡 Compliance buyer who needs invoice + PO process → invoice billing on the Business plan, not metered.
• 🟡 You don't have an agent in the loop yet → ignore this whole page; the regular onboarding works fine.

FAQ

Is x402 GA today? The discovery surface is live; settlement plumbing is in private preview. Email hello@sutrace.io to test agent-paid observability against your real workload before GA.

Which payment methods are supported? At GA: x402 (USDC initially, multi-asset later), Stripe metered subscription, ACP. UCP for human-mediated procurement.

How does an agent identify itself? OAuth 2.0 client-credentials grant. The customer-of-record (the org that runs the agent) is on the contract; each agent gets a scoped token with budget caps.

Can the same workspace mix metered and flat? Yes. A team can run a flat-rate Business plan for its core fleet and let an autonomous subagent burst-spin metered SKUs for ephemeral devices. The agent's spend rolls up under the parent contract.

What about HIPAA / financial-services compliance? Same posture as our regular DPA. Agent-paid workspaces inherit the customer's compliance configuration; metered SKUs include the on-host redaction chain by default.

Related

• Hard budget caps for AI agents — the architecture options
• EchoLeak, CamoLeak — prompt injection in shipping enterprise AI
• Helicone vs LangSmith vs Langfuse vs Phoenix — honest comparison
• Multi-provider LLM routing observability