---
title: Sutrace is now agent-payable — three SKUs your agent can buy itself
description: A LangGraph supervisor that spawns three new microservices doesn't have a human standing by to subscribe to Datadog for them. Sutrace ships discovery + x402 settlement so an agent can spin up observability and pay for it the same second.
author: Akshay Sarode
published: 2026-04-26
updated: 2026-04-26
cluster: c4-ai-agents
tags: [ai-agents, observability, x402, agentic-commerce, oauth, llm-budget]
reading: 12 min
hero: Diagram — agent discovers Sutrace via /.well-known, signs OAuth client-credentials, gets challenged with HTTP 402, settles via USDC on base-sepolia, receives signed receipt + workspace token, attaches SDK to its OpenAI client.
---

> **TL;DR.** Sutrace just shipped three machine-payable observability SKUs — per device, per 1,000 spans, per LLM call observed. An autonomous agent can discover them via `/.well-known/api-catalog`, authenticate with OAuth 2.0 client credentials, settle in USDC via x402, and start observing in five lines of TypeScript. Hard server-side budget caps prevent runaway loops. Discovery is live today; settlement plumbing is in private preview against base-sepolia. Email `hello@sutrace.io` for early access. Full design: [`/use-cases/agent-payable-observability`](/use-cases/agent-payable-observability).

## The shape of the problem

There's a class of agent that mainstream observability vendors quietly assume away: the agent that **provisions its own infrastructure**. A LangGraph supervisor that decides, mid-run, that it needs three new microservices. A robotics fleet manager that enrolls a new sensor without a maintenance ticket. A research agent that crawls 200 URLs and wants per-route latency histograms but doesn't know which 200 URLs at start-time.

Today, the answer to "where do I send the telemetry from these new services?" is: a human, ahead of time, created a Datadog account, pasted an API key into a vault, and set up service tokens. The agent operates entirely inside that envelope.

That's fine for steady-state. It's broken for autonomous workflows. It's also a procurement bottleneck — the human-in-the-loop on observability subscriptions is a [real friction point in 2026 agent ops](https://relayplane.com/blog/agent-runaway-costs-2026), even if the actual telemetry budget is small.

## What we shipped

Three SKUs, all metered, all machine-payable:

| SKU | Price | What it covers |
|---|---|---|
| `sutrace.observe.device` | **$0.50 USD / device-day** | Per-device industrial / fleet observability, all 28 protocols, on-host redaction default-on, up to 100k samples/day. |
| `sutrace.observe.trace`  | **$0.10 USD / 1,000 spans** | OpenTelemetry ingest. No cardinality bill — labels tokenised before ingest. |
| `sutrace.observe.llm_call` | **$0.001 USD / call** | Token, latency, cost, prompt-injection probability, multi-provider routing visibility. Detects [EchoLeak / CamoLeak class](/blog/echoleak-camoleak-prompt-injection-shipping-this-year). |

These sit alongside the existing Team / Business / Scale subscription tiers. 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, all under one parent contract.

## Why x402 specifically

Three reasons:

> [!NOTE]
> Diagram — comparison of API-key billing vs x402 settlement loop. API-key path: agent gets key from human → uses key forever → org-wide rate limit kicks in for everyone if one agent misbehaves. x402 path: per-batch challenge → per-batch USDC settlement → per-agent budget enforcement → signed receipt for each charge.

1. **Refunds for the failure case.** The x402 contract supports automatic refund. If a metered ingest fails server-side, the agent's wallet gets credited back inside the same conversation. Per-call API keys make refund a finance-team ticket; x402 makes it a protocol move.
2. **Signed receipts.** Every batch returns a cryptographically-signed receipt. Auditable in a way org-wide API-key billing isn't. A FinOps team running a year-end review can verify exactly which subagent spent which dollar.
3. **No shared-key sprawl.** Each agent identity gets its own OAuth client-credentials token, scoped to one or two SKUs, with a server-side budget cap. No "the agent leaked our org-wide API key" incident class — same architectural shape as [hard budget caps for agent loops](/blog/hard-budget-caps-for-ai-agents-the-architecture-options), just applied to *its own observability vendor* instead of OpenAI.

