> the autonomous AI observability platform

Make your code see how it performs in production.

ProdScopeAI builds tools that read your live telemetry and suggest concrete fixes. Get actionable code intelligence on the exact line you’re editing — plus an MCP server so your coding agent debugs with real production data, not guesses.

Get started — free See how it works

ask anything →

“What’s broken in checkout right now?” “Suggest a fix for the Safari error on line 18.” “Did yesterday’s deploy regress anything?” “Did changing UI increase clicks?” “Users say search is slow on Fridays — why?”

src/api.ts ai insight · claude

src/api.ts

15  export async function fetchProducts(category: string) {
    ↗ 1,204 calls · p50 245ms · p99 1.2s · 84% sessions
16    const cached = getFromCache(category);
17    if (cached) return cached;
18    const res = await fetch(`/api/products?cat=${category}`);
    ↳ 14 errors (Safari 17 only) — TypeError: undefined is not an object
19    return res.json();
20  }

ai insight fetchProducts · just now

root cause

Safari 17 ships Array.at() behind a flag. The cache key builder on line 16 calls category.at(-1), returning undefined — which invalidates the cache and sends every Safari user to the failing network path on line 18.

impact

14 errors in last 6h, 100% Safari/iOS. Affects 8% of your sessions. Trending up since Tuesday’s deploy (a3f9c2).

fix

Replace category.at(-1) with category.slice(-1) or ship the polyfill from PR #221. Verify with verify_fix after deploy.

↑ apply fix regenerate

> autonomous intelligence

Stop guessing. Let AI debug your live code.

Strictly on-request, with no background jobs. Every AI insight is grounded securely in your live telemetry and tied exactly to the file:line you're working on.

layer 1 · inside vs code

File-scoped code intelligence

Six tools that answer the questions a developer actually asks while editing a file. Every answer references real errors, real stacks, real users.

flagship 01

AI Insight per file

Open any file in VS Code, click “Generate insight”. Claude reads the last 24h of stats, errors, and slow queries for that file and writes a plain-English brief — what it does in production, what’s degrading, who’s affected, and what to do next.

→ fetchProducts is slow for Safari/iOS users p99 spiked from 340ms to 1.2s over the last 6 hours. 4 errors on line 18, all from Safari 17. Root cause: the new Array.at() fallback in the source map. Roll back, or add the polyfill from PR #221.

pre-edit 02

Pre-edit briefing

Before you touch a function, Claude briefs you: who calls it, how often it fails, which user segments are affected, and which lines are the danger zones.

fix 03

Suggest fix

Claude reads the real error messages and stack traces to pinpoint the actual root cause — race condition, null access, DB timeout — and returns a copy-ready fix.

verify 04

Verify fix

Compare before and after git SHAs. Claude reports whether error rates and latency actually moved, and flags regressions the diff missed.

priority 05

Developer priority queue

“What should I work on next?” Claude ranks real issues by user impact (error_rate × session_reach × call_count). No alert fatigue, no noise.

trace 06

Trace user symptom

Type “checkout feels slow on mobile” and Claude walks your telemetry backwards from the symptom to the responsible line of code.

layer 2 · whole project

Project-wide analysis engine

Five more Claude-powered reports over your entire project. Cached until you refresh, so re-reading costs zero tokens.

anomalies 07

Anomaly detection

Baselines every function against its own history. Claude flags latency spikes, error-rate jumps, traffic drops, and session-impact changes — with the actual numbers, not thresholds.

root cause 08

Root cause correlation

When multiple things break at once, Claude correlates across functions, errors, queries, and deploys to find the single upstream cause — not just a list of symptoms.

patterns 09

Behavioral patterns

Rush hours, weekday vs weekend, post-deploy regressions. Claude names the recurring behaviors in your traffic so you can plan around them.

issues 10

Proactive issue detection

Active incidents, silent failures, slow degradation, and reliability risks — ranked by how many real users they touch. Only things with concrete evidence.

