One step at a time
The agent asks for the current step, does it and advances. It never reads the whole process.
workflow_advance
Neomanex builds ConvOps and runs its own engineering, content and releases on it. AI agents walk 64 workflows one step at a time, failed checks loop back, and people approve at the gates.
the Neomanex workspace · as of October 2026
Neomanex, the company that builds ConvOps, runs its own software delivery, content and releases on ConvOps. AI agents get one step at a time from 64 workflows, failed checks loop back until they pass, plans split into phases that run in parallel, and a person approves before code merges or a release ships. Real counts, October 2026.
Software delivery, releases, QA, articles, social posts and teaching films. Every number below was read from the Neomanex workspace on October 4, 2026.
Neomanex builds ConvOps, and the team runs the company's own work through it. Engineering, content and operations share one workspace. Each kind of work has a workflow, and the AI agent walks it one step at a time from Claude Code or OpenCode over MCP. ConvOps does not run the models. It holds the process, the gates and the memory.
| What | Count | Read from |
|---|---|---|
| Workflow templates | 64 | workflow template list (includes engine test and placeholder templates) |
| Shared fragments | 36 | workflow template list, fragments |
| Work items tracked | 11,467 | task counts, all types and statuses |
| Work items completed | 7,559 | task counts by status |
| Plans / phases tracked | 772 / 3,412 | task counts by type (505 plans and 3,181 phases completed) |
| Steps in the development task workflow | 30 | Development Task (MR Flow) template |
| Approval gates in a production release | 5 of 11 steps | Production Release template |
| Exits from the development router | 4 | Development Intake (Router), Route step |
| Workspace policies | 5 | policy list |
| Routes in the brain | 1,577 | route list, Neomanex workspace |
| Executors configured | 17 (14 custom) | executor list |
| Executors that run each dispatch as its own Kubernetes Job | 3 | executor list, isolated backend |
| Agent environments | 8 | environment list |
| Saved work pools | 3 (plus 4 built in) | pool list |
| Work committed to Now / Next | 551 / 118 | task counts by horizon |
| Standards files in the repository | 198 | documentation/standards, markdown files |
| Root instruction file | 201 lines | CLAUDE.md in the Neomanex repository |
All of them. Each row names the feature, how Neomanex uses it, and the section below that shows it.
| Feature | How Neomanex uses it | See |
|---|---|---|
| One step at a time | A code change walks 30 steps. The agent only ever holds the current one. | below ↓ |
| Router workflow | Development work in 8 projects starts on one intake workflow with 4 exits. | below ↓ |
| Decisions that invoke sub-workflows | A red pipeline invokes CI Red Fix on the same task. The parent waits, then continues. | below ↓ |
| Fix loops | CI, smoke, acceptance and article reviews go back to the check until it passes. | below ↓ |
| Parallel child tasks | A 14 phase plan ran in 7 stages. Phases sharing an order ran together. | below ↓ |
| Approval gates | Merges wait for a person. A release has 5 gates and a rollback path. | below ↓ |
| Audit with two identities | Each change records the agent label and the verified account behind it. | below ↓ |
| Policies inside the step | 5 rules arrive with the step the agent is working on. | below ↓ |
| The brain | Triage starts with recall. Workflows end by storing what was learned. | below ↓ |
| Fragments | 36 shared blocks. CI Verdict is written once and embedded in 3 workflows. | below ↓ |
| Workspaces | One account, 8 workspaces. Recall searches all of them, writes land in one. | below ↓ |
| Schedules (RRULE) | A monthly sweep fires on the 1st at 10:00. One-shot schedules hand work to runners overnight. | below ↓ |
| Pools and horizons | 3 saved pools plus Now, Next and Rotting. 551 items are committed to Now. | below ↓ |
| Executors | 17 executors: local runners, hosted sessions and isolated runs. | below ↓ |
| One Kubernetes Job per run | 3 executors start each dispatch as its own Job with its own volume and secret. | below ↓ |
| Environments | 8 environments. The product repo receives the work; the standards repo is checked out beside it. | below ↓ |
Through the Development Task workflow: 30 steps from triage to merge. The agent sees one step. A person approves the analysis and the merge.
The workflow starts with a functional analysis. The agent writes what the change must do as numbered requirements with observable acceptance criteria. A person approves it, and the approval freezes the list. A shared fragment then finds the standards for the files in scope, and another writes the technical design, with every element pointing at the requirement it serves.
The agent implements in its own branch and environment, checks the code against the standards it found, and opens the merge request in one push. A CI verdict step watches the pipeline, and a red result goes into the fix loop shown below. The merge step is the single operator checkpoint. It is a gate the engine checks: the run does not move past it until a person approves. The steps run one after another, always. The workflow engine hands out one at a time.
Development work in eight projects starts on one router workflow. Triage recalls first, then a Route decision picks one of four exits and records why.
the agent picks one exit and says why
The Development Intake workflow has four steps. Triage opens with "recall first": the agent asks the brain what is already known before it reads a file, then confirms the kind of work. Route is a decision whose four exits each invoke a sub-workflow on the same task: Feature Delivery for an initiative, the development workflow for a code change, Simple Task for a small known fix, and Operational Task for infrastructure. The agent advances with the exit it picked and one line saying why, so the routing is on the record. The parent waits for the sub-workflow, then captures learnings and completes.
Everything else, from LinkedIn posts to releases, is matched to its workflow by rules on type, area, tags and project. The pattern of small workflows that call each other is graph engineering.
It goes back. A decision invokes a fix workflow on the same task, and the run returns to the check that failed. It repeats until the check passes.
sub-workflow on the same task
| Workflow | The check | On failure | Goes back to |
|---|---|---|---|
| Development Task (MR Flow), MR Review, Plan Lifecycle (MR Flow) | CI Green? | CI Red Fix: diagnose, fix the cause, push | CI Verdict, on the new pipeline |
| Plan Lifecycle (MR Flow) | Smoke Test Review | Smoke Test Fix | Smoke Test |
| Plan Lifecycle (MR Flow) | Acceptance Decision | Acceptance Fix, on the plan branch | Acceptance Testing, re-run on the fixed build |
| Article Publishing | Reader Value Review (pass at 80 of 100) | Article Engagement Fix | Reader Value Review |
| Article Publishing | SEO Review | Article SEO Fix | SEO Review |
| Video Production | Draft review (a gate) | none: a rejection goes back | Timeline, then a new draft |
The loop is built from two parts any workflow can use. A decision step has a condition that invokes a sub-workflow, and a resume point that sends the run back to an earlier step when the sub-workflow finishes. The fix workflow's own text sets the rule: fix the cause, never loosen a test to make it green, and never certify a fix without watching the check again. How the parts fit together is on graph engineering.
Through child tasks, never through steps. Phases that share an order value start together, and the plan waits until every one of them is done.
Inside one workflow the steps run one after another. Parallelism lives one level up. In the Plan Lifecycle workflow, the Execute Phases step is a gate with sequential children: the engine starts every phase that shares the current order value, holds the plan on that step, and starts the next order only when all of them are finished. Each phase then walks its own workflow, one step at a time.
The plan above is real. In September 2026 Neomanex built the ConvOps isolated backend with ConvOps: 14 phases in 7 stages, two of them running three phases side by side. The first phases were created on September 26 and the last one completed on September 27. Feature Delivery uses the same mechanism one level higher: an initiative plans all its plans, then executes them one at a time.
At the steps where a mistake is expensive. A production release has 11 steps and five of them are approval gates.
The agent assembles the release train and writes the runbook. A person approves the scope, then the release notes, then the heads-up post before anything is posted. The agent deploys. A person approves the smoke check, and a rejection sends the run to the rollback step instead of the announcement. The "now live" post waits for one more approval.
Each approval is a workflow gate the engine evaluates. Each change is recorded with two identities: the label the agent acts under and the account the server verified. There is no separate approver field; the verified account on the record is who it was. The full pattern is in human approval gates for AI agents, and the record in governance.
The current step, what the brain already knows, and the workspace policies. Nothing about the steps that come later.
Recall comes first. The router's Triage step tells the agent to query the brain before it reads anything, and the answer comes back as memories (what was decided and why) and routes (where the code lives). Neomanex has 1,577 routes in its brain. Then each step arrives with the five workspace policies attached, so the rules travel with the work instead of sitting in a file the agent may not reread. Policies are guidance the agent receives. The gates are what the engine enforces.
Shared steps are written once as fragments and embedded where they are needed. Neomanex has 36.
| fragment | Dev Task | Dev Task (MR) | MR Review | Plan | Plan (MR) | Phase |
|---|---|---|---|---|---|---|
| Standards Discovery1 step · in 4 | ||||||
| Code Standards Compliance3 steps · in 4 | ||||||
| Document Use Cases1 step · in 4 | ||||||
| CI Verdict2 steps · in 3 | ||||||
| Learning Capture, Completeglobal steps · appended |
The CI Verdict fragment is two steps: watch the pipeline, then decide. Development Task (MR Flow), MR Review and Plan Lifecycle (MR Flow) all embed it, so a change to how Neomanex reads a pipeline lands in all three at once. Standards discovery, compliance checks and use case documentation work the same way. Two global steps, Learning Capture and Complete, are appended by the engine to the end of the workflows, so even a small fix ends by storing what it taught.
One account, eight workspaces. A recall searches all of them at once. Every write lands in exactly one.
How do we ship the docs site?
The Neomanex account belongs to the Neomanex workspace, its own side workspaces for content and education, and customer workspaces. The instruction file has one rule for it: never pass a workspace to recall, always pass one to a write. Recall fans out across every workspace the account belongs to, and each memory stays owned by its workspace. Customer knowledge never pools into Neomanex. See workspaces and the brain.
Schedules start work from an RRULE, pools pick what is next, and horizons say what is committed now.
FREQ=MONTHLY;BYMONTHDAY=1;BYHOUR=10;BYMINUTE=0Fires on the 1st of every month at 10:00 and starts the base image re-pin sweep, an 11 step workflow.
next fire: November 1 · the one live recurring schedule
FREQ=MINUTELY;COUNT=1Four schedules fired once at 02:10 UTC and handed four guide pages to an unattended runner, through the 7 step Async Delivery workflow.
finish times in UTC · all four completed before 07:00
| Pool | Kind | What it holds |
|---|---|---|
| Now | built in | everything committed to Now |
| Now, actionable | built in | open Now work, top priority first |
| Next | built in | queued for Next |
| Rotting | built in | Now work untouched for 7 days |
| Pending deploy | saved | built and verified, not yet in production |
| Open non-backlog tasks | saved | the recurring stale work audit |
| Open tasks since a date | saved | created but not finished |
Horizons are the commitment axis. Each work item is Now, Next or Later, and children inherit it from the nearest parent that sets one. As of October 2026, 551 Neomanex work items are committed to Now and 118 to Next. The Rotting pool catches Now work nobody has touched for seven days. Pending deploy holds work that is built and verified but not yet in production, and the release workflow's close out step clears it. Read more on autonomy.
Wherever the task's executor says. Neomanex has 17: local runners, hosted sessions, and isolated runs that start one Kubernetes Job each.
tasks_dispatch
A dispatch names a task and an executor. For a local runner, ConvOps returns the dispatch envelope and a machine of the team's runs it. For a hosted executor, ConvOps starts the session itself. The three isolated executors run each dispatch as its own Kubernetes Job, with its own task volume and a secret made for that run, so two runs never share a disk or a credential. See executors and Kubernetes.
The environment decides what the run starts with. Neomanex has eight. In a product environment the product repository receives the work and the documentation repository is checked out beside it, read-only, so the 198 standards files are on disk for the agent. See environments.
It stopped holding the process. The root file keeps the contract, the red lines and one loop: read the step, do it, advance.
The Neomanex root CLAUDE.md is 201 lines today. That is not tiny, and we will not pretend it is. What changed is what it holds. It says who the agent works for, what it must refuse, where kinds of work go, and how to work: read the workflow step, do exactly what it says, advance, repeat. The order of steps, the approvals and the agent each step needs live in 64 workflows. The coding rules live in 198 standards files, found at the step that needs them by a shared standards discovery fragment, with ten routing files that map each kind of work to its standards.
The runner workspace that executes work unattended goes further: its instruction file is 18 lines, and most of them say to follow the workflow.
The same engine runs plans, QA, reviews, articles, posts and films. Step counts as of October 2026.
| Workflow | Steps | What it governs |
|---|---|---|
| Development Task (MR Flow) | 30 | A code change from triage to merge, with analysis and merge approvals and a CI fix loop. |
| Plan Lifecycle (MR Flow) | 32 | A larger plan from analysis to merge. Phases run as child tasks, stage by stage. |
| Feature Delivery | 16 | An initiative split into plans. Plans are planned one at a time, then executed one at a time. |
| Production Release | 11 | Release notes, announcements, deploy and smoke check, with five approval gates. |
| Manual QA, extreme testing | 12 | Functional testing of a feature against a live environment. |
| MR Review | 15 | Review, live test, standards check and merge for a merge request someone else opened. |
| Article Publishing | 12 | Topic, brief, research, writing, then reader value and SEO reviews that loop back on failure. Four approval gates. |
| LinkedIn Content | 6 | A decision picks the post or the article track, each a shared fragment, then reviews are logged. |
| Video Production | 16 | A teaching film from brief to publish. Five approval gates; a rejected draft goes back to the timeline. |
| Base Image Re-Pin Sweep | 11 | The fleet-wide monthly sweep, fired by a schedule on the 1st of each month. |
| Operational Task | 9 | Infrastructure work: scope and blast radius, execute, verify every write by reading it back. |
Each of these is built from the same parts: steps handed out one at a time, gates where a person decides, decisions that branch, and fix loops that go back to the check. The workflow engine runs them all, and the comparison pages show how that differs from other agent tools.
Four pieces carry most of the weight.
The agent asks for the current step, does it and advances. It never reads the whole process.
workflow_advance
Merges and releases wait for a person. The engine refuses to move past an unmet gate.
requires_approval
A failed check invokes a fix workflow and comes back to the same check. Nothing certifies itself.
resume_at
Decisions and file locations are stored as the work happens and recalled before the next task.
context_query
The last piece is the one we lean on most. Our workflows end in a learning capture step, so decisions and gotchas are stored as memories and file locations as routes. The next session asks the brain first, before it reads a single file.
Yes. As of October 2026 the Neomanex workspace in ConvOps holds 64 workflow templates, 36 shared fragments and 11,467 tracked work items, 7,559 of them completed. Code changes, releases, QA, articles, LinkedIn posts and teaching films all run through those workflows.
The team works from Claude Code and OpenCode. ConvOps does not run AI models: the client connects over MCP, asks for the current step and advances. Any MCP client can walk the same workflows.
No. In the Development Task workflow the merge step is an approval gate, so the run waits for a person. A production release has five approval gates, and a failed smoke check sends the run to rollback.
The CI Green? decision picks red-fix, which invokes the CI Red Fix workflow on the same task: diagnose, fix the cause, push. The run then goes back to CI Verdict and watches the new pipeline. The merge gate stays closed until the verdict is green.
No. Steps inside one workflow always run one after another. Parallel work is child tasks: phases of a plan that share an order value start together, and the plan waits until all of them finish before the next stage starts. One Neomanex plan ran 14 phases in 7 stages this way.
Yes. Three of its executors run each dispatch as its own Kubernetes Job, with its own task volume and a secret made for that run. Other executors hand the work to a local runner or start a hosted session.
The root file is 201 lines as of October 2026. It holds the contract, the red lines, routing tables and one loop: read the workflow step, do it, advance. The step order, the gates and which agent runs each step live in the workflows, not in the file.
In 198 markdown files under documentation/standards in the repository, with ten routing files that map a kind of work to the standards it needs. A shared standards discovery fragment finds the standards for the files in scope at the step that needs them.
The Neomanex workflows are internal, but the shapes are not secret. The template gallery has starter workflows for development, bug fixing, releases and content, and you can change any step in conversation from your AI client.