Production reports itself — your agent opens the PR
Errors, metric breaches, and user reports land as one triaged queue. A scheduled coding agent picks up each item and opens the fix as a reviewable pull request
two commands tonight — a triaged queue tomorrow morning
Eight SDKs, four coding agents
Every team ships faster now. Ops didn't keep up
The old choice was babysitting dashboards or flying blind. Shipeasy is the third path: production reports itself, every signal lands already triaged, and the fix loop runs on autopilot — you review PRs instead of chasing stack traces
Error tracking
see() turns a thrown error into a fingerprinted, deduplicated issue with the failing code path attached
Metrics & alerts
track() streams live metrics straight from your app; thresholds page you before your users do
In-app feedback
The overlay widget captures bug reports with the session, console, and repro steps attached
Agent-drafted fixes
A scheduled coding agent drains the queue as reviewable pull requests, closing issues as they merge
Know what broke, why, and what it cost
Two primitives instrument everything. No agents to install, no sampling rules to tune — the same SDK that reads your flags reports your errors and metrics
- Catch errors
see()turns a thrown error into a fingerprinted issue with the failing code path and the consequence it caused - Measure anything
track()streams a custom metric straight from your app — counts, ratios, and p95s show up as live tiles, not a warehouse job - Alert on guardrailsSet a threshold on any metric. On breach, Shipeasy pings Slack and opens an item in the queue
- In-app feedbackUsers report bugs from inside your app; every report arrives with the session, console, and repro steps attached
Every signal lands as one prioritized queue
Errors, alert breaches, and user reports converge into a single ops queue — structured items an agent can act on, not screenshots to decipher
- Fingerprint & dedupeThe same failure never files twice — occurrences fold into one issue with a live count and the first/last seen window
- Consequence & priorityEach item carries the failing code path, the consequence chain, and a priority — ready for an agent, or a human, to pick up
- Instrument from a Slack messageTell
@shipeasywhat you want to observe in plain words — it reads your repo, writes the calls, and opens a PR - Triage in one placeComments, reactions, and @mentions live on the item — priority arguments settle where the evidence is
From bug report to an open pull request, while you sleep
The queue doesn't just hold work — it drains. A scheduled agent routine picks up open items and leaves pull requests you review over coffee
- Your agent opens the PRA scheduled Claude Code routine pulls the open queue, writes the fix on its own branch, and opens a pull request that closes the issue
- Roll out behind a flagMerge it dark, ramp it on a guardrail metric, and kill it instantly if the numbers disagree
- Watch the error rate fallThe metrics that caught the problem verify the fix — every issue closes against the curve that proves it
- Wire it up from your terminalTwo commands:
npm install -g @shipeasy/clithenshipeasy setup— SDK, keys, and the overlay wired for you
error rate · charge_failed
watching the metric that filed it
Every screen here is a command your agent can run
Same operations as the dashboard, over a CLI and an MCP server
Ask in plain language — your stack instruments itself
You never name an event, a metric or a threshold — the session reads the handlers, registers the events it needs, defines the metrics on top of them, instruments all four and arms the rule that ends up filing its own ticket
A Claude Code session scanning four webhook route handlers, registering the webhook_delivery event with three typed properties, creating the webhooks.failed and webhooks.latency metrics, instrumenting every handler with track and see calls, arming an alert rule at 25 failures per hour, and finding that the rule fired overnight and filed item 944 into the ops queue
+import { see } from "@shipeasy/sdk/server"const flags = new Client(user)+const t0 = Date.now()+let status = "ok"try {await handle(evt)} catch (e) {+ status = "failed"+ see(e).causes_the("webhooks")+ .to("be retried by the provider")- return new Response(null, { status: 400 })+ return new Response(null, { status: 500 })+} finally {+ flags.track("webhook_delivery", { provider,+ status, duration_ms: Date.now() - t0 })}
webhooks.failed > 25 · 1h window
- It reads the code firstno event catalog to fill in by hand
- Events, metrics and rules are one CLIevents create · metrics create · alerts create
- And the alert files itselfa crossing lands in the queue you already work
One click hands the item to an agent — and it gets to work
Open any item in the queue, pick a coding agent, and delegate. Shipeasy opens the working run, the agent picks it up, and the fix comes back as a PR — you stay on review
One click hands it to an agent
Every row stuck on No progress carries a Delegate button. Pick a coding agent — Claude, Copilot, Cursor, or Jules — and Shipeasy opens the working run, hands over the failing path and the consequence chain, and starts streaming the run back onto the row
It asks instead of guessing
When a fix hinges on a judgment call the code can't settle, the agent stops and asks. The item moves itself into Action required with the question attached, you answer in a line, and the run picks up where it left off — the only thing that ever reaches you is the decision
Set up one trigger — every workflow opens a PR
Wire up a single agent routine once. Production errors, bug reports, feature requests, and metrics all run through it and come back as a reviewable pull request
- guard in checkout/price.ts
- see() consequence added
- regression test
Configure the trigger once — Claude Code, Copilot, Cursor, or Jules. Every kind of work runs through the same routine and comes back as a PR you review over coffee
The queue never sleeps — watch one alert close itself
This is acme-prod, the demo project that powers every scene on this page — live demo data, not a vanity metric
alert #214 on acme-prod — fired, AI ran, PR merged, cleared · demo data
- Issue created
- AI run
- PR #512 merged
- Issue closed
Armed and watching
Checkout error rate sits under the 4% threshold. Alert #214 is armed but quiet — nothing for a human to do
What the loop looks like on a real week
Wake up to PRs, not pages
An alert fires at 2am, the issue lands in the queue with the failing code path, and the scheduled agent run has a fix branch open before standup. You review it over coffee
Three dashboards become one queue
Error tracker, uptime pinger, and a feedback widget — three bills and three places to look. The same SDK call that reads your flags now reports all three into one triaged list
Ops coverage without an ops hire
A two-person product can't staff an on-call rotation. With triage automated and fixes agent-drafted, the humans only do the part that needs them — judgment on the PR
Guardrails by construction
The automation is bounded on purpose: scoped keys in, reviewable pull requests out
One hop, no middlemen
Events and errors go straight from your app to Shipeasy — nothing routes through a third-party pipeline on the way
Scoped keys
Server and client keys are separate, per-project, and rotate from the dashboard without a deploy
Your repo stays yours
A GitHub App you install on the repos you pick, revocable from GitHub — it opens pull requests, never writes to your default branch
Review stays human
Nothing merges itself. Every agent fix arrives as a pull request your team approves
Your stack, your agent — one queue
Shipeasy isn’t tied to a framework or an AI vendor. The SDK is a thin client for eight languages; the automation hands work to the coding agent you already use — Claude Code, Copilot, Cursor, or Jules. Errors, metrics, and feedback stop living in three tools with three bills — they land in one queue that something actually drains
Start free. One flat price, never per seat
Unlimited members on every plan — one bill covers errors, metrics, alerts, feedback, and the agent loop, instead of stacking three single-purpose tools
Free
Wire up error tracking in minutes — generous, not crippled
- Unlimited members — seats are never billed
- 100K events / mo (errors included)
- 10 metrics · 5 alert rules
- Ops queue — run an agent on any issue
- Comments, @mentions & tags on everything
- Unlimited scheduled Autopilot runs — results post back on Pro
- Shipeasy DevTools · CLI · MCP · full OpenAPI API
Pro
PopularFor the whole team draining the queue — one flat price
- Everything in Free, plus
- 1M events / mo, then $5 / M
- 50 metrics · 25 alert rules
- Shipeasy Reflex — errors file and fix themselves
- Agents auto-triggered on new issues, results posted back to the queue
- 30 days of history
- Advanced analytics on the queue
- $3 / mo of Jarvis AI credits · hosted MCP · email support
Business
Higher volume, unlimited metrics, and the queue in your pocket
- Everything in Pro, plus
- 10M events / mo, then $5 / M
- Unlimited metrics & alert rules
- 90 days of history — 3× Pro's window
- Mobile app — triage and resolve on the go
- 30s config propagation
- Email + Slack support
Enterprise
Committed volume, procurement, and a name on the contract
- Everything in Business, plus
- Committed volume + custom overage
- Data warehouse export
- AI triage & priority routing on the queue
- SAML/SSO, SCIM, RBAC & audit log
- Self-hosted, air-gapped deployment
- Dedicated support with response SLA
Every price published, including overages · Reflex, Jarvis credits and other terms explained
You probably want to know
What exactly do I get?+−
Error tracking, metrics with alerting, and in-app feedback — in one queue and one bill, instead of stitching together an error tracker, a metrics tool, and a feedback widget. Every signal lands as a triaged, deduplicated item your team (or your agent) can act on
Do I need an AI coding agent?+−
No. Errors, metrics, alerts, and the feedback queue work entirely on their own. The fix-loop automation — where an agent picks up an open issue and opens the fix as a pull request you review — is optional and works with Claude Code, Copilot, Cursor, or Jules
How is an error different from a log line?+−
see() produces a fingerprinted, deduplicated issue with the failing code path, the consequence it caused, and a priority — an item an agent can fix, not a stack trace to grep
What is auto-instrumentation?+−
Tell Shipeasy what you want to observe in plain words — in Slack or through your coding agent — and it reads your repo, writes the see() / track() calls in the right files, and opens a pull request. Prefer to do it by hand? Each is a single line
Which languages and frameworks?+−
The SDK ships for eight languages — TypeScript, Python, Go, Ruby, PHP, Swift, Kotlin, and Java. It's a thin client; the heavy lifting happens server-side, so any framework on those stacks works
Where does my data live?+−
Your events and errors stay in Shipeasy's own infrastructure — no third-party pipeline in between. Retention scales with your plan; a self-hosted, air-gapped deployment is available on Enterprise
Stop babysitting — start shipping
Two commands tonight. A triaged queue and a PR waiting for review tomorrow morning