Open source soon
GitHub
GitHub
Open source soon
Your community's power
makes your software better.
report-to-issue✔ triage agent → issue #209 opened
Thinking..
issue-to-pr sandbox → install → baseline → fix → mergeable
> branch pushed by the engine, never by the agent
> ✔ mergeable · draft PR #210
> titled "no automatic verification"
tokens counted · tools used · files touched · no verdict
Thinking..
const next = await fetch("https://api.example.com/next-section");
_
From chat to issue_
Your users describe the problem in their own words. An agent rewrites it as a technical issue in your repo. The fix is a second step, and it is your call.
Report
Issue
Fix
Mergeable
PROGRESS SECTION // 02 SUPCOFLOW
PROGRESS SECTION // 02 SUPCOFLOW
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.
- run
- report-to-issue
- report
- triage
- issue #209
- issue-to-pr
- sandbox
- install
- baseline
- fix
- push
- draft PR #210
Triaged, Not Guessed
An agent reads the report and writes the technical issue in your repo
Sandboxed By Default
Your repo cloned into a microVM, destroyed after the run
Evidence On Every Run
Tokens, tools used, files touched, and how the run ended
You Merge, Or You Don't
Fixes land as draft PRs. Nothing reaches main without you
Triaged, Not Guessed
An agent reads the report and writes the technical issue in your repo
Sandboxed By Default
Your repo cloned into a microVM, destroyed after the run
Evidence On Every Run
Tokens, tools used, files touched, and how the run ended
You Merge, Or You Don't
Fixes land as draft PRs. Nothing reaches main without you
const next = await fetch("https://api.example.com/next-section");
_
Drop @supcoflow/chat into your product. It asks what happened, what they expected and how to reproduce it, and it does not file until it has all three. Every report lands in your repo as a technical issue, written by an agent. The fix is a second call, and it is yours to make: that is the one that spends your key.
View Code Sample
// The one package you install. Your
// users need no account, no session.
import { IntakeChat } from "@supcoflow/chat";
<IntakeChat
tenantId="tnt_acme"
projectId="prj_acme_storefront"
backendUrl="https://chat.supcoflow.dev"
/>
// It asks what happened, what they
// expected, how to reproduce it.
// Incomplete: not filed.
// users need no account, no session.
import { IntakeChat } from "@supcoflow/chat";
<IntakeChat
tenantId="tnt_acme"
projectId="prj_acme_storefront"
backendUrl="https://chat.supcoflow.dev"
/>
// It asks what happened, what they
// expected, how to reproduce it.
// Incomplete: not filed.
// What your console posts when your
// team reports on its own. The chat
// comes in through its own backend.
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 settings.
// team reports on its own. The chat
// comes in through its own backend.
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 settings.
// 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.
// The one package you install. Your
// users need no account, no session.
import { IntakeChat } from "@supcoflow/chat";
<IntakeChat
tenantId="tnt_acme"
projectId="prj_acme_storefront"
backendUrl="https://chat.supcoflow.dev"
/>
// It asks what happened, what they
// expected, how to reproduce it.
// Incomplete: not filed.
// users need no account, no session.
import { IntakeChat } from "@supcoflow/chat";
<IntakeChat
tenantId="tnt_acme"
projectId="prj_acme_storefront"
backendUrl="https://chat.supcoflow.dev"
/>
// It asks what happened, what they
// expected, how to reproduce it.
// Incomplete: not filed.
// What your console posts when your
// team reports on its own. The chat
// comes in through its own backend.
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 settings.
// team reports on its own. The chat
// comes in through its own backend.
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 settings.
// 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.
const next = await fetch("https://api.example.com/next-section");
_
Support as a development engine_
Every report your users leave becomes a technical issue in your repo, without you rewriting it. You decide which ones are worth an agent's time, and those come back mergeable. Your support queue stops piling up and starts filling your backlog.
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 in your repo. Your time goes to deciding which fixes are worth running, and whether the one that comes back is right, not to turning a stranger’s complaint into something actionable.
The issue is written in your terms
Your own key: you pay your provider, not us
Draft PRs, never direct pushes
Issue In Your Repo
Your Own Key
You Approve
// Turn support volume into a backlog //
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 in your repo, and, when you decide it is worth the machine time, into a branch with a proposed fix. Engineering picks up an issue instead of a complaint, and a diff instead of a guess.
One less handoff between support and eng
Every report opens a run you can audit
Runs are capped at 20 and 40 minutes
Chat In, Issue Out
One Run Per Report
You Decide The Spend
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
What does this cost me?
Your provider’s bill, for the runs you choose to start. Everything runs on a model key you bring, and nothing starts until you add it: we don’t sell inference. The report and the issue it becomes do not spend your key. The fix is the call that does, and you make it one issue at a time.
02
Do my users need an account to report?
No. The chat runs inside your product with no account and no session. It asks what happened, what they expected and how to reproduce it, and it does not file until it has all three. What lands in your repo is the technical issue an agent wrote from that, not the raw transcript.
03
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.
04
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 agent only gets an approved set of tools, the model and CLI run at fixed versions, and every file it touched is recorded. Your key is encrypted for your account alone: copied anywhere else, it cannot be decrypted.
05
What happens when the agent cannot fix it?
You get no pull request, and a record of what the agent read and tried. Nothing grades the agent’s work automatically, so the run tells you what happened, not whether it was right. And if the agent never got to start, the run says it failed instead of pretending it tried.
06
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 we leave the amount blank on purpose instead of guessing from list prices. 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 stop rewriting tickets?
Connect a repo, report the first problem from your console, and watch it come back as a technical issue, then 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.
