case study: How Neomanex runs on ConvOps.

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

Development Task (MR Flow)real shape · 10 of 30 steps
  1. Triagecaptured, waiting for priorityagent working
  2. Functional analysisapproval freezes the requirements
  3. Standards discoveryfragment · standards-discoverer
  4. Technical analysisfragment · traceability check
  5. Implementagent: implementation-phase-developer
  6. Standards compliancefragment · standards-reviewer
  7. Push and merge requestthe one push
  8. CI verdictred: fix, then watch again
  9. Mergethe single operator checkpoint
  10. Completelearning capture, then done
the agent holds 1 stepthe engine holds the rest
Published ·Updated ·By the Neomanex team

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.

the numbers

What does Neomanex run on ConvOps?

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.

The Neomanex workspace, as of October 2026
What Count Read from
Workflow templates64workflow template list (includes engine test and placeholder templates)
Shared fragments36workflow template list, fragments
Work items tracked11,467task counts, all types and statuses
Work items completed7,559task counts by status
Plans / phases tracked772 / 3,412task counts by type (505 plans and 3,181 phases completed)
Steps in the development task workflow30Development Task (MR Flow) template
Approval gates in a production release5 of 11 stepsProduction Release template
Exits from the development router4Development Intake (Router), Route step
Workspace policies5policy list
Routes in the brain1,577route list, Neomanex workspace
Executors configured17 (14 custom)executor list
Executors that run each dispatch as its own Kubernetes Job3executor list, isolated backend
Agent environments8environment list
Saved work pools3 (plus 4 built in)pool list
Work committed to Now / Next551 / 118task counts by horizon
Standards files in the repository198documentation/standards, markdown files
Root instruction file201 linesCLAUDE.md in the Neomanex repository
every feature

Which ConvOps features does Neomanex use?

All of them. Each row names the feature, how Neomanex uses it, and the section below that shows it.

ConvOps features in the Neomanex workspace, October 2026
Feature How Neomanex uses it See
One step at a timeA code change walks 30 steps. The agent only ever holds the current one.below ↓
Router workflowDevelopment work in 8 projects starts on one intake workflow with 4 exits.below ↓
Decisions that invoke sub-workflowsA red pipeline invokes CI Red Fix on the same task. The parent waits, then continues.below ↓
Fix loopsCI, smoke, acceptance and article reviews go back to the check until it passes.below ↓
Parallel child tasksA 14 phase plan ran in 7 stages. Phases sharing an order ran together.below ↓
Approval gatesMerges wait for a person. A release has 5 gates and a rollback path.below ↓
Audit with two identitiesEach change records the agent label and the verified account behind it.below ↓
Policies inside the step5 rules arrive with the step the agent is working on.below ↓
The brainTriage starts with recall. Workflows end by storing what was learned.below ↓
Fragments36 shared blocks. CI Verdict is written once and embedded in 3 workflows.below ↓
WorkspacesOne 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 horizons3 saved pools plus Now, Next and Rotting. 551 items are committed to Now.below ↓
Executors17 executors: local runners, hosted sessions and isolated runs.below ↓
One Kubernetes Job per run3 executors start each dispatch as its own Job with its own volume and secret.below ↓
Environments8 environments. The product repo receives the work; the standards repo is checked out beside it.below ↓
development

How does one code change move?

Through the Development Task workflow: 30 steps from triage to merge. The agent sees one step. A person approves the analysis and the merge.

Triagebacklog
Analysisapproval
Standardsfound for the files
Implementthe agent
CI verdictred loops back
Mergeapproval
Completelearning captured
  1. Triagebacklog
  2. Analysisa person approves
  3. Standardsfound for the files
  4. Implementthe agent
  5. CI verdictred loops back
  6. Mergea person approves
  7. Completelearning captured
  • 30 steps, one at a timeThe agent sees the current step. The engine holds the other 29.
  • 2 approval gatesFunctional analysis and merge. The run does not move until a person approves.
  • 9 decisionsResearch, plan, UI, test first, acceptance, compliance, CI, publish, standards.
  • 6 embedded fragmentsStandards discovery, analysis, compliance, docs, use cases, CI verdict.

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.

one door

How does new work find its workflow?

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.

new work · example
initiativeSingle sign-on for the admin app
RouteDevelopment Intake · decision

the agent picks one exit and says why

  1. featureFeaturethe work is an initiativeinvokes Feature Delivery
  2. dev-mrDevelopmentchanges product code, any sizeinvokes Development Task (MR Flow)
  3. quickQuickknown pattern, one pass, no MRinvokes Simple Task
  4. opsInfra and opscluster, CI, Dockerfiles, datainvokes Operational Task

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.

