Get your software factory running.
A software factory is a system where AI agents and automation do the repeatable work of building, testing, and shipping software, and your people direct it. Most teams know they want one. Few know the order of steps that gets them there without a stalled pilot or a pile of unreviewable AI output. I do, because I run a factory every day. I’ll get yours running in the right order, so your team skips the expensive mistakes.
Book an intro callAgents are easy to start. Factories are hard to design.
Coding agents alone don't make a factory
Giving every developer an AI assistant speeds up individuals. A factory is different: agents take work from a queue, build it, test it, and hand it back, with little human prompting. Someone has to design that flow, and it is a different skill from using an assistant.
Unreviewed output piles up fast
Agents can produce more code than a team can read. Without a design for review, verification, and task boundaries, you get volume you can't trust. The architect decides what is checked automatically, what a human sees, and what is never delegated.
Autonomy needs boundaries
Agents need credentials, network access, and somewhere safe to run. Sandboxing, capability limits, and audit trails have to be designed in from the start, not added after something goes wrong.
Roles and coordination don't emerge on their own
Once several agents work in parallel they need defined roles, non-overlapping scopes, and a way to resolve conflicts, the way a human team does. Pilots without that structure stall or collide.
Quality has to be a system, not a person
When output is continuous, QA can't depend on one person's attention. The factory needs a standing loop that finds defects, fixes them, and confirms the fix.
I run a software factory, and I built the tools for it.
This isn’t theory. Everything below is running today, and you can inspect it yourself.
Agent Starbase is built by an autonomous factory
Agent Starbase, my self-hosted workbench for running coding agents in Docker sandboxes, is developed by the kind of factory I help others build. A coordinating "mayor" agent assigns scope to as many as eight dev-managers, each leading its own workers and critics, alongside dedicated QA and product-management managers. Every task moves through a defined lifecycle with an owner at each step.
I built the control room, not just the process
Agent Starbase gives operators live terminals, job queues, cron scheduling, task tracking, diff review, and explicit capability boundaries such as network access, Git write, and Docker access per job. It works with multiple LLM providers. These are the pieces a factory needs, built from running one.
Continuous QA is part of the practice
The Agent Starbase repository keeps a running record of dated regression and soak-test reports, and a written plan for discovering an app's features, ranking them, testing each one, fixing what breaks, and repeating. Verification is treated as a standing process, not a release-week task.
Infrastructure for agents to run on
Nebrelo turns a Linux host into a fleet of virtual machines defined in a small YAML file, with a plugin API, a local web view, and CI across multiple Ruby versions. I use it to give agents disposable machines and to host the apps the factory produces; the workspace holds more than twenty deployable app recipes built on it.
I write about the practice
My field notes cover how I run big features through a mayor agent, how to get a QA loop going for web apps, and where autonomous development is heading.
How we get from here to a working factory.
Assess
We look at how software gets built in your organization today: where the time goes, which work is repeatable, and where review and quality gates already exist. You get a candid view of what to automate first and what to leave alone.
Design the architecture
I design the factory: how work is broken into tasks, which agents handle which stages, where humans review, how context and requirements reach the agents, and how everything is observed. It is sized to your team, not copied from a diagram.
Stand up a first line
We pick one real workflow and run it end to end with agents, sandboxes, task tracking, and review in place. A working slice beats a plan, and it exposes the real problems early.
Build the QA loop
Automated output is only useful if it can be trusted. We set up testing, verification, and human review so quality is checked by the system instead of by heroics.
Scale and hand over
We add workflows and agents, document how the factory runs, and train your team to operate and improve it. Success means your team runs the factory without me.
Hands-on help that leaves you with a working system.
- Architecture and workflow design for your factory
- Hands-on setup and pairing with your engineers
- Agent orchestration, sandboxing, and review practices drawn from running my own factory with Agent Starbase
- Honest advice on tooling, including when not to automate
- Written documentation your team keeps
$500 an hour. Less for bigger contracts.
The standard rate is $500 per hour. Volume rates are available for larger engagements, because a bigger commitment lets me plan around your project.
Compare that with the cost of a team spending months on an AI pilot that never reaches production. The right architecture from the start is the cheapest part of the project.
Tell me what you are trying to do and I will scope it and quote the total, including the volume rate that applies.
Have a factory to build?
Send me a few lines about your team and what you want automated. I’ll reply with an honest take on whether I can help and what your first step should be.
Email me