“Which rule applied?”
The instruction file says everything. The agent followed some of it. Nobody can say which rule shaped this change.
Graph engineering is how you design work in ConvOps: a graph of small workflows behind one door, which your agent walks one step at a time. The knowledge grows. The prompt does not.
one router · detours · fix loops · fragments · child tasks
One door
Designing the process as a graph of small workflows behind one router, which your agent walks one step at a time, instead of one giant prompt.
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 lesson becomes another paragraph in CLAUDE.md or AGENTS.md. The file grows, the agent reads less of it, and the process lives in prose.
“Which rule applied?”
The instruction file says everything. The agent followed some of it. Nobody can say which rule shaped this change.
“Why does it keep growing?”
Every incident adds a paragraph. The file gets longer, the agent skims more, and the next incident adds another.
“Where is the process?”
In prose. Steps, checks and exceptions mixed into one page that nobody can run, test or review.
The instruction file keeps who the agent is and one rule: follow the workflow. The process moves into workflows. The rules move into standards, read at the step that needs them.
customer-report · step "Draft" reads reports.md
Mark one workflow as the workspace router. New work starts on it. The agent triages, picks one of the exits and records why.
Workspace router
recorded waiting for the route decision
An exit can invoke a sub-workflow on the same task. The parent waits, then carries on. An exit without one just records the choice.
A failed review invokes a fix and returns to Verify. A rejection at an approval gate sends the run back to the step the workflow names.
The loop ends when the work passes. Every turn is saved, so any session picks the run up where it stopped.
Shared blocks like finding the standards, build and verify, and review live in fragments. Edit one, and every workflow that embeds it changes.
do-and-verify
Added to every workflow automatically. Nobody copies them in.
A parent splits into child tasks, each with its own workflow. Children that share an order start together. The next order starts on its own. The parent waits for all.
Open a Lisbon office
Each step names the agent your orchestrator should use, and can name where it runs. It finds the standards for the files in scope. The agent gets one step.
Ask your AI client for the change. It edits the one step that needs it. No canvas, no code. Runs already in flight keep going.
Ask for the change you want.
needs fixes invokes fix and returns to Verify, passed carries on.One door per workspace. New work starts there and leaves by one exit.
is_router
Picks an exit and records why. A rule can match a task field instead.
decision · conditions
A detour on the same task. The parent waits, then carries on. Up to five levels deep.
invoke
Failed work returns to an earlier step and comes round again until it passes.
resume_at · on_rejected
Shared steps written once and embedded everywhere. Edit once, every workflow changes.
embed
The engine checks it and holds the step until the condition is met, or until an explicit approval is given, recorded with the account that gave it.
requires_approval
A parent splits into tasks with their own workflows. Same order starts together.
sequential_children
Rules live in files, found for the files in scope, read when the step needs them.
standards/
Every picture above is a few fields on a step. Here they are as the engine reads them.
Four conditions, each invoking a sub-workflow. The first matches a task field on its own; the others are picked by the agent, who records why.
// router · step "route" (example)
{
"id": "route",
"name": "Route decision",
"decision": true,
"instructions": "Pick the exit that fits. Say why.",
"conditions": [
{ "id": "project", "name": "Larger project",
"when": { "task_field": "type", "equals": "initiative" },
"invoke": "project-delivery" },
{ "id": "development", "name": "A code change",
"invoke": "development-mr" },
{ "id": "report", "name": "A customer report",
"invoke": "customer-report" },
{ "id": "campaign", "name": "A campaign to improve",
"invoke": "campaign-loop" }
]
}resume_at sends the return trip from the fix back to verify. on_rejected names where a person's rejection sends the run.
// development-mr · review loop (example)
{
"id": "review",
"name": "Review",
"decision": true,
"conditions": [
{ "id": "needs-fixes", "name": "Needs fixes",
"invoke": "fix" },
{ "id": "passed", "name": "Passed" }
],
"resume_at": "verify"
},
{
"id": "merge",
"name": "Approve the merge",
"gate": { "requires_approval": true },
"on_rejected": "build"
}An embed directive pulls a fragment's steps into the workflow. Edit the fragment and every workflow that embeds it changes.
// development-mr · steps (example)
[
{ "embed": "fragment", "id": "find-standards" },
{ "embed": "fragment", "id": "do-and-verify" },
{ "id": "review", "decision": true, ... },
{ "id": "merge", "gate": { "requires_approval": true } }
]
// capture-learnings and complete are added
// to every workflow by the workspace globalsA sequential_children gate routes the parent into its children by order. Children that share an order start together. The parent advances when all are done.
// project-delivery · step "children" (example)
{
"id": "children",
"name": "Run the child tasks",
"gate": { "sequential_children": true }
}
// children, by order
// order 1 Lease review contract-review
// order 1 Hiring plan simple-task
// order 2 Local payroll setup simple-task
// order 3 Launch note simple-taskOne call marks a workflow as the workspace router. It needs a workspace owner or admin and is checked before anything is saved.
workflow_template_meta_update({
"template_id": "router",
"changes": { "is_router": true }
})
// owners and admins only
// every new task, bug, initiative and plan
// in this workspace now starts on "router"Graph engineering in ConvOps is designing how work gets done as a graph of small workflows instead of one giant prompt. One router takes every new task, decisions detour into sub-workflows and come back, loops send failed work round again, and shared fragments keep common steps in one place. Your agent walks the graph one step at a time.
Operators and team leads who own a process, not only engineers. In ConvOps the graph holds the steps, the checks and the exceptions, so the person who knows the work can read and change it. Example: an account lead designs the weekly customer report, and a growth lead designs the campaign loop that reads a sign-up metric.
Those are graphs that call APIs: you write code or wire nodes, and the framework calls models and services. In ConvOps the engine holds the graph and your AI session walks it. Locally, any AI client that connects to ConvOps asks for the current step, does it and advances. Graphs your agents run, with no code to write.
No, by design. In ConvOps a decision either records a choice or detours into a sub-workflow that returns. A loop goes back to an earlier step the workflow names. Every path comes back to the line, so anyone can read the graph and know where a run can go.
In ConvOps a rejection sends the run back to the step the workflow names for it, often the draft or the fix step, and the work comes round again. The gate holds the step until an explicit approval is given, recorded with the account that gave it. Example: a rejected weekly report returns to Draft.
No. Without a router, ConvOps rules match new work to a workflow by type, area, tags and project. A router gives every new task, bug, initiative and plan one door, where the agent triages it and records why it went where it went.
Yes. Ask in conversation and ConvOps edits that one step, while runs already in flight keep going. Or build a workflow that reads a metric and edits workflows, agent instructions or model tiers on its own. You choose whether a person reviews each change. Example: a campaign loop reads its weekly sign-up rate and rewrites its own brief step. Marking the workspace router stays with owners and admins.
No canvas. In ConvOps you describe the change from the AI client you already use, and every run follows the stored workflow. The graph is the steps, decisions and links the engine evaluates, so what you read is what runs. Example: a team lead asks for one more check before the report is sent.