digest 11

Weekly digest

A 2-minute weekly read covering health, top regressions, what improved, deploy impact, and the week’s priority fixes — ready to paste into Slack or a standup.

layer 3 · coding agents

19-tool MCP server for Claude Code & Cursor

Ship your telemetry as MCP tools so any coding agent debugs with live production data. No log diving, no hallucinations, no hand-crafted prompts.

queries

get_function_stats get_hot_paths get_live_sessions get_trace get_errors_at_line get_slow_queries

trends & comparisons

get_function_trend get_error_trends get_time_of_day_pattern get_weekday_weekend_pattern compare_periods compare_deploys

ai-powered

get_ai_insight get_analysis pre_edit_briefing suggest_fix verify_fix dev_priority_queue trace_symptom

> sample prompts to your agent

“What’s broken in production right now?” “Did last Tuesday’s deploy cause the checkout regression?” “Users say search is slow on Fridays — why?” “Write me a fix for the error on line 42 of checkout.ts.”

> the problem

Developers ship code they can’t see.

The moment your code leaves your laptop, it disappears. What runs in production is a black box — and the tools we’ve been handed weren’t built for the person writing the code.

problem

You’re debugging blind.

87% of production bugs are reported by users, not caught by developers.
The average engineer spends 13 hours/week reproducing issues they can’t see.
Every function you write runs invisibly — you don’t know which ones are slow, failing, or never called.
When something breaks, you grep logs, ping teammates, and guess.

“Works on my machine” is the industry’s $300B/year excuse.

the gap

APM was built for ops, not coders.

Datadog, New Relic, Dynatrace — $500 to $5,000/mo dashboards built for SRE teams.
Sentry shows errors but stops at the stack trace. No latency. No user reach. No fix.
Logs & traces live in a separate app, separate auth, separate mental model from the code.
Nothing connects production telemetry to the file:line a developer is actually editing.

Developers don’t need another dashboard. They need the answer, on the line, in the editor.

solution

ProdScope brings production to your cursor.

Every function annotated inline in VS Code: calls, p50/p99, error rate, % of users reached.
AI that reads your telemetry and tells you exactly which line to fix — and why.
MCP server so Claude, Cursor, and any AI coding agent debugs with real production data, not guesses.
2-minute setup. One Vite plugin, one init call. Works with React, Next.js, Express, Prisma, Cloudflare Workers.

The first observability tool that actually makes you a better coder.

> before / after

Without ProdScope

Switch to Sentry for errors
Switch to Datadog for latency
Check cloud console for costs
Grep through logs for context
Ask teammates “does this affect users?”
$500+/mo for basic APM tooling

With ProdScope

Errors on the line that caused them
Latency on every function, inline
Session reach shows user impact
AI tells you what’s wrong and why
Ask Claude Code with real production data
Free for all developers

> why now

AI writes more code than humans.

Claude Code, Cursor, and Copilot now ship production changes. They need production context — not just the file tree. ProdScope is how AI agents learn what’s really happening.

APM budgets are collapsing.

Teams are cutting Datadog contracts. Developers want one tool that lives in their editor — not a $60k/year dashboard nobody opens.

The IDE is the platform.

VS Code has 15M+ daily developers. CodeLens and MCP make it the perfect distribution surface for the next generation of developer tools.

> quick start

Up and running in 2 minutes

No agents. No config files. No dashboards.

Install the SDK

$ npm install @prodscope/sdk-browser

Add the Vite plugin

vite.config.ts

import { prodscope } from "@prodscope/sdk-browser/vite"

export default defineConfig({
  plugins: [prodscope({ apiKey: process.env.PRODSCOPE_API_KEY })],
})

Init in your app entry

main.tsx

import { init } from "@prodscope/sdk-browser"

init({
  projectId: "my-app",
  apiKey: import.meta.env.VITE_PRODSCOPE_API_KEY,
})

Done. Open VS Code and see production data on every function.

