Software Factory CLI

Every AI-written pull request, verified before your team reviews it

Your engineers already build with Claude Code, Codex, and Cursor. The Software Factory CLI plugs into those agents and makes every branch earn its review: tested at the exact commit that will ship, checked by an independent judge, and opened as a PR with the evidence attached. Your reviewers spend their time on judgment calls, not on catching what the agent broke.

macOS · Linux

# 1. Install the codepress executable

$curl -fsSL https://downloads.codepress.dev/factory/install.sh | sh

# 2. Hook it into your agent

$codepress factory init --provider claude

Two-command install · works with the agents your team already uses · no new accountsWatch a branch go from commit to review-ready

Why engineering leaders use it

Agents made writing code cheap. Reviewing it didn't get any cheaper.

When every engineer ships with an agent, your reviewers become the QA team. The Factory makes each agent prove its work before a person spends time on it.

Reviewers review. They don't re-test.

Every PR arrives with a QA report for the exact commit being shipped, so review starts from evidence instead of pulling the branch to check it by hand.

One bar for every agent and engineer

The same delivery standard applies whether the code came from Claude Code, Codex, or Cursor, on anyone's machine.

An audit trail on every PR

QA results, the judge's verdict, and any skipped check — with its written reason — are posted on the pull request for everyone to see.

Humans still decide what ships

The Factory stops at ready-for-review. It never merges; your team keeps the final call.

See it in action

From “done” to review-ready, with no babysitting

When an agent finishes a branch, the Factory tells it exactly what to do next — test it, open a draft PR, post the evidence, get an independent verdict — until the PR is ready for a human.

~/app — feat/usage-export

● agent · committed 3 files on feat/usage-export

codepress factory start --repo .

Factory delivery started

Branch: feat/usage-export

Next: verify the current head, then qa-stamp

codepress factory delivery qa-stamp --verdict PASS

QA verdict: PASS at 4e1c9a2

codepress factory delivery create-draft-pr

Draft PR: #412 opened

codepress factory delivery post-report

Report: posted · judge requested

● judge · VERIFICATION PASS for 4e1c9a2

codepress factory delivery ready-for-review

Factory delivery ready for review

Checks: head · report · verdict · CI · mergeable

How it works

Seven checkpoints between an agent's commit and your reviewer

Progress is saved per branch, so if an agent crashes, a session restarts, or a teammate picks up the work, delivery resumes right where it stopped.

01
Agent writes the code
Your engineer's agent works on a feature branch exactly as it does today. Nothing about their workflow changes.
02
Delivery starts
Once the work is committed, delivery kicks off — started by the agent, by the engineer, or automatically.
03
Tested at the exact commit
QA runs against the precise version that will ship, not an earlier draft, and records a clear PASS, FAIL, or BLOCKED.
04
Draft PR opens
A draft pull request opens with the change, including screenshots or video whenever the UI changed.
05
Evidence on the PR
The QA report is posted on the pull request, where every reviewer can see what was tested and how.
06
Independent verdict
A separate judge reads the evidence and rules on the current version — a second opinion, not the author grading its own work.
07
Ready for your team
Only after re-checking the latest commit, the report, the verdict, CI, and merge conflicts does the PR leave draft for human review.
Your team still decides what ships.
The Factory never merges. A review-ready PR is an invitation for a human, not an approval.

Works with your stack

No new agent to adopt

Your engineers keep the coding agent they already use. One command connects the Factory to that agent's existing settings — no retraining, no migration, no lock-in.

Claude Code

.claude/settings.json

Codex

.codex/hooks.json

Cursor

.cursor/hooks.json

Muse Spark

.muse/hooks.json

Devin, Grok, Kimi

Supported through the same integration.

Built to stay out of the way

Guardrails that guide agents, never trap them

A delivery process that stalls your engineers is worse than none at all. Every check comes with a way forward, so the Factory raises the bar without becoming a bottleneck.

Every check says what to do next

When something isn't ready, the agent gets a plain reason and a concrete next step it can take on its own. A check is a nudge, never a dead end.

Exceptions are allowed — and recorded

Escalate to a human, skip QA, ship unverified, or abandon the branch when that's the right call. Each exception needs a written reason and shows up on the PR, never hidden.

Never blocks your engineers

If the Factory is missing, crashes, or runs slow, the agent keeps working. Every check is capped at six seconds, and any failure is logged with its cause.

No runaway loops

An agent that keeps hitting the same wall is released instead of burning hours and tokens on a stuck session.

You choose when it runs

Delivery starts on request by default. Turn on automatic mode per machine when your team is ready for every finished branch to enter delivery on its own.

Nothing to provision

One self-contained binary for macOS and Linux. Git is the only dependency — no Node, Python, or other tooling to roll out.

No new accounts

Works with your engineers' existing GitHub credentials. There's no Factory login to manage.

Signed, reversible updates

Every release is cryptographically signed and verified, with stable and beta channels and a one-command rollback.

For your engineers

Output humans and agents read the same way

Every command prints plain, labeled text — no colors, spinners, or special modes — so an engineer and their agent always see exactly the same thing.

codepress factory init: Connect the Factory to your agent and walk through setup
codepress factory start: Start delivery for the current branch
codepress factory guidance: Show what's required right now and the next step to take
codepress factory skill: Print the usage guide built into the executable
codepress factory delivery status: Show where a branch is in delivery
codepress factory bootstrap --local: Set up local QA with the agent you already use, no login
codepress factory doctor: Run health checks, each problem paired with its fix
codepress auto on | off | status: Let this machine start delivery automatically
codepress factory update | rollback: Signed updates on stable or beta, with one-command rollback

FAQ

Questions engineering leaders ask

What does my team have to change?

Almost nothing. Each engineer installs one binary and runs one command to connect the agent they already use. Day-to-day work stays the same; the Factory takes over once a branch is committed and carries it through testing, evidence, and an independent verdict to a review-ready PR.

Do we need a CodePress account?

No. The CLI talks to GitHub directly using your engineers' existing Git or gh credentials, so there is no Factory-specific login. codepress factory bootstrap --local sets up local QA with the agent you already run, without a connected CodePress repository.

Which coding agents are supported?

Claude Code, Codex, Cursor, and Muse Spark are configured with a single command, and Devin, Grok, and Kimi are supported through the same integration. The Factory never replaces your agent — it works with the one your team already uses.

Will it merge code without a human?

No. Delivery ends at ready-for-review. A review-ready PR means the latest commit has passing QA evidence and an independent verdict — it is not permission to merge. Your team decides what ships, and an agent merges only when someone explicitly asks it to.

Could it slow my engineers down?

It's designed not to. If the CLI is missing, crashes, or runs slow, the agent keeps working: every check is capped at six seconds and the cause is logged to ~/.codepress/factory/hook-adapter.log. When a check does stop an agent, it names a next step the agent can take on its own, exceptions only need a written reason, and repeated identical blocks are capped so no session gets stuck in a loop.

How is this different from the hosted Software Factory?

The CLI runs the delivery process on your engineers' machines with their own agents. The hosted CodePress Software Factory runs the same process on cloud agents, from issue to verified PR, and its agents ship with a pinned copy of the CLI.

Give every agent-written PR a verified path to review

Two commands on macOS or Linux, and your team's agents start delivering with evidence attached. Want the whole process run by cloud agents, from issue to verified PR?

Explore the hosted Software Factory