From your users to your codebase_
From users to your codebase_
Unlock your community.
Let your software heal itself.
Every report comes back as a draft pull request, with the whole run on record.
reporte-a-issue✔ triage agent → issue #209 opened
Thinking..
issue-a-pr sandbox → install → baseline → fix → pr
> branch pushed by the engine, never by the agent
> draft PR #210 opened
> titled "sin verificación automática"
tokens counted · tools used · files touched · no verdict
Thinking..
const next = await fetch("https://api.example.com/next-section");
_
From report to pull request_
Your users describe the problem in their own words. The engine turns that into a technical issue, then into a proposed fix and a run you can audit.
Report
Issue
Fix
Draft PR
PROGRESS SECTION // 02 SUPCOFLOW
PROGRESS SECTION // 02 SUPCOFLOW
Your mail client should have opened, with what you wrote already in it — you still have to press send. If nothing opened, write to supportcodeworkflow@gmail.com. This page did not submit anything on its own.
Every run is recorded: which files the agent touched, which tools it used, how many tokens it burned, and how it ended. No verdict — the engine does not grade its own work.
const next = await fetch("https://api.example.com/next-section");
_
A report is one POST and a fix is another, both from a signed-in console. The repository is never read from the request — it comes from your project row, so untrusted input cannot choose where an issue gets written.
View Code Sample
// The console posts this. Nothing else
// can: it needs a signed-in session.
POST /api/issues
{
"title": "Checkout hangs on the last step",
"body": "I press pay and nothing happens…",
"project_id": "prj_acme_storefront"
}
// No owner and no repo: both come from
// your project row.
// can: it needs a signed-in session.
POST /api/issues
{
"title": "Checkout hangs on the last step",
"body": "I press pay and nothing happens…",
"project_id": "prj_acme_storefront"
}
// No owner and no repo: both come from
// your project row.
// A second call, on purpose: this one
// spends money, and it is refused until
// your own credential is on file.
POST /api/issue-runs
{
"issue_number": 209,
"project_id": "prj_acme_storefront"
}
// You send it after reading the issue
// the first call wrote.
// spends money, and it is refused until
// your own credential is on file.
POST /api/issue-runs
{
"issue_number": 209,
"project_id": "prj_acme_storefront"
}
// You send it after reading the issue
// the first call wrote.
<!-- Declared. Not shipped — and what
blocks it is not the widget: the microVM
still has open outbound internet. -->
<script src="…/widget.js" defer></script>
<!-- An end user has no account, so the
session model does not apply to them.
This needs a public entry of its own,
with a per-tenant ingest key and a
quota. Until then, reports come from a
signed-in console. -->
blocks it is not the widget: the microVM
still has open outbound internet. -->
<script src="…/widget.js" defer></script>
<!-- An end user has no account, so the
session model does not apply to them.
This needs a public entry of its own,
with a per-tenant ingest key and a
quota. Until then, reports come from a
signed-in console. -->
// The console posts this. Nothing else
// can: it needs a signed-in session.
POST /api/issues
{
"title": "Checkout hangs on the last step",
"body": "I press pay and nothing happens…",
"project_id": "prj_acme_storefront"
}
// No owner and no repo: both come from
// your project row.
// can: it needs a signed-in session.
POST /api/issues
{
"title": "Checkout hangs on the last step",
"body": "I press pay and nothing happens…",
"project_id": "prj_acme_storefront"
}
// No owner and no repo: both come from
// your project row.
// A second call, on purpose: this one
// spends money, and it is refused until
// your own credential is on file.
POST /api/issue-runs
{
"issue_number": 209,
"project_id": "prj_acme_storefront"
}
// You send it after reading the issue
// the first call wrote.
// spends money, and it is refused until
// your own credential is on file.
POST /api/issue-runs
{
"issue_number": 209,
"project_id": "prj_acme_storefront"
}
// You send it after reading the issue
// the first call wrote.
<!-- Declared. Not shipped — and what
blocks it is not the widget: the microVM
still has open outbound internet. -->
<script src="…/widget.js" defer></script>
<!-- An end user has no account, so the
session model does not apply to them.
This needs a public entry of its own,
with a per-tenant ingest key and a
quota. Until then, reports come from a
signed-in console. -->
blocks it is not the widget: the microVM
still has open outbound internet. -->
<script src="…/widget.js" defer></script>
<!-- An end user has no account, so the
session model does not apply to them.
This needs a public entry of its own,
with a per-tenant ingest key and a
quota. Until then, reports come from a
signed-in console. -->
const next = await fetch("https://api.example.com/next-section");
_
Support as a development engine_
Every report your users leave comes back as a technical issue. You decide which ones are worth an agent's time, and those come back as draft pull requests. Growth stops being a support burden and becomes your development engine.
Who it's for
// For the person who is also the support team //
Stop triaging. Start reviewing.
Every report arrives already triaged: an agent read it, looked around your code, and rewrote it as a technical issue. Your time goes to deciding whether a fix is right, not to turning a stranger’s complaint into something actionable.
The issue is written in your terms
Draft PRs, never direct pushes
Close the loop in one review
Draft PRs Only
Full Audit Trail
You Approve
// Turn support volume into shipped fixes //
Your support queue becomes a backlog that is already half done
Support captures what the user said. An agent turns it into a technical issue, and — when you decide it is worth the machine time — into a branch with a proposed fix. Engineering picks up a diff instead of a complaint.
One less handoff between support and eng
Every report opens a run you can audit
Runs are capped at 20 and 40 minutes
// Ship client fixes without the back-and-forth //
Take on more client products without adding headcount
Each client is its own tenant, with its own repo and its own credential. Runs stay isolated, and every pull request points at the issue that caused it.
One tenant and one repo per client
Isolated runs and credentials
Each client pays their own inference
Issue First
Fix In A Sandbox
Draft PR, You Review
// Scale it without handing over your keys //
Bring your own credential, keep your code where it is
The agent runs inside an ephemeral microVM against an allowlisted tool set, using a credential you supply. Model and CLI versions are pinned per run, and nothing survives the sandbox.
Bring your own model credential
Allowlisted tools, pinned versions
Credentials sealed per tenant
const next = await fetch("https://api.example.com/next-section");
_
Updated as the engine changes. If something here is out of date, tell us.
01
Can the agent push to my main branch?
No. Every run ends at a draft pull request on its own branch. Merging is a decision you make, and nothing reaches main without it.
02
What does the agent actually see of my repository?
A clone inside an ephemeral microVM, created for that single run and destroyed after it. The tool set is an allowlist, the model and CLI versions are pinned, and every file the agent touched is recorded.
03
What happens when the agent cannot fix it?
The run closes as no-changes: no pull request, and a record of what the agent read and tried. There is no not-reproduced outcome anywhere in the product, because there is no automatic judge — the engine reports what happened and never grades whether it was right. And when the agent never got to work at all, the run closes as failed and says so, instead of dressing that up as no-changes.
04
Can I bring my own model credential instead of paying for inference through you?
It is the only way this runs. Both product paths bill your own account, and until a credential is on file the API refuses to start a run. There is no inference to buy from us. The credential is scoped to inference only, and it never leaves the environment of the command that needs it.
05
How do I know what a fix actually cost me?
Each run records its token counts, the tools it used and the files it touched. It does not record a dollar figure: with a subscription credential there is no per-request invoice to derive one from, so that column stays empty on purpose instead of showing you a list-price guess. The dollars are on your provider bill, and the tokens here tell you which run they belong to.
const next = await fetch("https://api.example.com/next-section");
_
Ready to turn support into shipping?
Connect a repo, report the first problem from your console, and watch it come back as a draft pull request.
Every problem a user reports comes back as a technical issue, and then as a draft pull request for you to review. Leave your email and we will set up your first repo with you — today that is still done by hand.
Your mail client should have opened — you still have to press send. If nothing opened, write to supportcodeworkflow@gmail.com. This page did not submit anything on its own.
Ephemeral sandboxes, pinned model versions, and your own credential.
