The Software Factory Class: One Rented Server That Takes Orders in Plain English

Every piece of software ever sold starts with the same awkward translation problem. Somebody knows what they want. Somebody else — or something else — has to turn that wanting into thousands of lines of exact, unforgiving code. The whole history of the software industry is the history of that gap: programmers exist because computers only take orders in one language, and it isn't yours.

So we asked a question that sounds like a joke until the numbers come back: what is the cheapest complete software factory we can build that takes orders the way a diner takes orders — in plain conversation — and ships working software out the other end?

We set a hard budget ceiling (one rented server in the €84-a-month class), we required the design to be legal under the vendors' own rules rather than clever about them, and we graded every claim against published benchmarks and primary documentation. Here is what we found, factory floor and all.

Meet the factory

Picture a small factory with five stations.

The front office is a chat window — Open WebUI, free and open source. It looks like any chat app you have ever used. This is the only door the owner ever walks through.

The foreman stands just inside it: an open-source agent called Hermes, from Nous Research. The foreman's job is not to build anything. The foreman listens to plain language, asks a question when an order is fuzzy, and translates the order into a precise work ticket — the kind of exact, technical brief a builder can execute without guessing. When work comes back, the foreman inspects the paperwork and reports to the front office in plain words again.

The assembly line has three bays, and this is where the actual building happens. Bay one holds Claude Code, Anthropic's builder, currently the strongest measured coding agent in its class. It does its everyday building with a pro-tier model and calls the top-tier model up only for the hardest jobs. Bay two holds OpenAI's Codex — a second builder, and the factory's standing reviewer: a different vendor's eyes on bay one's work. Bay three holds OpenHands, the flexible hand: it runs several smaller jobs in parallel and handles bulk work. Every job gets its own sealed workspace — a container and a fresh copy of the project — so three builders can work at once and none of them can break another's job.

Quality control is a gate, not a person: the project's automated tests. Nothing leaves a bay until the tests pass, and a second builder reviews the work. The cheapest reliable intelligence in the whole building is a test suite, because a test suite cannot be sweet-talked.

The shipping dock is version control. Finished work leaves as reviewed branches, deployed by the same push-to-publish pipeline we already run for our own site.

Total software licences for all of the above: zero. Every structural piece is open source. The money in this factory goes to exactly three things: the building, the foreman's brain, and the builders' wages. Which is where the interesting questions live.

A short vocabulary, because the names do no favours

Five terms carry the whole design, so here they are in plain English before the argument starts.

Body and brain. Hermes is software — the body. It listens, remembers, files paperwork and dispatches jobs. It arrives with no mind of its own: a brain — a language model — is rented separately and plugged into it.

Nous is the company that makes Hermes. When the foreman needs something, Nous is the first place we shop.

The Portal is Nous's prepaid wallet. Twenty dollars a month buys twenty-two dollars' worth of thinking, spendable across more than 300 different brains — one wallet instead of an account with every AI company on earth.

Sonnet is a brain made by Anthropic, the Claude company. It is the pro tier: the senior professional — strong, quick, and priced in the middle.

Opus is Anthropic's top tier: the expensive genius. Brilliant, and billed like it.

The foreman's brain: why the senior gets the desk

The foreman needs a brain, and there are two ways to get one: run a model locally, on our own server, for free — or rent one through the wallet.

The free option is real, and it is cleverer than it sounds. Our server has no graphics card, which rules out almost every local model worth having: on a plain CPU, a typical smart model reads its own weights so slowly that it answers at a handful of words per second.

Almost. One model family cheats physics honestly: Qwen3-30B-A3B only wakes up a small slice of itself for each word — about a tenth of its total size — so on our server class it speaks at a conversational 15 to 30 words per second, from memory the machine already has. It costs nothing per word, it never sends the owner's conversations anywhere, and it can hold a 64,000-word working memory, which is the minimum the foreman's job demands.

But is it good enough? There is a standard exam for exactly this — Berkeley's Function Calling Leaderboard, which grades models on using tools correctly: not chatting about work, but actually doing it, step after step. The results draw a bright line through the foreman's job description:

• Single instructions: 87% correct. Hand the local brain one clear task — read this, file that, dispatch this job — and it performs nearly as well as anyone could ask.
• Long chains of dependent steps: about one in three fully correct for the local brain. Ask it to run an eight-step sequence where each step depends on the last, and errors compound until most long chains have a stumble somewhere in them. The rented pro-tier brains score roughly 44 to 55% on those same chains — better, though nobody is magical here; long autonomous sequences are simply where this technology is weakest, for everyone.

