Change production in seconds, not deploys.
Ship changes and fixes to your live app without waiting on a deploy. Bring your own source edit, or let AI draft one from a report your users filed in-page. Your team previews it on the real site and approves it, and it is live for every visitor, cryptographically signed, while a real pull request opens with the permanent change. When the PR merges, the patch retires itself.
Already have a workspace? Sign in to the dashboard
46 minutes
How long a one-line fix can take to clear a typical CI/CD pipeline¹ — Sarcio delivers an approved fix in seconds.
< 1 hour
DORA's bar for elite failed-deployment recovery; low performers take up to a week². Sarcio is the fast path to restore.
$2M / hour
Median cost of a high-impact production outage³. Every minute a known bug stays live is money.
From "it's broken" to "it's fixed" — one governed pipeline.
No war room, no emergency deploy, no SSH. One flow takes a bug from in-page report to a live, signed, reversible fix — with the permanent source fix already in flight.
Report in-page
Anyone — a QA engineer, a client, a support agent — flags the bug where it happens. Console, network, and screenshot context attach automatically.
AI drafts a scoped fix
Triage plus a minimal, constrained patch with a hard expiry — and no risk rating, because that call is your reviewer’s. The AI drafts; it never ships.
Preview in isolation
See the fix applied for you alone before anyone else does. The broken behavior keeps failing for everyone until you say otherwise.
Approve — twice, if risky
A human signs off on every patch. Elevated-risk changes require two distinct approvers before anything is signed.
Live in seconds
The signed patch pushes to every visitor over WebSocket — no redeploy. Retire it any time with one click.
The PR opens itself
A pull request with the permanent source fix opens on GitHub, GitLab, or Bitbucket, carrying a sarcio/approval check. When it merges, the patch auto-retires.
Review fixes from your AI assistant
Triage reports, check what a drafted patch changes, and see what is live from Claude or any Model Context Protocol (MCP) client. Approval stays with a signed-in person in the dashboard. Set up the Sarcio MCP server →
Every patch is a bridge to a merged pull request.
The classic objection to hotfixing is drift: quick fixes that outlive everyone's memory. Sarcio is designed so a patch cannot silently outlive its fix.
A temporary, signed, time-boxed patch
- Live for every visitor seconds after approval
- Hard TTL with client-side expiry rollback
- One-click retire reverts the site live
- Expiry reminders before anything lapses
The permanent fix, as a real PR
- Opened automatically on your Git host with the source fix
- Merge it — the patch retires itself
- PR closed or stalled? The patch is flagged as orphaned
- A Jira ticket filed, updated, and moved to Done when the fix merges, if you choose
One signed pipeline, covering your whole stack.
Visual & markup bugs
API & backend bugs
Real logic bugs
Frontend to backend, four languages deep.
One protocol, one signing scheme, verified identically everywhere — so an approved fix lands on every tier of your stack at once. See all integrations →
React
Angular
Vanilla JS
Web Workers
Vite
webpack
Node.js
Express
Fastify
Koa
Hono
PHP
Laravel
Symfony
WordPress
Java
Spring Boot
Servlet
GitHub
GitLab
Bitbucket
Jira
Kubernetes
Docker
Your own CI
Built for the teams who own the worst day.
WordPress owners and agencies
E-commerce
Platform & SRE
Small product teams
More controlled than a panic deploy.
Patching production is only scary when it's ungoverned. Sarcio is the governed version — built to hand to your security reviewer. Read the full security model →
Ed25519-signed manifests — verified in the client against your workspace's own key before anything applies
Constrained operations — hard deny-rules enforced server-side; never arbitrary code
Two-approver gate — for elevated-risk patches, with preview-before-live for every change
Self-hosted server tier — outbound-only sidecar, no inbound credentials, safe when it is down
Append-only audit log — every sign-in, approval, rotation, and retirement — exportable as CSV/JSON
RBAC, TOTP 2FA, OAuth sign-in — plus scoped API tokens over a default-deny surface
Per-tenant keys — envelope-encrypted at rest — a leaked credential is scoped to one workspace
Builds in your own CI — module patches can build in your pipeline, never on Sarcio’s build servers
The questions your reviewers will ask.
Sarcio is a governed break-glass path, not a cowboy console. Patches are constrained operations — never arbitrary code — validated server-side, previewed in isolation, approved by a human (two approvers for risky changes), signed, time-boxed with a hard expiry, reversible in one click, and recorded on an append-only audit log.
Every patch is verified in the client against your workspace's own Ed25519 signing key before anything is applied. Even a fully compromised delivery channel cannot push an unsigned payload to your users. The server tier verifies in a sidecar you host yourself, with outbound-only connections, or on WordPress inside the plugin, and fails closed either way.
Every patch ships with the pull request that makes it permanent. When the PR merges, the patch retires automatically. Patches carry hard expiries with reminder emails, live patches sit on one dashboard, and a patch whose PR was closed or stalled is flagged as orphaned — a patch cannot silently outlive its fix.
The AI only drafts. A human previews every patch in isolation and approves it before it goes live, and risky changes require two distinct approvers. DOM and server patches are constrained operations validated server-side — the AI cannot emit arbitrary code into them. Module patches are built from your repository and reviewed like any code change.
Sarcio is built for review: per-tenant signing keys, role-based access control, TOTP two-factor authentication, OAuth sign-in, admin-only integrations that act as a bot or app rather than a person, envelope encryption at rest, scoped API tokens, an exportable append-only audit trail, Jira change tickets, and module builds that can run in your own CI instead of on Sarcio’s infrastructure.
Plans differ by size, not by capability: every plan ships all three patch kinds, every connector, and every security control. What scales is how many sites and members a workspace covers (1 site and 1 seat on Solo, 5 and 10 on Team, 25 and 50 on Scale) and its monthly AI allowance: 80 AI credits on Solo, 400 on Team and 2,000 on Scale, enough for up to 40, 200 and 1,000 AI-drafted fixes. Captured reports are kept for 30 days on Solo, 90 on Team and 365 on Scale, and each report’s screenshot is stored at up to 2 MiB on Solo and Team and 5 MiB on Scale. Credits measure the model work itself, so every AI call spends them, including pull request writing and failed attempts. Exceeding either allowance never blocks a report: drafting pauses for the rest of the month and reports wait for manual triage. The one place size shows through is the two-approver rule on elevated-risk changes: two different people must approve, so shipping those needs at least two seats. The reviewer who approves first rates each patch low or elevated, and only an elevated rating calls for that second approver. WordPress sites have their own plans, priced on sites rather than seats: WordPress for one site, Freelancer for three, Agency for ten and Agency Plus for fifty.
Yes. A workspace admin cancels from Settings → Plan & billing in the dashboard; you keep access until the end of the period you've paid for. You can change plan there too: upgrades charge the prorated difference and apply once paid, downgrades apply right away with the unused time credited to your next invoice.
Stripe retries the charge and your admins are emailed, and everything keeps working. If it is still unpaid after 14 days the workspace is locked: nobody can sign in until it is paid, and admins get a link to pay without signing in. Live patches on your sites keep running while locked. After 30 days unpaid the subscription is canceled.
No. Pull requests, checks and tickets come from a workspace connection that only admins set up, ideally the Sarcio GitHub App or a bot token, so nothing depends on one person. Members can link their own GitHub, GitLab, Bitbucket or Jira account so fix PRs and tickets name or @mention them; a link stores no token. An admin can also allow acting links, which are off by default: then a member can opt in so Sarcio approves the fix PR and posts the Jira go-live comment as them. Approval itself always happens in Sarcio, and nothing done on a Git host counts toward it.
The browser widget is a small self-contained script of about 19KB gzipped that loads asynchronously and never blocks rendering. Heavier capture features like screenshots are lazy-loaded only when a report is actually filed.
The next change to production doesn't need a deploy.
Create a workspace, drop the widget on a site, and take your first change or report to a live, signed patch, with the permanent PR already open.
Create a workspace