fix loops

What happens when a check fails?

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.

CI Verdict fragment · CI Red Fixreal step names
CI Verdictwatch the pipeline to the end
CI Green?decision · green or red-fix
Mergea person approves
CI Red Fix

sub-workflow on the same task

  1. Diagnose CI Red
  2. Fix the Cause
  3. Push (pipeline re-runs)
  4. Fix Cycle Complete
back to CI Verdict
watching the pipelineno fix certifies itself: the re-watch is the proof
Fix loops in Neomanex workflows, October 2026
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, pushCI Verdict, on the new pipeline
Plan Lifecycle (MR Flow)Smoke Test ReviewSmoke Test FixSmoke Test
Plan Lifecycle (MR Flow)Acceptance DecisionAcceptance Fix, on the plan branchAcceptance Testing, re-run on the fixed build
Article PublishingReader Value Review (pass at 80 of 100)Article Engagement FixReader Value Review
Article PublishingSEO ReviewArticle SEO FixSEO Review
Video ProductionDraft review (a gate)none: a rejection goes backTimeline, 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.

parallel work

How does work run in parallel?

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.

Isolated backend on Kubernetesreal plan
Execute Phases · the plan waits herestage 1 of 7 · 2 running · 0 of 14 done
  1. order 0
    • Refactorscode
    • Cluster bring-upinfra
  2. order 1
    • Data foundationcode
    • Executor imagesinfra
    • Runs namespace and RBACinfra
  3. order 2
    • Launchercode
    • Executor configcode
  4. order 3
    • Isolated backendcode
    • Run controllercode
    • Executor formapp
  5. order 4
    • Execution read surfacecode
  6. order 5
    • Execution historyapp
  7. order 6
    • Core docsdocs
    • App docsdocs
same order: start togetherparent waits for allthen the next order starts

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.

the gates

Where do people decide?

At the steps where a mistake is expensive. A production release has 11 steps and five of them are approval gates.

Release trainwhat ships
Pre-flightapproval
Release notesapproval
Pre-announceapproval
Deploythe agent
Verifyapproval
Post-announceapproval
Close outrecorded
  1. Release trainwhat ships
  2. Pre-flightapprove scope
  3. Release notesapprove text
  4. Pre-announceapprove post
  5. Deploythe agent
  6. Verifyreject: rollback
  7. Post-announceapprove post
  8. Close outrecorded

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.

Activity · exampleexample record
Production Release Verify (smoke) · waiting for a person
step
Verify (smoke)Post-announce
gate
waitingapproved
actor labelrelease agentwhat the client says it is
accountthe person signed inwhat the server verified
inside a step

What does the agent see at each step?

The current step, what the brain already knows, and the workspace policies. Nothing about the steps that come later.

Claude Code · exampleexample conversation
Pick up the refund rounding bug.

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.

fragments

How do 64 workflows stay consistent?

Shared steps are written once as fragments and embedded where they are needed. Neomanex has 36.