One-in-three is not a number you run a factory on — and here the design took a turn. The first version of this blueprint put the free local brain at the foreman's desk and kept a rented brain in reserve for hard days, mostly to keep the bill pretty. We reversed it. The foreman is the face of the factory: the owner talks with it all day, every day, and its core duty is exactly the thing the local brain is measurably worst at — carrying a long chain of dependent steps without dropping one. Saving $20 to $50 a month by staffing the front desk with an evidently weaker mind is false economy, so the senior gets the desk.

The arrangement, then: the foreman's default brain is a Sonnet-class model, rented through the Portal wallet — the $20 wallet covers ordinary months, and the realistic budget is $20 to $50 a month depending on how much conversation the factory does. The same wallet can also rent Opus-class thinking for the foreman's own hardest moments — drafting a genuinely tangled brief, say — a few dollars at a time. (It cannot feed the builders. That is a different arrangement, and it is the next section.)

Honest sizing, since every owner asks: the $22 of credit inside the $20 tier is sized for light-to-moderate foreman use. An ordinary month of conversation fits inside it. In a powerful week, though, the foreman alone can draw roughly $10 to $25 of thinking — an estimate, but the right order of magnitude — so a month of sustained heavy use pushes the brain budget toward the top of that $20-to-$50 range: a bigger wallet, not a different design. The reviewer's seat is unaffected either way, because the buckets are separate — Codex rides its own $20 plan and never competes with the foreman's talking. And if the wallet ever does run dry mid-conversation, the local understudy covers the gap automatically while it is topped up.

The local brain keeps two honest jobs. First, understudy: Hermes has a documented fallback chain, and ours points at the local model — if the rented brain ever fails mid-conversation, the foreman swaps to the local brain automatically and the conversation survives. Second, grunt engine: the local model powers bay three's bulk work, where its weaknesses don't matter and its price — zero — is exactly right.

Two disciplines survive from the first design, because they were never about money. The foreman's own errands stay short — dispatch whole jobs, never micromanage them — and the owner still approves the work ticket in plain words before big jobs start. And the field reports still earn their keep: local agents that print their tool calls as text instead of executing them because of one wrong setting, agents that silently "forget" the owner's message when their working memory overflows — every one of those failure modes has a known fix, and they are why the understudy gets configured carefully and smoke-tested after any change. A fallback nobody has tested is a decoration.

The builders' wages, and the rulebook twist

The builders burn the real compute, and there are two ways to pay them: flat monthly subscriptions (the plans sold to individual subscribers, $20 to $200 a month) or metered API billing, paying for every word read and written. At a realistic small-factory workload — about 120 builder-hours a month — the metered route for builder-class models lands around $325 a month. The flat route, if it is allowed, costs a fraction of that. Everything hinged on one question: allowed by whom, exactly?

The answer turned out to be written down, in the vendors' own words, and it has a twist.

In February 2026, Anthropic published the rule plainly: using a subscription login inside any other product, tool, or service is not permitted. Enforcement followed — from April 2026, subscription plans stopped covering third-party agent frameworks entirely. A whole ecosystem had been quietly running industrial workloads through consumer logins; that door is closed, and any design that depends on reopening it is built on sand. This matters directly to our factory: the foreman software offers a tempting button that logs in with a Claude subscription and spends it. That button is precisely what the rulebook forbids. We don't press it. (It is also why the foreman's brain can never be paid for out of a Claude subscription: no Claude plan may be spent inside the foreman, which is exactly why the Portal wallet exists in this design at all. OpenAI, it turns out, answers this same question the other way — and that answer becomes an option of its own after the bill.)

But the same vendors sell the builders themselves — and the builders come with their own front doors, built for exactly our use. Anthropic's documentation describes a one-year token, generated by its own tool, explicitly "for CI pipelines, scripts, or other environments where interactive browser login isn't available," which lets its builder run unattended on a server under the owner's own subscription. OpenAI's builder signs in with the owner's ChatGPT plan the same way — a documented, first-party feature of the product. Codex deserves its own footnote here: it is included in the ordinary $20 ChatGPT Plus plan, and signing its tool into the server is OpenAI's documented flow, not a workaround. Twenty dollars buys the factory its independent checker.

