“What happens when someone leaves?”
The process lived in their head, or in a prompt only they kept up to date.
The ConvOps workflow engine turns how the work should go into steps, approvals and detours that every AI agent run follows. Describe it once, in plain words, from the AI client you already use.
no canvas · no pipeline language · one step at a time
new chat
example
It stores your process as steps, gates and decisions, and hands your AI agent one step at a time, so the same work comes out the same way 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
Long prompts get copied, edited and forgotten. The steps live in someone's head, and the checkpoints are only words.
“What happens when someone leaves?”
The process lived in their head, or in a prompt only they kept up to date.
“Why did it skip the review this time?”
A checkpoint written in a prompt is only wording. A model in a hurry talks its way past it.
“Which copy of the prompt is the real one?”
Everyone keeps their own version. Each one drifts a little, and nobody notices.
Pick what your process needs. The workflow re-lays itself, then a run goes through it and stops where you said it should.
The engine holds the cursor. Your AI asks for the current step, does it, and asks to move on. Everything else stays out of its context.
Reproduce
Recall what the team knows about checkout. Reproduce the crash in Safari and note the exact steps.
Teach each workflow what it applies to. From then on, new work attaches to the right one when it is created.
Example: two bugs, two people, two AI tools, three days apart. Both runs go through the same steps.
Monday. Checkout crashes on Safari. The task is a bug, so the bug-fix workflow attaches on its own. Nobody picks it.
Claude asks for the current step and gets only that: reproduce the crash. It does the work, then asks to move on.
The review detour runs its own steps. Changes requested, so the run returns to the fix, and comes back when the work passes.
The run stops at the approval gate. Until an explicit approval is given, recorded with your account, the engine does not move the cursor.
A teammate picks up a different bug in Codex. The same workflow attaches. Same steps, same detour, same approval.
Different people, different AI tools, different days. The work went through the same steps, and every step is recorded on its task.
A checkpoint can wait for an explicit approval, a metric or a report. Place them where you want them, or run a workflow with none.
The graph view draws every step, decision and approval from start to end. Each sub-workflow opens in place, right where the work takes the detour.
Each step carries its own instructions, handed over only when the work reaches it.
one at a time
An approval, a required metric or report, finished child tasks: checked on every move. Not met, the run does not go forward.
it refuses
A decision can send the work through a whole sub-workflow. It always comes back.
loops included
Child tasks that share an order start together. The parent waits for all of them.
start together
New work is matched to the workflow that owns it, by type, tags or project.
nobody wires it
Every publish of a workflow is a version. Running work keeps the version it started with, and you can roll back at any time.
Each publish is a numbered version of the whole workflow, the sub-workflows it calls included.
whole workflow
Edit a draft while running work keeps the published version. Publish when it is ready.
publish when ready
A run stays on the version it started with. Move running work to a new version when you choose, with a preview first.
you choose when
Set an earlier version live again. Nothing is deleted.
history kept
Today every run follows the live workflow. Agents are already versioned: each step runs its agent's active revision, and teams pin the revisions they tested. How agents are versioned
IMPORTANT: always ask before releasing.
IMPORTANT: always ask before releasing.
a sentence, not a gatethe whole process, every message
checked by the engineexample
A template declares what it applies to: task type, vertical, tags or project. Matching work attaches the workflow at creation.
{
"applies_to": [{
"type": "bug",
"vertical": "development",
"default": true
}]
}Your client calls workflow_advance over MCP and receives the current step only. Edit a step once and future runs inherit it.
{
"id": "failing-test",
"name": "Failing Test",
"status": "in_progress",
"instructions": "Write the test that
reproduces the crash. Red first.
Notify me when it goes green."
}Evaluated server-side on every advance: requires_approval, wait_for_children, sequential_children, task_status, require_context, plus any required metric or report bound to the step. A miss returns unmet_conditions and the cursor stays.
{
"current_step": "approve",
"unmet_conditions": [
"Requires explicit user approval"
]
}A decision records which condition matched. A branch is an invoke into a sub-workflow; on the way back, resume_at can point backward. That is the fix loop. There is no forward goto.
{
"decision": true,
"conditions": [
{ "id": "simple",
"when": { "task_field": "complexity",
"equals": "S" } },
{ "id": "unclear",
"invoke": "deep-research" },
{ "id": "go", "when": "default" }
]
}Child tasks that share an order value start together; the rest start one after another. Each child can target its own executor, and the parent's wait_for_children gate holds until all are done. A step can also tell your AI session to start several agents at once.
{
"children": [
{ "title": "fix", "order": 1 },
{ "title": "tests", "order": 1,
"executor": "your-runner" },
{ "title": "docs", "order": 1 }
],
"parent_gate": { "wait_for_children": true }
}Templates live in the database, built from steps, reusable fragments and workspace-wide globals. Edits are surgical, dry-run validated, and runs in flight survive them.
Agents record metrics from their runs. A workflow reads them and rewrites workflows, agent instructions or model tiers, and a gate can require the metric before the next step. People set the metrics and the targets. Add an approval gate to hold a change until an explicit approval is given, recorded with the account that gave it. Example: a support team reads first-reply quality each week and tightens the triage step.
A workflow engine for AI agents holds a process as structure and hands it to the agent one step at a time. ConvOps stores each workflow as steps, gates and decisions in your workspace. Claude Code, Codex, Cursor or any MCP client asks for the current step, does it and asks to advance. Operations, finance, support and engineering teams use it so the same work runs the same way every time.
No. ConvOps is not a prompt: a prompt hands the model the whole process at once and hopes it is followed. In ConvOps the engine holds the cursor: steps arrive one at a time as the work reaches them, gates are checked server-side on every advance, and a gate that is not met returns its unmet conditions instead of moving.
Yes. A ConvOps decision step checks its conditions against real task fields and records which one matched. A branch is a detour: the condition invokes a sub-workflow, which runs to the end with its own steps and gates and then returns. The main line stays linear by design, so every run reads as one auditable line.
On the way back from an invoked sub-workflow, ConvOps can resume at an earlier step named by resume_at. That is the fix loop: a review finds problems, the run goes back to the fix step, and the cycle repeats until the work passes. A credit memo sent back by legal review follows the same loop as code sent back by a reviewer.
Yes, two ways. A step's instructions can tell your AI session to start several agents at once: ConvOps holds the step, your session does the fan-out. Or split the work into child tasks: children that share an order start together, each can target its own executor, and the parent's wait_for_children gate holds until all are done.
In the ConvOps database, scoped to your workspace: steps, reusable fragments and workspace-wide globals. You install starting points from the template catalog and edit them in conversation over MCP from your own client. A review sequence written once as a fragment can be reused by every workflow that needs it.
They keep going. ConvOps applies template edits surgically and validates each one with a full dry run before it lands. Runs already in flight continue against the updated definition, so a fix to a step reaches the next run that gets there without restarting anything.
No. ConvOps does not version workflows today: every run follows the live workflow. Agents are versioned: each save of an agent's instructions is a revision, teams pin the revisions they tested, and an earlier revision can be made active again.
Routing. ConvOps templates declare what they apply to, by task type, vertical, tags or project, and matching work attaches its workflow at creation. A shared-services team can send IT, legal and access requests to their own workflows this way, and nobody wires anything per task.
Yes, when you build it that way. In ConvOps agents record metrics from their runs, and a workflow can read them and edit workflow steps, agent instructions or model tiers. A gate can require a metric before the next step moves. People set the metrics and the targets. Add an approval gate to hold a change until an explicit approval is given, recorded with the account that gave it.