---
type: use-case
title: Agent-payable observability — your agent runs it, pays for it, and reads from it
description: Let an AI agent provision a Sutrace workspace, pay for it programmatically (x402, ACP, UCP), and stream the data it produces back to itself. Three SKUs — per-device, per-trace, per-call — all metered, all machine-payable.
last_updated: 2026-04-26
audience: AI engineers / platform engineers building autonomous workflows
---

> **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

> [!NOTE]
> These prices are the design surface. The metering layer ships with the agent-billing GA milestone — see status at the bottom of the page.

### 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`](/blog/echoleak-camoleak-prompt-injection-shipping-this-year) and [`/blog/hard-budget-caps-for-ai-agents-the-architecture-options`](/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:

```ts
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`](/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

| Step | URL | What it gets |
|---|---|---|
| 1 | [`/.well-known/api-catalog`](https://sutrace.io/.well-known/api-catalog) | RFC 9727 linkset → service-doc + service-meta + status |
| 2 | [`/openapi.json`](https://sutrace.io/openapi.json) | Read surface + billing endpoints (preview) |
| 3 | [`/platform/v2/x402/discovery/resources`](https://sutrace.io/platform/v2/x402/discovery/resources) | The 3 metered SKUs with prices and HTTP 402 endpoints |
| 4 | [`/.well-known/ucp`](https://sutrace.io/.well-known/ucp) | Subscription products (Team, Business, Scale) |
| 5 | [`/.well-known/acp.json`](https://sutrace.io/.well-known/acp.json) | Agentic-commerce envelope: agent_purchase=preview |
| 6 | [`/.well-known/oauth-authorization-server`](https://sutrace.io/.well-known/oauth-authorization-server) | OAuth 2.0 with `client_credentials` grant for agent identity |
| 7 | [`/.well-known/mcp/server-card.json`](https://sutrace.io/.well-known/mcp/server-card.json) | MCP transport at `/mcp` for tool-call traces |

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`](/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`](/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`](/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](/blog/hard-budget-caps-for-ai-agents-the-architecture-options)
- [EchoLeak, CamoLeak — prompt injection in shipping enterprise AI](/blog/echoleak-camoleak-prompt-injection-shipping-this-year)
- [Helicone vs LangSmith vs Langfuse vs Phoenix — honest comparison](/blog/helicone-langsmith-langfuse-phoenix-honest-comparison)
- [Multi-provider LLM routing observability](/blog/multi-provider-llm-routing-observability-otel-semantic)