Fragments in the Neomanex workspacereal embed map
Which Neomanex workflows embed each shared fragment
fragment Dev TaskDev Task (MR)MR ReviewPlanPlan (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
  • Standards Discovery1 step · embedded in 4Development TaskDevelopment Task (MR Flow)MR ReviewPlan Lifecycle
  • Code Standards Compliance3 steps · embedded in 4Development TaskDevelopment Task (MR Flow)MR ReviewPhase Implementation
  • Document Use Cases1 step · embedded in 4Development TaskDevelopment Task (MR Flow)Plan LifecyclePlan Lifecycle (MR Flow)
  • CI Verdict2 steps · embedded in 3Development Task (MR Flow)MR ReviewPlan Lifecycle (MR Flow)
  • Learning Capture, Completeglobal steps · appended by the engine
embedded fragment: edit once, every embed changesglobal steps: appended by the engine, never copied

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.

workspaces

How does one team work across workspaces?

One account, eight workspaces. A recall searches all of them at once. Every write lands in exactly one.

one recall · example

How do we ship the docs site?

Neomanexengineering
Contentside workspace
Customercustomer workspace

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.

unattended

What runs when nobody is watching?

Schedules start work from an RRULE, pools pick what is next, and horizons say what is committed now.

Recurring · RRULEreal schedule
FREQ=MONTHLY;BYMONTHDAY=1;BYHOUR=10;BYMINUTE=0

Fires on the 1st of every month at 10:00 and starts the base image re-pin sweep, an 11 step workflow.

  1. Jan
  2. Feb
  3. Mar
  4. Apr
  5. May
  6. Jun
  7. Jul
  8. Aug
  9. Sep
  10. Oct
  11. Nov
  12. Dec

next fire: November 1 · the one live recurring schedule

One-shot handoffs · July 8, 2026real night
FREQ=MINUTELY;COUNT=1

Four schedules fired once at 02:10 UTC and handed four guide pages to an unattended runner, through the 7 step Async Delivery workflow.

Guide page 1 of 4
Guide page 2 of 4
Guide page 3 of 4
Guide page 4 of 4

finish times in UTC · all four completed before 07:00

Neomanex work pools, October 2026
Pool Kind What it holds
Nowbuilt ineverything committed to Now
Now, actionablebuilt inopen Now work, top priority first
Nextbuilt inqueued for Next
Rottingbuilt inNow work untouched for 7 days
Pending deploysavedbuilt and verified, not yet in production
Open non-backlog taskssavedthe recurring stale work audit
Open tasks since a datesavedcreated 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.

executors

Where does the agent actually run?

Wherever the task's executor says. Neomanex has 17: local runners, hosted sessions, and isolated runs that start one Kubernetes Job each.

one task, one executor1/3

tasks_dispatch

Plan phase: launcherdispatched from the plan, example
next item
Local runner4 executors · ConvOps returns the envelopeClaude Code · Kimi
idle
Hosted session7 executors · ConvOps starts the runClaude · DeepSeek · Kimi
idle
Isolated run3 executors · one Kubernetes Job eachClaude Code
idle
  • The product repo receives the workSix of the eight environments are one per product. The other two are scratch environments for smoke tests.
  • Standards ride along, read-onlyThe documentation repository is checked out beside it, so the standards are on disk.
  • A fixed list of ConvOps toolsEach environment names the ConvOps tools a run may call: 11 for most products, 14 for one.
  • Secrets only where neededOne of the eight environments carries a secret. The others run without one.

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.

the instruction file

What happened to CLAUDE.md?

It stopped holding the process. The root file keeps the contract, the red lines and one loop: read the step, do it, advance.

CLAUDE.mdexample
the process, in prose+1 rule
  1. 256## Deploys
  2. 257- Run the tests. Then the linter. Then the tests again.
  3. 258- Release notes go to the channel. Ask first.
  4. 259## Reviews
  5. 260- Big changes need a plan. Small ones do not.
  • Every lesson is a new paragraph. Deploys, reviews, bugs and posts share one file.
  • The agent reads all of it. Each task carries every other task's rules.
  • Nothing checks it. "Ask first" is a sentence, not a gate.

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.

beyond code

Which workflows run the rest of the company?

The same engine runs plans, QA, reviews, articles, posts and films. Step counts as of October 2026.

Selected Neomanex workflows, October 2026
Workflow Steps What it governs
Development Task (MR Flow)30A code change from triage to merge, with analysis and merge approvals and a CI fix loop.
Plan Lifecycle (MR Flow)32A larger plan from analysis to merge. Phases run as child tasks, stage by stage.
Feature Delivery16An initiative split into plans. Plans are planned one at a time, then executed one at a time.
Production Release11Release notes, announcements, deploy and smoke check, with five approval gates.
Manual QA, extreme testing12Functional testing of a feature against a live environment.
MR Review15Review, live test, standards check and merge for a merge request someone else opened.
Article Publishing12Topic, brief, research, writing, then reader value and SEO reviews that loop back on failure. Four approval gates.
LinkedIn Content6A decision picks the post or the article track, each a shared fragment, then reviews are logged.
Video Production16A teaching film from brief to publish. Five approval gates; a rejected draft goes back to the timeline.
Base Image Re-Pin Sweep11The fleet-wide monthly sweep, fired by a schedule on the 1st of each month.
Operational Task9Infrastructure 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.

what made it work

Why does it hold up at this size?

Four pieces carry most of the weight.

One step at a time

The agent asks for the current step, does it and advances. It never reads the whole process.

workflow_advance

Gates the engine checks

Merges and releases wait for a person. The engine refuses to move past an unmet gate.

requires_approval

Loops, not retries

A failed check invokes a fix workflow and comes back to the same check. Nothing certifies itself.

resume_at

Memory and routes

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.

questions

What people ask about this setup.

Does Neomanex really use ConvOps for its own work?

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.

Which AI clients does the Neomanex team use with ConvOps?

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.

Do AI agents merge code without a person?

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.

What happens when the CI pipeline fails?

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.

Do the steps of a workflow run in parallel?

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.

Does Neomanex run agents on Kubernetes?

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.

How long is the Neomanex CLAUDE.md?

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.

Where do the coding standards live?

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.

Can I use the same workflows?

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.