The whole reason we cared about [the Anthropic OpenClaw cutoff in April 2026](/blog/anthropic-openclaw-cutoff-april-2026-economics-decoded) was that flat-rate subscription terms for autonomous workflows are inherently fragile. We're applying the lesson to ourselves: if you're building an agent, you should be able to pay us for exactly what you used, in real time, with a refund path.

## 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**, not just in the SDK. If the agent's day-rate exceeds the limit, ingest pauses and the SDK returns a structured error. Your agent's plan got out of control? Sutrace stops billing. Same architecture as the [LLM budget-cap pattern](/blog/hard-budget-caps-for-ai-agents-the-architecture-options) — you should expect this from every machine-payable vendor in 2026, and we're holding ourselves to it.

## Discovery, in order

| Step | URL | What the agent learns |
|---|---|---|
| 1 | [`/.well-known/api-catalog`](https://sutrace.io/.well-known/api-catalog) | Sutrace exists, here's where the docs live |
| 2 | [`/openapi.json`](https://sutrace.io/openapi.json) | Read surface + the three `/api/v1/observe/*` billing endpoints |
| 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 + metered SKUs |
| 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 |

All seven are live today. The metering plumbing — the actual 402 → pay → token loop — lands at agent-billing GA.

## When a human-provisioned plan still wins

Honest carve-outs:

- 🟡 **Steady-state load with predictable host count.** Flat-rate Team or Business is cheaper than 30 device-days × $0.50 — break-even at ~$15/device/month. See [`/pricing`](/pricing).
- 🟡 **Procurement-led buying.** Many enterprise buyers need invoice + PO. Pay-via-Stripe-with-NET-30 still works on Business+; metered is for the agent-led case.
- 🟡 **You don't have an agent in the loop yet.** Just use the regular onboarding. This entire model is invisible to non-agent customers.

## The trust posture

- **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).
- **EU residency by default** (europe-west3). Pay-via-EU-bank rails for ACP customers who need it.
- **DPA** — every workspace, agent or human-provisioned, processed under [the same DPA](/legal/dpa).
- **No key leakage class.** Compromise of an agent token compromises one agent, not the org.

## Why this matters for the four-surfaces thesis

The original Sutrace thesis is that hardware, software, web, and AI agents all need observability under one pane. AI agents are the surface where the *vendor* relationship has to change too — a vendor that requires human-in-the-loop subscription is a vendor that's incompatible with autonomous workflows. We don't want to be that vendor.

Hardware, software, and web monitoring are stable categories with stable buyers. The AI-agent surface isn't — the buyers are agents themselves, and they need to pay for the observation of their own work. We're shipping the protocol surface to make that legible, today. The settlement plumbing follows.

## Get on the preview list

Email `hello@sutrace.io` with:

- The agent stack you're building (LangGraph / CrewAI / custom)
- The SKU you'd test first (`device` / `trace` / `llm_call`)
- Your day-rate budget tolerance

We'll send a private-preview client_credentials token plus the SDK. base-sepolia testnet only until GA — no real-money exposure during preview.

## Related

- [Agent-payable observability — the use-case page](/use-cases/agent-payable-observability)
- [Hard budget caps for AI agents — the architecture options](/blog/hard-budget-caps-for-ai-agents-the-architecture-options)
- [Anthropic OpenClaw cutoff April 2026 — economics decoded](/blog/anthropic-openclaw-cutoff-april-2026-economics-decoded)
- [Helicone vs LangSmith vs Langfuse vs Phoenix — honest comparison](/blog/helicone-langsmith-langfuse-phoenix-honest-comparison)
- [Multi-provider LLM routing observability with OTel semantic conventions](/blog/multi-provider-llm-routing-observability-otel-semantic)