Agent-native observability

The improvement loop for AI apps and agents

LoopKit turns production telemetry into an approval-gated loop. Agents capture telemetry, diagnose repeated product pain, and prepare the evidence and coding-agent handoff — humans hold the boundary on every external write.

Start a free sandbox See how the loop works
5,000 spans free No credit card One JSON endpoint
# 1 · mint a sandbox — no operator needed $ curl -X POST loopkit.dev/v1/signup \ -d '{"project_name":"my-app"}' → producer_key, agent_key # 2 · stream telemetry (producer key) $ curl -X POST loopkit.dev/v1/traces \ -H "authorization: Bearer $PRODUCER_KEY" \ -d '{"records":[{ "record_id": "rec_checkout_1", "signal_type": "tool_call_failed", "occurred_at": "2026-06-19T08:00:00Z", "status": "failed" }]}' # 3 · diagnose repeated product pain (agent key) $ curl -X POST loopkit.dev/v1/runs/diagnose \ -H "authorization: Bearer $AGENT_KEY" \ -d '{"since_minutes":1440}' → { ok: true, packet: { status: "ready_for_issue_diagnosis" } }
One JSON endpoint
POST records as JSON. No SDK, no agent install.
Scoped keys
Separate producer and agent scopes.
Human approval gate
No external write happens without a human call.
Cloudflare edge
Each project isolated in its own Durable Object.
How the loop works

Five stages. Every one tied to a real endpoint.

Telemetry comes in, repeated product pain gets diagnosed, and a complete handoff lands on a human's desk. LoopKit stops at the approval boundary — it never posts, merges, or ships.

01

Capture

Your app sends structured JSON records — errors, tool failures, latencies, user signals. One POST, any language.

POST /v1/traces
02

Detect

An agent reads a bounded window and clusters recurring pain into a diagnosis packet — what's failing, and how often.

POST /v1/runs/diagnose
03

Handoff

The packet carries the issue, evidence IDs, eval candidates, and a patch plan — everything a coding agent needs to act.

GET /v1/dashboard
04

Human decision

A human reviews the prepared evidence and decides what ships. External writes happen outside LoopKit for now.

05

Verify

After the change ships under your control, LoopKit reads the next telemetry window to confirm the fix held — or flags a regression.

GET /v1/telemetry
What comes back

A diagnosis packet — not an automatic fix.

Diagnose returns structured evidence with stable record IDs you can trace. A human stays in control of what ships; external writes happen outside LoopKit for now.

POST /v1/runs/diagnose · response read 
{
  "ok": true,
  "packet": {
    "packet_id": "pkt_8f21c",
    "status": "ready_for_issue_diagnosis",
    "approval_required": true,
    "issues": [
      {
        "title": "tool_call_failed on /checkout",
        "evidence": ["rec_checkout_1", "rec_checkout_7", "rec_checkout_9"],
        "eval_candidate": "checkout-timeout-v1"
      }
    ]
  }
}

Telemetry records persist to per-project SQLite. Evidence IDs in a packet point straight back to the records that triggered it — no guessing which rows the agent meant.

What you get

Built so an agent can read it — and a human can trust it.

Every surface is plain HTTP and agent-readable. Point an agent at /llms.txt and it discovers the schemas, the quickstart, and the operating loop on its own.

An agent-readable packet

Diagnosis returns structured JSON — issue, evidence, eval candidate, patch plan — that a coding agent can consume directly. No screenshots, no dashboards to scrape.

Traceable evidence IDs

Each finding cites the exact record IDs behind it. Follow any claim back to the raw telemetry in your project's store — full provenance, no hand-waving.

Humans stay in control

LoopKit prepares evidence and a coding-agent handoff, then stops. It never posts, merges, or ships — external writes happen outside LoopKit, under your control.

You stay in control

Agents prepare the work. Humans hold the boundary.

LoopKit prepares the evidence, eval candidates, and the coding-agent handoff. It never posts issues, opens PRs, merges, or ships for you — your agent does that under your control, after a human approves.

  • Scoped access keysProducer keys write OTLP spans. Agent keys read telemetry and diagnose.
  • The handoff stops hereLoopKit prepares the issue and patch plan, then hands off. No GitHub writes, no auto-apply, no production changes from LoopKit.
  • Tenant isolationEach project runs in its own Durable Object on Cloudflare. No cross-project data access, by design.

The approval boundary

AgentReads telemetry · diagnoses · drafts the handoff
PacketIssue · evidence IDs · eval candidate · patch plan
HumanReviews evidence · controls what ships
Your agent shipsExternal writes happen under your control — never LoopKit's
FAQ

Questions, answered honestly.

How is this different from Datadog, Sentry, or Grafana?
Those tools give humans dashboards to stare at. LoopKit gives agents structured, bounded access to telemetry so they can cluster recurring pain and prepare a handoff. A human reviews a short list of decisions instead of a wall of charts.
Does LoopKit open PRs or push fixes for me?
No. LoopKit prepares the evidence, eval candidates, and the coding-agent handoff, then stops. It never posts issues, opens PRs, merges, or changes production. After a human approves, your own agent or workflow performs the external write under your control.
What telemetry can I send?
OTLP JSON spans through a single endpoint, POST /v1/traces. Anything you can express as an OTLP span — tool failures, errors, latencies, user signals — works.
How do agents and humans stay separated?
Signup mints two scoped keys: a producer key (write OTLP spans) and an agent key (read and diagnose). Agents prepare work but never make external writes.
What does the free sandbox include?
A POST /v1/signup mints your three keys plus an isolated project capped at 5,000 spans for 14 days — no credit card, no operator needed. The response includes your ingest, diagnose, dashboard, and quickstart URLs so you can start immediately. Need more? Request a production tenant through /contact.json.
Can I use my own agent framework?
Yes. LoopKit is a plain HTTP API with no SDK. Any agent that can make HTTP requests can ingest OTLP spans and read packets — Claude, GPT, custom agents, MCP tools, or a shell script with curl.

Close the loop on your product.

Mint a sandbox in one request — three scoped keys and an isolated, span-capped project, ready to ingest.

Read the agent quickstart
Sandbox ready — keys are ephemeral.
Store these now — sandbox keys aren't shown again. Next: POST them to your ingest URL, then read the quickstart.