So the legal architecture of the factory is one sentence long: the foreman never holds the builders' passes; the builders carry their own. Hermes dispatches work by invoking the vendors' official tools, which authenticate themselves. The subscriptions are used by the products they were sold for, by the person who pays for them. That is not a loophole. It is the intended shape, and it survives audits because there is nothing to hide from one.

Inside bay one, the staffing mirrors the foreman's: Claude Code builds with its pro-tier model (Sonnet class) as the everyday workhorse and calls the genius (Opus class) up only for the hardest jobs. That is arithmetic, not snobbery — Opus hours are the pinch in the weekly allowance, as few as 15 to 35 a week on the $100 tier, and an all-genius diet does not fit any tier on the menu.

Which raises the obvious question: why not simplify — one vendor, one top-tier plan, the very best for everything? Three reasons. Price: two wages — $100 and $20 — come to $120, which undercuts the single top tier's $200 by $80 a month. Fit: even the top tier rations its genius hours, so "the best for everything" is a plan that runs dry mid-week. Independence: the reviewer must not be the builder — a second vendor's model checking the first vendor's work catches what a builder marking its own homework waves through. And as noted, full consolidation on the Claude side was never on the table anyway: the February rule means a Sonnet-brained foreman needs its own wallet no matter how the bays are paid. (The OpenAI side of the street turns out to have a door in it after all — that is the simpler option, after the bill.)

The subscriptions are not unlimited — both vendors run weekly allowances on top of shorter session windows, and Anthropic's are currently the subject of a consumer lawsuit alleging the delivered hours fall short of the advertised multiples. We sized the factory under the pessimistic version of the numbers and it still fits: the primary builder's plan (the $100 tier) covers its share of a 120-hour month several times over on standard models, with metered billing available as overflow, and the second builder starts on a $20 plan with a defined upgrade trigger. Two vendors also means two independent allowances — when one bay's week runs dry, the other vendor's doesn't.

One last wallet note: the Portal wallet rents brains for the foreman alone. It cannot feed Claude Code, and we would not want it to — for heavy building, a flat plan beats metered genius pricing by a wide margin. Every brain in the building is paid for in the way its seller intended; that sentence is the factory's whole legal strategy.

The bill

Here is the whole factory, monthly, at October 2026 prices (€1 = $1.12):

The same factory with every brain rented by the meter — no subscriptions, frontier models thinking at full price around the clock — comes to roughly $719 a month. The design above is not a compromise version of that factory; on the measured evidence, its builders are identical and its quality gates are identical. What changes is how each brain is paid for, and who staffs which desk. (One-time costs: a €39 server setup fee. Everything runs under one deployment panel, and the whole factory can be rebuilt from its own blueprint in an afternoon — the building is rented, but the factory is ours.)

The hardware ladder

The bill above prices the building at €84 — the 24-core tier, the largest on this menu. The building is itself a choice, so here is the whole menu: four rented servers from the same provider, prices checked 25 October 2026 (prices move — several tiers were raised in April 2026 — and stock comes and goes; treat every figure as check-at-checkout).

And the same three factory wirings from this piece, totalled on each building — the brains cost the same on any of them (the starter adds $100 of AI, the recommended design $140–170, the simpler wiring $200):

The €84 column is the bill you have already read — the ladder widens the menu without moving a single published number. (The setup fee belongs to the server, not the wiring: €39 on three of the four tiers, €99 on the 14-core tier, charged once and never monthly.)

Which building do we pick? The sweet spot is the ~€50 14-core tier. This box does not run one job — it runs several worlds at once: the agent factory, the owner's own desktop workstation, the resident local brain, with room for more. Cores are what let everything breathe at the same time. The 8-core tier clears the memory wall — all four carry the same 64 GB — but leaves too little parallel headroom once multiple systems and operating environments share the box; for serious multi-workload use it is the false economy of the row. The 24-core stays the growth pick, not the requirement.

Climbing later is a bounded, known cost, not a leap: the provider's documented upgrade path is a support request, the new box running in parallel while the data copies across, then the old one cancelled — one month of double rent, the new setup fee, and an afternoon of copying. Two honest caveats: these cheap tiers live in Europe only, and their stock comes and goes. And one more: the local brain's speeds quoted earlier were estimated on the 24-core machine — on the 14-core tier the local brain runs slower, which slows the grunt work and the understudy, and touches the rented foreman not at all.

The sweet-spot server's own class gets the full pricing treatment in our companion study: The 16-Core Class — where the mainstream server class is cheapest, and where it is best value.

The simpler option: two subscriptions