> sdk reference

Full setup

Browser apps, Node.js backends, and Claude Code integration.

> prerequisite

Get your API key

Two curls — no dashboard required. Sign up, create a project, copy the api_key into your SDK init().

1 Create an account

shell

$ curl -X POST https://api.prodscope.dev/auth/signup \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","password":"••••••","name":"You"}'

200 OK

{
  "user": {
    "id": "12fb11fe-aa42-4199-9491-5562169f63c7",
    "email": "[email protected]",
    "name": "You"
  },
  "token": "eyJhbGciOiJIUzI1NiIs…"  // 30-day JWT
}

Save the token — you’ll pass it as a Bearer header in step 2.

2 Create a project

shell

$ curl -X POST https://api.prodscope.dev/auth/projects \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"name":"my-app"}'

201 Created

{
  "id": "7a3c…",
  "name": "my-app",
  "api_key": "ps_live_xxxxxxxxxxxx",  // ← use this
  "created_at": "2026-04-11T12:00:00Z"
}

3 Drop it into the SDK

Use the api_key and id from step 2 wherever you call init() below.

any runtime

init({
  projectId: "7a3c…",
  apiKey: "ps_live_xxxxxxxxxxxx",
})

@prodscope/sdk-browser $ npm install @prodscope/sdk-browser

1 Add the Vite plugin

Instruments every exported function at build time with file:line metadata.

vite.config.ts

import { defineConfig } from "vite"
import { prodscope } from "@prodscope/sdk-browser/vite"

export default defineConfig({
  plugins: [
    prodscope({
      apiKey: process.env.PRODSCOPE_API_KEY,
    }),
  ],
})

2 Initialize in your entry point

Call init() once — before anything else renders.

main.tsx

import { init } from "@prodscope/sdk-browser"

init({
  projectId: "my-app",
  apiKey: import.meta.env.VITE_PRODSCOPE_API_KEY,
  environment: import.meta.env.MODE,    // "production" | "staging"
  release: import.meta.env.VITE_GIT_SHA, // optional
})

3 Set your API key

.env.production

VITE_PRODSCOPE_API_KEY=ps_live_xxxxxxxxxxxx

4 Drop log() calls in your code new

Structured logs with auto file:line. They stream to your editor beside errors and feed Remedy's root-cause context.

checkout.ts

import { log } from "@prodscope/sdk-browser"

async function checkout(cart) {
  log("info", "checkout started", { items: cart.length })
  try {
    await submit(cart)
  } catch (err) {
    log("warn", "checkout retry", { reason: err.message })
    throw err
  }
}

tracked automatically

function calls & latency fetch / xhr requests unhandled errors session reach per fn click interactions p50 / p99 latency user log() calls

@prodscope/sdk-node $ npm install @prodscope/sdk-node

1 Initialize at startup

Must be the first import in your entry file.

index.ts

import { init } from "@prodscope/sdk-node"

init({
  projectId: "my-api",
  apiKey: process.env.PRODSCOPE_API_KEY,
  environment: process.env.NODE_ENV,
  release: process.env.GIT_SHA, // optional
})

2 Express middleware

Tracks every route — method, path, status code, latency.

app.ts

import express from "express"
import { expressMiddleware } from "@prodscope/sdk-node/express"

const app = express()
app.use(expressMiddleware()) // before routes

3 Database middleware

Pick your adapter — or use both.

import { PrismaClient } from "@prisma/client"
import { prismaMiddleware } from "@prodscope/sdk-node/prisma"

const prisma = new PrismaClient()
prisma.$use(prismaMiddleware())

4 Drop log() calls in your code new

Structured logs with auto file:line. Visible in your editor, and feed Remedy's root-cause context for auto-fix PRs.

payment.ts

import { log } from "@prodscope/sdk-node"

export async function charge(order) {
  log("info", "charging order", { orderId: order.id, amount: order.total })
  const res = await stripe.charges.create(order)
  if (res.status !== "succeeded") {
    log("error", "charge failed", { orderId: order.id, code: res.failure_code })
  }
  return res
}

