AI agent workflows for engineering: Ship with the process attached.

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

example · Claude Codeconnected
EU cards fail at checkout. Fix it the way we fix bugs.
bug filed · Bug Fix workflow attached
Reproducing first. No fix until the failure is real.
approval · waiting for you
The failing test is green now. The release needs your approval.
Approved.
released · every step logged on the task
ConvOps · task · exampleBug Fix
task

EU cards fail at checkout

step 1 of 6
bug arrives reproduce reproduced? test + fix approve approvalrelease
in short

How do engineering teams govern AI coding agents?

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

  • Git access is set per environment. None, the default, gives the run no key; full hands over the matched key, and saving it warns you and names each key.
  • Executors hold no keys. Provider connections hold them.
  • A gate holds the step until an explicit approval is given, recorded with the account that gave it.
  • A test report bound as required in enforce mode keeps the step open until it is filed. Observe mode never blocks and records whether each step would have met it.
  • ConvOps records the cost, duration, queue wait, tokens, turns and outcome of every run by itself. Agents cannot write these numbers.
  • Attended runs need only your AI client. For unattended work, run on ConvOps Cloud, on your own runners, or fully self-hosted.

best for

  • Teams running Claude Code, Cursor or Codex on real repositories
  • Platform teams that need one change process across many repositories
  • Regulated software teams that keep a record of each change

not for

  • A one-off script you will never run again
  • Teams that want an agent with merge rights and no review

updated

the problem

Fixed. But how, and by whom?

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.

watch it work

One bug, report to release.

A real bug, run through the Bug Fix workflow from Claude Code. Same steps, whoever picks it up.

01you, in Claude Code

The bug becomes a task.

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.

example
example · Claude Codeconnected to ConvOps
Checkout fails for EU cards. Error log attached.
bug filed · Bug Fix workflow attached
Step 1 of 6: reproduce. Starting there, before any fix.
02the AI

It looks before it 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.

example
example · ConvOps · recallbefore acting

askeu card checkout failure

memoryEU cards need the 3-D Secure step. Never skip it.
routeCheckout code: api/payments/checkout/
taskCard declines in Spain (done)
03the AI · reproduce

No fix before the failure is real.

The AI writes a test that fails the way production fails. Cannot reproduce it? The bug closes with an explanation instead of rotting.

example
example · terminalreproduce
  • $ pytest tests/checkout -k card
  • ✓ test_us_card_checkout
  • ✓ test_uk_card_checkout
  • ✕ test_eu_card_checkout
  • 3-D Secure redirect lost the session
reproducedFailing test captured on the task
04the AI · fix

Red, then green.

The fix lands against the failing test. The test turns green, and the whole checkout suite runs again before anyone is asked.

example
example · checkout/session.pyfix
  • - cookie.same_site = "Strict"
  • + cookie.same_site = "Lax"
  • $ pytest tests/checkout
  • ✓ 3 passed
fix readyEvery checkout test green
05you approve

The release waits for an explicit approval.

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.

example
waiting for approval

Release the EU card fix?

1 file changed · 3 tests green · reproduced first

Send backApprove release
approvedRelease step unlockedThe run continues from exactly here.
06the record

Logged. And remembered.

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.

example
example · ConvOps · task activityrecord
  • createdBug filed from Claude Code
  • step doneReproduce: failing test captured
  • step doneFix: 3 tests green
  • approvedRelease gate passed
  • completedReleased

agent: claude-code (its own label) · person: from verified sign-in

memory · lesson3-D Secure redirects drop strict cookies. Use Lax.linked to this task
example
example · Claude Codeconnected to ConvOps
Checkout fails for EU cards. Error log attached.
bug filed · Bug Fix workflow attached
Step 1 of 6: reproduce. Starting there, before any fix.
the workflow

The Bug Fix workflow, running.

Six steps and one approval. The same for every engineer, every agent and every bug.

workflow · Bug Fixrunning · step 1 of 6
  1. 01

    A bug arrives

    Typed in chat, sent from your stack, or found by another workflow.

  2. 02

    Reproduce

    No fix before the failure is real and captured.

  3. 03

    Branch on reality

    Cannot reproduce? It closes with an explanation instead of rotting.

    decision
  4. 04

    Failing test, then the fix

    Red before green. The fix ships with its proof.

  5. 05

    You approve the release

    A gate holds the step until the release is approved.

    needs approval
  6. 06

    Release

    Logged on the task, step by step.

what teams run it for

What engineering teams run on it

Labelled examples from different kinds of software work.

example · platform engineeringenterprise

Dependency upgrades across 40 repositories

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

example · product squad

Bug triage with a required test report

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

example · regulated softwareenterprise

A change record for every release

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

example · code review

Review findings loop back to the fix

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

example · incident follow-up

Post-incident actions as child tasks

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

example · data migrationenterprise

A policy database moved in ordered phases

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

example · quality engineering

Regression tests added per fix

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

example · release management

Weekly release notes, approved before posting

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

what it remembers

Every bug teaches the next.

Kept by the team, not by whoever was on call. Recalled before the next fix starts.

Decisions

Why the payments library is pinned, with the reason and the task that decided it.

why we did it

Where code lives

Checkout lives in api/payments/checkout. No session searches for it again.

where it lives

What broke before

The fix that broke Safari last spring, so nobody ships it twice.

lessons from failures

Linked to the bug

Every memory points back to the task that produced it. The reason and the code stay together.

traceable

recurring work

Run it every week

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.

schedule firesweekly, in its time zone
upgrade branchgit access: none
test reportreport required
reviewapproval
tests addedmetric required
program verdicthealthy
the difference

Ad hoc vs taught once.

  • Each engineer fixes bugs their own way
  • The agent jumps straight to a fix
  • Releases ship when someone feels ready
  • The reason for a change lives in a closed chat
  • One Bug Fix workflow for every engineer and agent
  • Reproduce first, failing test before the fix
  • The release waits at an approval gate
  • The decision is saved, linked to the task

The gate is real

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.

Routing attaches the workflow

A workflow assignment maps task type, tags or project to a template, so a bug gets Bug Fix the moment it is filed.

Detours come back

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.

Runs where you choose

Attended runs need only your AI client. For unattended work, run on ConvOps Cloud, on your own runners, or fully self-hosted.

next to what you use

ConvOps next to what you already use

Most teams keep these tools. ConvOps holds the process around them.

ConvOps next to the engineering tools teams already weigh
ConvOpsA code-review botA raw coding agentA CI pipeline
Holds the processSteps served one at a timeComments on a finished changeThe prompt is the processBuild and test stages only
Review before mergeA gate holds the step until it is approvedSuggestions; merge rules live elsewhereWhatever the session decidesRequired checks only
Git keysNone by default, set per environmentRead access to the changeWhatever the machine holdsDeploy keys per pipeline
Numbers per runCost, duration, tokens, turns and outcome, recorded by ConvOpsFindings per changeNone keptBuild time and pass rate
Recurring workSchedules grouped into programs with a verdictRuns on each changeStarted by handScheduled builds
built on

The parts doing the work.

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.

questions

What teams ask.

What is the engineering use case in ConvOps?

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.

Does a ConvOps agent hold a git key?

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.

How does ConvOps stop an agent merging work nobody reviewed?

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.

Which coding agents does ConvOps run?

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.

Can ConvOps enforce engineering rules, or only suggest them?

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.

How does ConvOps show whether agent-written changes are getting better?

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.

Does ConvOps replace our issue tracker?

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.