Everything above is the design we recommend. There is a second way to wire the same factory — simpler, slightly dearer — and it exists because OpenAI answered the subscription question the opposite way from Anthropic.

In September 2026, OpenAI launched "Sign in with ChatGPT": subscribers can spend their plan's allowance inside named third-party tools, and Hermes is on the launch list. Hermes documents the arrangement itself — sign the foreman in with a ChatGPT account and it thinks with OpenAI's Codex-family GPT brains, paid out of the plan instead of a wallet. Anthropic's February rule still forbids exactly this for Claude logins. OpenAI built a front door for it instead.

That door makes this variant possible:

• One ChatGPT Pro subscription ($100 a month) does double duty. It signs the foreman in — so the foreman's brain is a GPT-class model — and it powers bay two, the Codex builder and standing reviewer, exactly as in the main design.
• Claude Code is unchanged: the $100 Max plan, the pro-tier workhorse doing the everyday building, the genius called up only for the hardest jobs.
• The building is unchanged ($94), and the free local brain keeps its two jobs: bay three's grunt engine and the foreman's emergency understudy.
• There is no Portal wallet. Nothing metered, nothing to top up — one less account on the books.

Total: ≈ $294 a month — roughly $30 to $60 more than the main design's range — plus the same one-time €39 (≈ $44) server setup.

Why would an owner choose it? Simplicity, and headroom. Two subscriptions are easier to hold in one head than two subscriptions plus a wallet, and Pro's limits are far higher than Plus's — one shared OpenAI allowance has real room in it at a single owner's pace. The programme also lets the owner cap how much of the pool the foreman may drink (each app can be limited to between 10% and 100% of the allowance), a safety valve that guarantees the talking can never quietly eat the builder's whole week.

The trade-offs, stated plainly. The foreman and the Codex builder now drink from one shared pool: a truly heavy week can still pinch, in a way the main design's separate buckets never can — two buckets cannot starve each other. The foreman's brain changes flag, from Sonnet class to GPT class; on the evidence available that is a wash — Nous's own guidance ranks the Sonnet class the best general-purpose agent brain and OpenAI's top GPT the best heavy reasoner; same league, different strengths. And Portal's shelf of 300-plus brains, with its bundled tool gateway, is given up.

We still recommend the main design: it is cheaper, and its separate buckets are structurally safer. But an owner who values simplicity over the last $30 to $60 is not making a mistake here. It is the same factory with fewer moving parts.

The starter option: one subscription, one vendor

There is a third way to wire the factory, and it is the cheapest complete version of it: skip the second vendor altogether.

The September door makes it possible. One ChatGPT Pro subscription ($100 a month) takes on every paid job in the building:

• The foreman signs in with ChatGPT and thinks with Codex-family GPT brains — the same arrangement as the simpler option.
• Codex is the only builder. There is no Claude Code and no Claude subscription at all; the strongest measured builder in its class is benched, and Codex builds everything.
• The free local brain picks up a third job: first-pass checking. Alongside bay three's grunt work and understudy duty, it reads finished work in front of the test gate — catching build breaks, obvious bugs and missing edge cases, and drafting extra tests where coverage looks thin.
• There is no Portal wallet and no second subscription. One vendor, one bill.

Total: ≈ $194 a month — the building ($94) plus the single subscription ($100) — plus the one-time €39 (≈ $44) server setup. This is the starter rung: the way to launch the factory for the least money and prove the machine end to end — conversation, briefs, dispatch, gated shipping. Nothing about it is a dead end. The upgrade path is pure addition: adding the Claude plan later is one subscription and one bay, no rebuild. And the factory itself reports when to climb — a week where the shared pool pinches, or a rising rate of jobs coming back for second passes, is the signal.

The trade-offs, stated plainly, because this rung carries more of them:

One pool for everything. The foreman's talking and all of the building drink from the same OpenAI allowance. How fast it drains depends steeply on which model does the work — the flagship model costs roughly a hundred times the cheapest tier per word — so model discipline is part of the design: mid-tier brains for routine building, the flagship reserved. The verified shape of the pool: the $100 Pro tier is five times the Plus allowance, capped weekly with no shorter window, and OpenAI publishes no raw number for it. Heavy users have drained the $100 plan in hours on the flagship model, and in October 2026 OpenAI halved the $200 plan's allowance — allowances are real, and they move. Overflow, at least, is not a hard wall: past the allowance, extra credits simply bill at plain API prices.