tracked automatically

express routes & status prisma queries & duration raw sql (sanitized) unhandled exceptions rejected promises slow query detection user log() calls

@prodscope/mcp-server $ npm install -g @prodscope/mcp-server

1 Add to Claude Code

Add to ~/.claude/settings.json

~/.claude/settings.json

{
  "mcpServers": {
    "prodscope": {
      "command": "prodscope-mcp",
      "env": {
        "PRODSCOPE_API_KEY": "ps_live_xxxxxxxxxxxx",
        "PRODSCOPE_PROJECT_ID": "my-app"
      }
    }
  }
}

2 Ask Claude about production

Claude queries your live telemetry — no log diving.

What functions are erroring the most right now?

Show me the slowest queries in the last hour

How did today's deploy affect checkout latency?

What's causing the error on line 42 of checkout.ts?

available tools — 19 total

get_function_statscall count, latency, error rate

get_hot_pathsmost-called functions in a window

get_live_sessionsactive sessions in real-time

get_tracefull request trace with spans

get_errors_at_lineerrors at file:line with stacks

get_slow_queriesslowest db queries

get_function_trendfunction metrics over time

get_error_trendserror rates over time

get_time_of_day_patternhourly traffic / error patterns

get_weekday_weekend_patternweekday vs weekend behavior

compare_periodsdiff any two time windows

compare_deploysdiff deploys by latency & errors

get_ai_insightclaude insight for a file

get_analysisanomalies, patterns, issues, digest

pre_edit_briefingwhat to know before editing

suggest_fixroot cause + code suggestion

verify_fixdid my deploy actually fix it?

dev_priority_queuewhat to work on next

trace_symptomsymptom → responsible code

> introducing remedy

Prodscope detects the bug.
Remedy fixes it.

When errors cross a threshold, Remedy wakes up, reads the source, runs an AI agent in a sandboxed clone of your repo, and opens a draft PR — with a Slack notification and email. Zero human triage required.

coming soon

Error threshold crossed

Remedy watches ClickHouse for error signatures that spike past your threshold — 5+ occurrences / hour by default. It deduplicates on a 24h cooldown so the same error never spawns two PRs.

Agent spins up

Claude Agent SDK launches in a sandboxed worktree of your repo. It reads the offending file:line, the full stack traces, function stats, and the existing AI insight — then diagnoses the root cause.

Minimal fix applied

The agent edits only what's broken — no refactors, no scope creep. If it can't determine a safe fix from the evidence alone, it makes no changes and explains why. Surgical or nothing.

Draft PR opened

Remedy pushes a branch, opens a draft PR with the full diagnosis, stack traces, and agent reasoning as the body. Every auto-fix stays a draft — a human merges, never Remedy.

Slack + email notification

Your team gets a Slack Block Kit message with the PR link, error count, affected sessions, and the agent's one-sentence diagnosis. Optional email notification per project. No pager noise — just context.

remedy · draft PR draft

🩹 remedy: fix TypeError in checkout.ts:42 draft

opened by remedy-bot · 1 commit · branch remedy/checkout-ts-a3f2

Diagnosis

user.address is undefined when guest checkout skips the address step. The null-guard on line 38 only checks user, not user.address.

Fix

Added optional chaining: user?.address?.city. Added a test in checkout.test.ts covering the guest path.

Impact

47 errors in the last hour across 23 sessions. Guest checkout broken for ~12% of users hitting the payments page.

📊 47 occurrences 👤 23 sessions 📁 2 files changed ⏱ fixed in 48s

Remedy is in private development. Join the waitlist to be notified when it ships.

join the waitlist

Start seeing what your code does in production.

Free for all developers. No credit card. Set up in 2 minutes.

get started — free read the docs

Unlimited projects VS Code extension 11 AI tools 19-tool MCP server Deploy comparisons