“Who approved that release?”
It shipped on a Friday night. Nobody can say if anyone checked it first.
ConvOps runs your engineering process as governed AI agent workflows. Bugs reproduce before they get fixed. Tests go red before green. A gate holds each release until it is approved. Every engineer and agent runs it the same way.
claude code · cursor · codex · gates the engine checks · nothing to install
EU cards fail at checkout
They run each change through a ConvOps workflow: least-privilege git access per environment, gates between plan, code and merge, and numbers recorded on every run.
ConvOps is the operations layer for AI agents. It holds your team's process as workflows with gates, a shared memory, scheduled and unattended runs, programs, a plan board, metrics and a full audit trail. It does not sell or host models.
key facts · october 2026
best for
not for
updated
Every engineer and every agent fixes bugs a little differently. The reasons vanish with the chat.
“Who approved that release?”
It shipped on a Friday night. Nobody can say if anyone checked it first.
“Where did that decision go?”
Why we pinned the payments library lives in a closed chat. The next fix undoes it.
“What happens when someone leaves?”
Their way of debugging leaves with them. The new hire and the agent start from zero.
A real bug, run through the Bug Fix workflow from Claude Code. Same steps, whoever picks it up.
You paste the error and ask for a fix. ConvOps files a bug and attaches the Bug Fix workflow. The work has a home before anyone touches code.
Before acting, the AI asks shared memory: past decisions on payments, where checkout lives, related bugs. It starts where the last person stopped.
askeu card checkout failure
The AI writes a test that fails the way production fails. Cannot reproduce it? The bug closes with an explanation instead of rotting.
The fix lands against the failing test. The test turns green, and the whole checkout suite runs again before anyone is asked.
The workflow stops at the approval gate and will not advance without it. You read the fix, the test and the reasoning, then approve it.
Release the EU card fix?
1 file changed · 3 tests green · reproduced first
Every step lands on the task, with the agent and the signed-in person kept apart. The lesson becomes a memory, so the next bug starts smarter.
agent: claude-code (its own label) · person: from verified sign-in
Six steps and one approval. The same for every engineer, every agent and every bug.
Typed in chat, sent from your stack, or found by another workflow.
No fix before the failure is real and captured.
Cannot reproduce? It closes with an explanation instead of rotting.
decisionRed before green. The fix ships with its proof.
A gate holds the step until the release is approved.
needs approvalLogged on the task, step by step.
Labelled examples from different kinds of software work.
A platform team runs one upgrade task per repository, all under one program. Each run works on its own branch with git access set to none, and the program turns failing after three failed runs in a row.
Program over a weekly schedule
Every bug runs Bug Fix: reproduce, a failing test, the fix, then verify. A test report bound as required in enforce mode keeps Verify open until the report is filed.
Required report binding
A bank's release runs stop at an approval gate before deploy. The approval is recorded with the account that gave it, next to the step history and the field-level changes on the task.
Approval gate and step history
A review step that finds problems sends the run back to the fix step, and the loop repeats until the review passes. There is no approval gate in this loop: the review is the bar.
Fix loop, no approval gate
After an outage review, each action becomes a child task with its own workflow. The parent incident task stays open until every child is completed or cancelled.
Child tasks
An insurer moves its policy store in four phases. Each phase starts only after the one before it lands, and each runs the verification its plan file names.
Plan with ordered phases
A custom metric counts the regression tests each bug fix adds, recorded at Verify along with who recorded it. Markers on the trend show when the Bug Fix workflow last changed.
Custom metric with change markers
A weekly schedule starts a task that drafts release notes from merged work. A gate holds the notes until the release manager approves them, and the agent posts them through the tools its environment provides.
Weekly schedule and approval gate
Kept by the team, not by whoever was on call. Recalled before the next fix starts.
Why the payments library is pinned, with the reason and the task that decided it.
why we did it
Checkout lives in api/payments/checkout. No session searches for it again.
where it lives
The fix that broke Safari last spring, so nobody ships it twice.
lessons from failures
Every memory points back to the task that produced it. The reason and the code stay together.
traceable
Some engineering work comes back on a rhythm. ConvOps gives it a schedule, an owner and numbers.
Put the recurring work on a schedule: dependency upgrades every Monday, a flaky-test sweep every weekday, release notes every Friday. Each schedule has its own time zone, and you can preview the next five runs. Group the schedules into a program with an owner and a goal, and its verdict turns late, silent or failing when the runs stop arriving.
Lay the week out on Plan. Capacity comes from four weeks of completed work across the workspace, and spread places tasks on the least-loaded days before each deadline, with a preview first.
Define the numbers each fix must report in Metrics, such as tests added per fix, and bind them as required at the Verify step, so the step holds until they are recorded. Every value carries who recorded it and at which step. ConvOps also records the cost, duration, tokens and outcome of every run by itself, and agents cannot write those.
A gate holds the step until an explicit approval is given, recorded with the account that gave it. A refused advance returns what is missing.
A workflow assignment maps task type, tags or project to a template, so a bug gets Bug Fix the moment it is filed.
A decision step records its outcome. Detours, like closing a bug that will not reproduce, run as sub-workflows that return to the main line.
Attended runs need only your AI client. For unattended work, run on ConvOps Cloud, on your own runners, or fully self-hosted.
Most teams keep these tools. ConvOps holds the process around them.
| ConvOps | A code-review bot | A raw coding agent | A CI pipeline | |
|---|---|---|---|---|
| Holds the process | Steps served one at a time | Comments on a finished change | The prompt is the process | Build and test stages only |
| Review before merge | A gate holds the step until it is approved | Suggestions; merge rules live elsewhere | Whatever the session decides | Required checks only |
| Git keys | None by default, set per environment | Read access to the change | Whatever the machine holds | Deploy keys per pipeline |
| Numbers per run | Cost, duration, tokens, turns and outcome, recorded by ConvOps | Findings per change | None kept | Build time and pass rate |
| Recurring work | Schedules grouped into programs with a verdict | Runs on each change | Started by hand | Scheduled builds |
Connect the AI tool your team already uses, install the workflows, and run one real piece of work through them.
Connect your client and install Bug Fix and Feature from the catalog
File one real bug. Watch the workflow attach itself and hand your agent step one
Sit at the approval gate: the release waits until it is approved
Edit one step instruction. The next run inherits it, and nobody reads a memo
ConvOps is the operations layer for AI agents. It holds your team's process as workflows with gates, a shared memory, scheduled and unattended runs, programs, a plan board, metrics and a full audit trail. It does not sell or host models.
In ConvOps, the engineering use case runs bug fixes, features, plans and phases as workflows your coding agents follow step by step. Bugs are reproduced before anyone fixes them, a failing test comes before the fix, and gates hold merges and releases until they are approved. Every engineer and agent runs the same process, and every run leaves a record on the task.
Not by default. In ConvOps, git access is set per environment. None, the default, gives the run no key, and the runner pushes to the task branch or a branch you choose. Full access hands over the matched key, and saving that setting warns you and names each key. Executors hold no keys of their own; provider connections hold them.
Put a gate before the merge. In ConvOps, a gate holds the step until an explicit approval is given, recorded with the account that gave it, whichever client or agent is driving the run. A refused advance returns what is missing. With git access set to none, the agent holds no key, and the runner pushes only to the task branch or the branch you chose.
ConvOps works with the coding agent you already use. Attended runs need only your AI client, such as Claude Code, Cursor, OpenAI Codex or OpenCode, which receives one step at a time. For unattended work, isolated runs use Claude Code or OpenCode on ConvOps Cloud, on your own runners, or fully self-hosted, with the same workflow and the same gates.
Both, depending on where the rule lives. In ConvOps, a rule written into a step instruction guides the agent. A rule that must hold becomes a gate or a required report: bind a test report to the Verify step as required in enforce mode, and the step will not advance until the report is filed. Observe mode never blocks and records whether each step would have met it.
Define the metrics each change must report in ConvOps, such as tests added per fix or review findings per change, and bind them at the step that matters, such as Verify. Every recorded value carries who recorded it and at which step. ConvOps also records the cost, duration, tokens and outcome of every run by itself, and agents cannot write those. Markers on the trend show each workflow change, so you can see what an edit did.
It does not have to. ConvOps is the system of record for the work your agents run: tasks in a hierarchy, the workflow each one follows, and the record of every step. Some teams move AI-driven work into it and keep their tracker for everything else. Nothing forces a migration, and you can start with a single bug.