The independent checker is gone — so checking becomes a ladder. In the main design, a second vendor's model reviews the primary builder's work. Here nobody independent is on staff, and the honest response is not to pretend otherwise — it is to stack the checks that remain, cheapest first. The ladder, as the starter runs it:

1. Instruments, not brains. Linters, type checkers, security and secret scanners. Deterministic, free, local — and incapable of being talked out of an opinion, because they have none.
2. The hard test gate. Nothing merges unless the full test suite is green. The backbone, here as everywhere.
3. The local brain's first pass, given a checklist instead of an opinion. It reads finished work against a written list — spec compliance, edge cases, error handling — and carries one more duty: write tests for the new code and run them. A test it writes that fails is a finding. That turns the local brain's weak judgement into mechanical work, which is the work it is measurably good at — breaks, obvious bugs, missing edge cases, thin coverage.
4. A fresh Codex session, briefed as the enemy. A new session with no memory of building the thing, told plainly: you did not write this; your only job is to find what is wrong. It is the same family as the builder, so it is not true independence — but a fresh, hostile pass catches a real share of what the building session waves through, and reviews are cheap next to builds.
5. Flagship review for the risky diffs only. Money, logins, deploys: those changes get read by the top-tier model. Reviewing costs a fraction of building, so frontier-grade judgement can be rented per-diff, through the top door, exactly where the stakes are.
6. The optional review wallet. A small pay-per-use budget at the rival vendor — an Anthropic API key, roughly $10 to $20 a month at review volumes — spent only on reviewing the highest-stakes changes. It buys back genuine cross-vendor independence for pennies, precisely because reviews are small next to builds. It slightly breaks this rung's one-subscription purity, deliberately and cheaply, and it is off by default: with the wallet switched on, the starter runs roughly $205 to $215 a month instead of $194 (the one-time €39 server setup rides on top of either figure).

The first three layers are not special to this rung — instruments, gate and local first pass are the standard quality machinery in every configuration in this piece. The ladder matters most here, where no second vendor is on staff to lean on. And the honest residue, even with the ladder climbed: no frontier rival reads every line in the starter. Layers five and six exist so that the lines that matter most get read by one — because a "reviewed" stamp from a weak reviewer is worse than an honest gap, and the gap stays written on the label.

The step down is real but narrow. On everyday work, expect no visible difference — the test gate does not care which vendor produced the passing work. The gap shows on the hardest five percent of jobs, the tangled builds where the Claude pair measured strongest, and in a slightly higher rate of jobs needing a second pass.

One vendor is one point of failure. An OpenAI outage, a model regression, or an allowance cut reaches the foreman, the builder and the checker in the same hour. The two-vendor wirings never share that fate.

So the ladder reads: ≈ $194 to start and prove it, ≈ $235–265 for the design we recommend, ≈ $294 for the simplest wiring — and every rung pays the same one-time €39 (≈ $44) server setup: once, per server, never monthly. The starter is not the factory we would run a business on forever. It is the cheapest honest way to find out whether a software factory is worth running at all — and every dollar of it carries forward when the answer is yes.

What we are not claiming

Honesty is a feature, so here is what this study did not establish. Nobody has published a benchmark of this exact server running this exact foreman — our local speeds are careful estimates from bandwidth arithmetic and neighbouring measurements, and the first job after the server lands is to measure them for real; they now bound how fast bay three chews bulk work and how the fallback feels, rather than the daily conversation. The subscription allowances are contested numbers; we budgeted under the unflattering version, but they can change with a terms update, and if they ever close the builders' front doors, bay one moves to metered billing and the factory's bill roughly triples — painful, not fatal. And the foreman pattern itself is young: the failure reports we learned from come mostly from a sibling system, because the public record of this exact one is still being written. By us, among others.

The verdict

A software factory that takes orders in plain English is no longer a research project; it is a shopping list, a rulebook reading, and one design discipline — narrow the talker's job, gate the builders' work with machines, and let every brain be paid for in the way its seller intended. The building rents for €84 at the growth tier; the sweet spot the factory launches on is the ~€50 14-core tier in the hardware ladder above, where the recommended design totals ≈ $196–226 a month. The foreman thinks with a rented senior brain on a $20-to-$50 wallet, with a free local understudy standing by for failures and grunt work. The builders, on their own flat wages, out-produce their metered price three times over.

The gap between a plainly spoken want — this thing should do that thing — and working software turns out not to be a language problem anymore. It is a factory-design problem. And factory design, it turns out, is a solved genre — you just have to read the rulebook before you wire the machines.