Work keeps moving
Agents stop waiting for someone to paste the next prompt. The system knows what stage the job is in, what is missing, and what can happen next.
Velomor by Inspectural
Dark Factory Software Development
AI coding is useful in bursts. Dark Factory turns those bursts into a delivery loop: work gets picked up, understood, changed, checked, reviewed, and handed to a person only when judgment is needed.
workflow run
WF-0427 / payments-ledger-rules
human gate
Stage attempts
5 passed, 1 waiting
spec artifact v3 accepted pass
build runner macos-02, fresh worktree pass
review risk raised by migration diff gate
Evidence bundle
diff.patch test.log decision.json policy.yml
Allowed next actions
Approve release candidate human
Request revision human
Retry failed attempt disabled
The result is a delivery loop: agents keep work moving, evidence stays attached, and human approval happens with the context already on screen.
control runners evidence
request
Intake
A rough idea becomes a job with a clear goal, enough context, and a known owner.
agent
Spec
The agent writes down what it plans to change so the team is not reviewing mystery work later.
system
Plan
The factory decides what kind of workspace, checks, review, and approval the job needs.
runner
Build
A runner opens a clean workspace, gets the code ready, makes the change, and records what happened.
agent plus human
Review
Independent review looks at the actual change, the risk, the checks, and the evidence.
human gate
Release
Safe work can keep moving. Sensitive work lands in front of a person with the context already assembled.
Why it works
Make the system simple where trust gets expensive
The problem is not whether an agent can write code. It can. The problem is that code still needs context, checks, review, release rules, and a way to recover when something stalls. Velomor wraps the agent in that operating system.
No more guessing
Every codebase gets a repeatable operating routine. Agents stop guessing how to start, which checks matter, and when the work is finished.
Review matches risk
Tiny safe changes do not need the same ceremony as a production migration. Risk-shaped review keeps speed and judgment in the same system.
Humans get the right work
People get pulled in for judgment, approval, and exceptions. They do not have to babysit every command to understand what happened.
The operating layer
The simple promise has real machinery behind it
Agents do the work. The factory keeps that work moving. People approve the moments that need judgment. Velomor makes that credible with a deterministic control plane, runner nodes, narrow credentials, and repo-owned checks.
Orchestration
The system knows what is happening, what is missing, and what can happen next
Workspaces
Runner nodes give agents clean places to work with only the access each job needs
Codebase routine
Every repo has a repeatable operating routine for setup, checks, cleanup, and proof
Approval
People get pulled in for release calls, sensitive overrides, and work that needs judgment
What we build with teams
From agent habit to delivery system
Most teams already have smart people prompting agents. The gap is the machinery around the agents: policy, repeatability, evidence, review, and a substrate that can carry real work without constant babysitting.
Turn scattered prompting into a clear path from request to shipped change.
Give each codebase a reliable way to get ready, run checks, clean up, and prove the job is finished.
Set up the machines and credentials agents need without giving them broad trust.
Route simple work quickly and send risky work to stronger review.
Build the evidence view so a reviewer can see the change, the checks, and the reason for the decision.
Use cloud-to-metal strategy when owned machines make the factory cheaper, cleaner, or easier to isolate.
Cloud-to-metal connection
The factory gets sharper when you own more of the stack
Agentic development creates long-running jobs, secrets boundaries, staging paths, build machines, and cost profiles that cloud defaults rarely optimize for. Cloud-to-metal work gives the factory a cleaner substrate when workloads are stable, sensitive, or expensive. The software loop and the infrastructure loop reinforce each other.