The Conversational Software Factory

Question: What is the best software-production pipeline for naive conversational input — a non-technical owner talks plainly, working software comes out — on the cheapest reasonable budget, built around a €84/mo Hetzner dedicated server (EX101 class: Intel i9-13900, 24 cores, 64 GB RAM, 2× NVMe, no GPU)?

Candidate architecture under test: OpenWebUI (the owner's window) → Hermes (Nous Research's agent, acting as foreman: translates plain talk into technical briefs, delegates, keeps the builders in sync with the owner's intent, reports back in plain words) → production engines (Claude Code headless as primary builder, Codex CLI as second builder/reviewer, OpenHands for parallel and local-model work), every job isolated in Docker + a git worktree, with automated test gates before any work is accepted.

Researched: 24–25 October 2026. Sources cited inline; retrieval dates are October 2026 unless noted. Companion pieces: our earlier studies on agent runtimes (agentic-coding-powerhouse-runtime-choice-20261025-0522) and local inference on CPU-only servers (local-llm-efficiency-and-gpu-servers-20261025-0517), whose verified findings are reused and marked as such.

Revision (25 Oct 2026): the research below was first read as recommending a local-model foreman with a cloud second brain. On review we reversed that call: the evidence in §1 shows the local model's weakness sits exactly on the foreman's core duty (long dependent tool chains, ~33–38% vs ~44–55% for rented pro-tier models), and the foreman is the owner's daily point of contact. The specified design (§§4, 6, 7) therefore puts a rented Sonnet-class brain in the foreman's seat by default, paid through the Nous Portal wallet, and demotes the local model to fallback and grunt duty. The §1 evidence is unchanged — it is what forced the reversal.

Second revision (25 Oct 2026): this study originally framed subscription logins as spendable only inside the vendors' own tools. That remains true — and absolute — for Anthropic (§2.2). OpenAI has since moved the other way: on 29 September 2026 it launched "Sign in with ChatGPT" plan usage for third-party tools, with Hermes Agent as a named launch partner — Plus and Pro subscribers may spend their plan allowance inside participating tools, with each app's share cappable between 10% and 100% of the shared allowance (OpenAI DevDay announcement coverage — The New Stack, via URALLNEWS/Bitcomme; TokenPost announcement summary, tokenpost.com). Nous's provider documentation likewise lists a first-class "ChatGPT or Codex Subscription" provider for Hermes itself — device-code sign-in, Codex-family models (Hermes docs, LLM and Model Providers, hermes-agent.nousresearch.com). §2's framing and §2.5's closing claim have been corrected accordingly, and §6.1 records the alternative configuration this opens up: one ChatGPT Pro subscription doing double duty as foreman brain and Codex bay. The recommended design is unchanged — separate buckets still cannot starve each other, and that is still worth a wallet.

Third revision (25 Oct 2026): a budget configuration joins the two recorded in §6 and §6.1. §6.2 specifies the GPT-only starter — one ChatGPT Pro subscription signing in the foreman and powering the sole builder bay, the local model taking first-pass checking, no Claude subscription and no Portal wallet, ≈ $194/mo — so the ladder reads ≈ $194 / ≈ $235–265 / ≈ $294. No recommendation changes: the starter is the on-ramp, and its trade-offs (one shared pool, a labelled checking gap, one-vendor exposure) are stated where it is specified.

Fourth revision (25 Oct 2026): §6.2's checking passage is expanded into the full review ladder the one-vendor factory actually runs — instruments, hard test gate, local first pass with a written checklist and a test-writing duty, fresh-session adversarial Codex review, flagship-model review for risky diffs — plus the optional review wallet: a small pay-per-use Anthropic API budget (≈ $10–20/mo at review volumes, off by default) spent only on reviewing the highest-stakes changes, which puts the starter at roughly $205–215/mo with the wallet on. The base total and the ladder's headline numbers are unchanged.

Fifth revision (25 Oct 2026): the factory gains a hardware dimension. §6.3 puts the server under the same scrutiny as the subscriptions: four Hetzner tiers (AX42, EX44, EX63, EX101) specced and priced, cross-tabulated with all three configurations (§§6, 6.1, 6.2), and the sweet-spot ruling recorded — the ~€50 14-core tier is the baseline pick for a box that runs several worlds at once; the 24-core tier of §6's original table stays the growth pick, not the requirement. Prices checked 25 Oct 2026; Hetzner adjusts prices and stock varies, and the cheap tiers are Europe-only. One honesty note the ladder forces: §1.4's local-model speed estimates were made on the 24-core DDR5 machine — on the DDR4 14-core tier the local model runs slower, an estimate labelled as such in §6.3, which costs the grunt and fallback jobs speed and the rented foreman nothing.

Names, in plain English: Hermes is the foreman software — the body: it listens, remembers, and dispatches. A brain is a language model rented separately and plugged into it. Nous (Nous Research) is the company that makes Hermes. Portal is Nous's prepaid wallet — $20/mo buys $22 of thinking across 300+ brains. Sonnet is Anthropic's pro-tier brain (the senior professional); Opus is Anthropic's top tier (the expensive genius).

1. Can the foreman run on a free local brain? (The all-local question)

1.1 What the job actually demands

Hermes-the-foreman does four things: (1) hold a plain-language conversation with the owner; (2) translate intent into a precise technical brief; (3) operate tools — dispatch jobs to engines, read results, run checks, manage files and sessions; (4) report back in plain words. It does not write the production code. The naive hope is that (1)–(4) are "just talking and organising," so a free local model should suffice. The evidence says the job is really two jobs with very different difficulty:

• Talking, translating, summarising — single-shot language work. Local models are good at this.
• Tool operation over a long shift — multi-turn function calling: sequences of dependent tool calls where state must be carried correctly across many steps. This is where small local models fall off a cliff, and it is measured, not vibes.

1.2 The benchmark evidence (BFCL / τ-bench)

Berkeley's Function Calling Leaderboard (BFCL) is the standard tool-use exam. For Qwen3-30B-A3B-Instruct-2507 — the strongest realistic local candidate for this server (see §1.4) — independent evaluations run under the official BFCL protocol report (arXiv 2610.23148, appendix L, BFCL v3, temperature 0.7):

A second independent study (TDScaling, arXiv 2602.03219) tells the same story with different numbers: BFCL multi-turn 33.2% for Qwen3-30B-A3B-Instruct, and τ-bench agentic scores of 30.5 (Airline), 53.3 (Retail), 21.9 (Telecom). A third (AgenticQwen, arXiv 2604.21590) puts its BFCL-V4 multi-turn average at 36.2%. For calibration, the frontier models are better but not magical on the same multi-turn tests: Claude Sonnet 4 scores 54.8%, GPT-5 43.8% (arXiv 2602.03219, Table 1). Single-call function calling, by contrast, is a solved problem at this size: ~83–87% across BFCL and OrchestrationBench (ICLR 2026) measurements.

Reading of the evidence: per-call, the local foreman is right roughly 6 times out of 7 on easy calls and only ~1 time in 3 across a long dependent chain. Errors compound: a dispatch sequence of eight dependent steps at per-step reliability implied by these scores succeeds end-to-end only about a third of the time without correction. Hermes's own error handling (retries, self-correction, checkpointing) recovers some of this, but the direction is unambiguous — the longer and more autonomous the local foreman's own tool chains, the more often the factory floor stumbles for reasons that have nothing to do with the builders.

1.3 What Hermes itself requires and recommends

From Nous Research's own documentation (hermes-agent.nousresearch.com, retrieved Oct 2026):

• Hard floor: 64,000 tokens of context, enforced at startup — "Models with smaller windows cannot maintain enough working memory for multi-step tool-calling workflows and will be rejected at startup." The full tool registry, system prompt, skills and conversation state ride in every request.
• Local inference is a supported, documented path: Ollama or llama.cpp as a custom OpenAI-compatible endpoint (--jinja required on llama-server for tool calling; OLLAMA_CONTEXT_LENGTH=64000 required because Ollama defaults to as little as 4,096 tokens by VRAM tier — and on a CPU-only box there is no VRAM tier to save you).
• Hermes's docs steer local users toward tool-calling-trained models; third-party setup guides summarising the official provider docs identify only a small set of local models with reliable tool calling, and warn that chat-only models "can converse… but agentic features like file editing, command execution, and web browsing will not work" (hermes-tutorials.dev, 2026).
• No complexity routing exists (established in our runtime study via Nous's own tracker: a maintainer-closed issue confirms the main model is pinned per profile by design). The documented escape valves are: a fallback_providers: chain in config.yaml that swaps model/provider mid-session, on failure (rate limit, server error, auth failure — one-shot per session, conversation preserved; Hermes docs, "Fallback Providers"); per-task auxiliary model overrides (compression, vision, titles, approval checks can each be pointed at a different model); a separate delegation model for subagents; and manual /model switching.

1.4 Why Qwen3-30B-A3B is the only sane local candidate on this box

Generation on CPU is memory-bandwidth-bound. The i9-13900's DDR5-5600 ceiling is 89.6 GB/s theoretical. A dense 31B model at Q4 reads ~19 GB of weights per token → ~3–5 tok/s in practice: unusable for conversation. Qwen3-30B-A3B is a mixture-of-experts model that activates only ~3.3B parameters per token (~1.9 GB of active weights), which is why it — uniquely in its class — reaches an estimated 15–30 tok/s at moderate context on this exact server class, falling toward 8–18 tok/s as context fills toward 64K (our local-inference study, anchored on published bandwidth arithmetic and community benchmarks; treat as ±2× estimates, not measurements of this exact box). Weights at Q4_K_M ≈ 18.6 GB; total footprint with 64K KV cache ≈ 21.8 GB (q8_0 KV) to 24.9 GB (f16 KV) — comfortably inside 64 GB alongside the rest of the factory, provided llama.cpp's server (not Ollama) is used for its prefix caching, which makes the foreman's long stable system prompt nearly free to re-read each turn.

1.5 Community field reports

No large public corpus exists yet of Hermes specifically running a manager workload on a local model (a gap we flag in §8), but the sibling ecosystem — OpenClaw is architecturally the same pattern (agent harness + tool registry + local OpenAI-compatible endpoint) — has produced a consistent failure taxonomy from production write-ups (clawmage.ai's OpenClaw/Ollama production-patterns series; dev.to post-mortems; Edgible's deployment guides, all retrieved Oct 2026):

1. Transport traps beat model quality as the #1 cause of "my local agent does nothing." Ollama's OpenAI-compatible /v1 path silently drops/breaks tool calls for agent harnesses (the agent prints raw JSON as chat text instead of executing); the fix is the native API surface. The llama.cpp equivalent for our stack: tool calling requires the --jinja flag, without which the model likewise prints JSON as text (Hermes local-models guides). Lesson: after any stack change, smoke-test a real tool call, not a chat reply.
2. Context blowout, not stupidity, is the classic mid-task failure. An agent turn carries system prompt + tool schemas + skills + memory — tens of thousands of tokens before the user says a word. If the served context is smaller than the harness believes, truncation silently eats the end of the prompt — where the user's actual message lives. Symptoms: the agent ignores instructions, "forgets" its tools, drifts off-topic. A direct curl chat test passes; the real agent turn falls over (dev.to, "My fresh OpenClaw install kept failing. The model wasn't the problem."). This is precisely why Hermes hard-rejects <64K contexts, and why the local server must be configured with an honest, fixed 64K window.
3. Format fragility on complex sequences. Models that chat fine emit almost-correct, unparseable tool calls when sequences get complex; small models (7B class) "drop tool calls" outright on multi-step turns. Guides converge on ~27–32B tool-trained models as the practical local floor for agent work — exactly the class §1.4 selects.
4. Cold starts. Runtimes unload idle models (Ollama's default keep-alive is 5 minutes); reloading ~19 GB costs tens of seconds and reads as a hang. On a 64 GB box the fix is free: keep the foreman's model permanently resident.
5. The hybrid consensus. Practitioner guides land in the same place: local for the cheap, frequent, private beats; a cheap cloud model (a few dollars a month at Flash/Luna-class prices) where reliability matters — "Most teams settle on hybrid" (betterclaw.io). Our final design sits inside that consensus with the emphasis the BFCL numbers dictate: the rented brain takes the conversation and coordination (the reliability-critical traffic), and the local model takes the bulk work and failure recovery (§4). The closest published twin of our full architecture — a DevOps engineer running Hermes as orchestrator delegating real work to the Claude Code CLI, with Hermes doing QA, git and phone reporting (dev.to, "How I Built a 24/7 AI DevOps Coding Agent for About CAD 200") — likewise uses a cloud model as the orchestrator brain rather than a local one, and reports the pattern works around the clock. That is evidence for the architecture; our §1 analysis says the foreman's seat specifically belongs to the rented brain.

1.6 Conclusion on the all-local foreman

The local model can hold the conversation, take dictation, translate ordinary requests into briefs, dispatch simple jobs and narrate results — the factory's front-office work — at zero marginal cost. What it cannot do is match the rented pro-tier brains at the foreman's core duty: multi-turn chains land at ~33–38% versus ~44–55% for the frontier class (§1.2), and the gap widens precisely when a job gets tangled. We therefore do not seat the local model as foreman by default. The design answer (§4) is a rented Sonnet-class default brain, paid through a prepaid wallet, with the local model kept on staff for the two jobs where it is genuinely the right tool: automatic fallback when the rented brain fails, and the grunt tier (Bay 3 bulk work), where cost-per-word is zero and its weaknesses do not matter.

2. The biggest budget lever: how the engines are billed

The builders — not the foreman — burn the serious tokens. There are two ways to pay for each builder: a flat consumer subscription, or metered API billing. Whether the subscription route is legitimate on a headless server turns out to be sharply different for "the vendor's own CLI" versus "a third-party harness holding the vendor's login." This distinction is the whole ballgame, and as of October 2026 it is documented in the vendors' own words — words that now point in opposite directions: Anthropic closed the third-party-harness door for subscription logins (§2.2), while OpenAI opened a sanctioned one for its own plans (§2.3).

2.1 Claude Code on a Claude subscription — YES, through Anthropic's own front door

• Claude Code is included in the Pro ($20/mo), Max 5x ($100/mo) and Max 20x ($200/mo) plans; there is no separate Claude Code plan (Anthropic pricing pages; multiple Oct-2026 trackers agree).
• Anthropic documents the headless server path itself: claude setup-token "For CI pipelines, scripts, or other environments where interactive browser login isn't available, generate a one-year OAuth token" — set as CLAUDE_CODE_OAUTH_TOKEN, it "authenticates with your Claude subscription and requires a Pro, Max, Team, or Enterprise plan" (Claude Code docs, Authentication, updated 2026-10-22, code.claude.com/docs/en/iam). A server-resident claude -p driven by Hermes's terminal tool is therefore running Anthropic's own binary, under Anthropic's own documented CI mechanism. That is the sanctioned pattern — Anthropic's own staff phrase it as: piping work into the official claude binary under your own token is inside the lines; a third-party program holding the token and calling the API itself is not (see §2.2).
• The limits are real and two-layered: a 5-hour session window plus a weekly cap across all models. Anthropic's own July-2025 subscriber emails put numbers on them (as quoted in the June 2026 class-action filing, Kahn v. Anthropic, N.D. Cal. 3:26-cv-05763): Pro ≈ 40–80 Sonnet-hours/week; Max 5x ≈ 140–280 Sonnet-hours + 15–35 Opus-hours/week; Max 20x ≈ 240–480 Sonnet-hours + 24–40 Opus-hours/week. The same filing alleges effective delivery is closer to ~3.5× (5x) and ~6–8× (20x) Pro rather than the advertised multiples — unproven allegations, but consistent with heavy users' reports that large-context Opus work drains the weekly allowance far faster than the Sonnet "hours" headline suggests. On 6 May 2026 Anthropic doubled Claude Code's 5-hour rate limits for paid plans and removed the peak-hours reduction (secondary trackers; treat as reported).
• At our workload: ~120 engine-hours/month ≈ 28 hours/week shared across both builders. If Claude Code carries ~60–75% of that (~17–21 h/wk) on Sonnet-class models, Max 5x's nominal envelope covers it several times over; even the lawsuit's pessimistic arithmetic leaves headroom at Sonnet. Opus-heavy weeks are the pinch point (15–35 Opus-hours/wk at Max 5x). Overflow past plan limits can be enabled as pay-as-you-go "usage credits" at API rates.
• Bay 1's seat, stated plainly: Claude Code builds with the Sonnet-class model as its everyday workhorse and calls Opus up for the hardest jobs only. An Opus-for-everything diet is not on the menu at any tier — the Opus-hours allowance (15–35/wk at Max 5x) is the binding constraint, and the Sonnet envelope is where the plan's headroom lives.

2.2 The trap: Hermes must not hold the Claude login itself

Hermes's own provider menu offers an "Anthropic (Claude Max + extra usage credits via OAuth)" route. The button existing is not the same as the route being permitted:

• Anthropic's Legal & Compliance page (updated 19 Feb 2026): "Using OAuth tokens obtained through Claude Free, Pro, or Max accounts in any other product, tool, or service — including the Agent SDK — is not permitted and constitutes a violation of the Consumer Terms of Service."
• Enforcement followed: server-side blocks from 9 Jan 2026 (403s: credentials "authorized only for use with Claude Code"), and from 4 Apr 2026 subscriptions stopped covering third-party tools (OpenClaw named explicitly by Anthropic's Head of Claude Code); third-party harness traffic with a Claude login is billed against metered extra usage credits instead of the plan.
• So: Hermes's brain must never be a Claude subscription login, and Hermes must not impersonate Claude Code. Claude enters this factory in exactly one way — as the official claude CLI, invoked as a subprocess, authenticating itself. (An experimental community/official plugin pattern, "Claude Subscription DirectSDK," does precisely this — drives the official CLI and never reads its credential files; vincentvandeth.nl, Oct 2026.)

2.3 Codex on a ChatGPT plan — YES, same shape

• Codex — OpenAI's own coding agent, CLI included — is included in every ChatGPT plan. Signing the Codex CLI in with a ChatGPT account is OpenAI's documented first-party flow; headless codex exec is a product feature, not a workaround.
• Since April 2026 Codex usage is credit-metered inside the plans ("credits are tokens in a costume" — 1 credit = $0.04 of API value; OpenAI's published per-model rates). OpenAI's pricing page (as retrieved Oct 2026 via multiple trackers) gives Plus ($20/mo) local-message estimates per 5-hour window: GPT-6.1 Sol 15–160, GPT-6 Sol 15–150, GPT-6 Luna 350–3,000, GPT-6 Astra 5–45; weekly limits may also apply; extra credits can be purchased to continue past the allowance (a typical GPT-6 Sol task ≈ 2–15 credits). Pro tiers ($100/$200/$500) currently have no 5-hour limit; a weekly allowance applies, and new Pro $200 subscriptions carry a reduced allowance (≈ half the previous dollar-in-API-spend value, per OpenAI's Codex lead, 29 Sep 2026).
• API fallback pricing for the same models: GPT-6.1 Sol $2 in / $10 out per M tokens — the same class as Claude Sonnet API pricing.
• At our workload (Codex carrying ~25–40% of ~120 engine-hours/mo as reviewer/second builder): Plus is the optimistic tier — fine while tasks are Sol/Luna-sized and bursty; sustained daily building will eat purchased credits. Pro $100 is the no-thinking tier. Start on Plus, watch the usage page, upgrade on evidence.
• The harness-side door (the basis of §6.1's variant). Hermes ships a first-class "ChatGPT or Codex Subscription" provider: sign Hermes itself in with a ChatGPT account (device-code flow) and the foreman thinks with Codex-family GPT models drawn on the plan (Hermes docs, LLM and Model Providers). On 29 Sep 2026 OpenAI formalised the arrangement as a programme — "Sign in with ChatGPT" plan usage for third-party tools, Hermes Agent a named launch partner: eligible usage in a participating tool counts against the subscriber's ChatGPT plan, and each app's share can be capped between 10% and 100% of the overall allowance (OpenAI DevDay announcement coverage — The New Stack via URALLNEWS/Bitcomme; TokenPost summary). Note what this does not do: it does not generalise to Anthropic, whose §2.2 rule stands untouched. The two vendors have answered the same question in opposite directions — which is why the alternative configuration in §6.1 is an OpenAI-side variant, not a universal one.

2.4 The foreman's brain, priced

2.5 Why two builder subscriptions, not one top tier

The obvious simplification — drop Codex, put everything on the single top Claude tier (Max 20x, $200/mo) — loses on three counts. Price: the two wages (Max 5x $100 + ChatGPT Plus $20 = $120) undercut the one top tier by $80/mo. Fit: even Max 20x rations Opus (24–40 Opus-hours/wk), so an all-Opus diet runs dry mid-week at any tier; the split design matches models to jobs instead of fighting the allowance shape. Independence: Codex's seat is independent checker — a second vendor's model reviewing Bay 1's diffs catches classes of error that a builder reviewing its own work waves through (§3, §5). And consolidation was never fully available in any case: §2.2's rule means no Claude subscription may be spent inside Hermes, so a Sonnet-brained foreman needs its own Portal wallet regardless of how the bays are paid. OpenAI's answer is the mirror image (§2.3) — and §6.1 turns it into an alternative configuration rather than the recommendation, because a shared allowance pool is a weaker structure than two buckets that cannot starve each other.

3. Does this factory already exist in the wild? (Workflows & deployment reality)

Yes — every joint in the candidate architecture is a documented, travelled path, which matters more for a budget build than any benchmark:

• Front office → foreman is a first-party integration. Open WebUI's own documentation carries a "Hermes Agent" page: Hermes exposes an OpenAI-compatible API server (enable API_SERVER_ENABLED=true, set API_SERVER_KEY, port 8642), Open WebUI connects as an ordinary OpenAI connection, tool activity streams inline into the chat (~10-minute setup, per Open WebUI's docs; Hermes docs, "API Server"). The owner talks to "Hermes" in a normal chat window; no custom UI code exists anywhere in this design.
• Foreman → builders is Hermes's bundled pattern, not a hack. Upstream Hermes ships skills for the major coding CLIs (skills/autonomous-ai-agents/ — claude-code, codex, opencode): the skill instructs Hermes which CLI commands to run via its terminal tool and how to supervise them with its process tool, in a terminal backend that can be a Docker container, an SSH host, or a sandbox. Community plugins productise the same move (e.g. Oh My Hermes' ulw-maestro: "Runs a delegated task on Claude Code or Codex — prompt composed from the CLI's own installed skills, spawned live"). Crucially, in this pattern the engines authenticate themselves — Hermes holds no Claude or OpenAI credentials, which is exactly what keeps §2's terms analysis clean.
• The supervisor pattern solves a real disease. A published operator case study (Faizan Javed, Oct 2026) describes the motivation precisely: long-lived Claude Code sessions suffer context decay — days of accumulated history get compacted and the builder forgets architectural decisions. Moving durable memory up into Hermes (persistent supervisor) and giving builders fresh, bounded contexts per job is the community-discovered fix, and it is this design's shape.
• Deployment is one-click where it matters. Dokploy (the settled host platform for this programme) publishes an official Hermes template (v2026.6.19; Create Service → Template → Hermes — domains, env vars, volumes configured), within a 585+ template library; Open WebUI and the llama.cpp server run as ordinary Compose services under the same panel. The whole factory is therefore "a Dokploy project," rebuildable from templates + this blueprint.
• The shipping dock already exists. The programme's website pipeline (GitLab push → validate → deploy to Cloudflare Pages) is built and waiting only on an account-verification step; product repos follow the same GitLab discipline. The factory ships through the same dock it builds.

4. The foreman's brain design (rented default, local understudy)

Because Hermes has no complexity router (§1.3), brain assignment is assembled from the parts that do exist. The design that falls out of the documentation — and out of the §1 evidence, which is why the rented brain, not the local one, holds the default seat:

1. Default (rented): foreman on a Sonnet-class model via the Nous Portal wallet — conversation, brief drafting, dispatch, supervision, reporting. The wallet is Portal Plus ($20/mo, $22 of credits); the realistic budget is $20–50/mo depending on chat volume. Rationale: the foreman is the owner's daily point of contact, and its core duty — long dependent tool chains — is exactly where the local model scores ~33–38% against the rented class's ~44–55% (§1.2). Staffing the desk with the evidently weaker brain to save the price of the wallet is false economy.
2. Failure fallback (automatic): fallback_providers: chain — Portal model → local Qwen3-30B-A3B endpoint. Documented behaviour: triggers on rate limits, server errors, auth failures; swaps mid-session without losing the conversation; one-shot per session. The local model is the understudy: if the rented brain falls over, the factory keeps talking.
3. Hard-moment escalation (process, not machinery): the foreman's standing instructions (its SOUL/skill layer) define escalation triggers — multi-product scope; anything touching production data, money, or deployment; requirements still ambiguous after one clarification round; a brief whose own checklist fails. On trigger, Hermes re-drafts the brief with an Opus-class model rented from the same Portal wallet and presents the brief itself in Open WebUI for the owner's approval before dispatch. The owner approves words, not code — which is the entire point of the naive-input design. Note the wallet's limit: Portal rents brains for the foreman only; it cannot feed Claude Code, whose bay keeps its own subscription (§2.5).
4. The local model's standing jobs: besides fallback duty (item 2), Qwen3-30B-A3B is the grunt engine for Bay 3 — OpenHands bulk and parallel work, where zero cost-per-word beats chain reliability — plus bursty background chores (compression, titles); summarisation is its strength. Model pinned resident on the server; nothing quality-critical rides on it.
5. Engine-side second opinions: Codex reviews Claude Code's diffs as a standing order; the test gate is mechanical and cannot be talked past. Two consecutive gate failures on one job bounce the job back to the owner with a plain-language incident note rather than a third silent retry.

Expected escalation volume beyond the default brain is small — a handful of hard briefs a week — which is why the one $20 credit wallet (Portal Plus carries $22 of credits) covers both the default seat and the Opus-class escalations at one-owner chat volumes, with headroom to ~$50/mo before the wallet size, not the design, needs revisiting.

5. Failure modes & mitigations

6. The full monthly bill

Workload assumption (stated so the table can be argued with): ~120 engine-hours/month of real building, split roughly ⅔ Claude Code / ⅓ Codex + OpenHands; a handful of hard briefs/week escalated. Currency: €1 = $1.12 (25 Oct 2026, Finnhub). Server price: Hetzner's own launch listing — EX101, €84/mo + €39 one-time setup (Hetzner press release; spec confirmed in Hetzner's hardware docs: i9-13900, 64 GB DDR5 ECC, 2× 1.92 TB NVMe Gen4). Re-confirm the order-page price at checkout; €84 is a launch price and secondary listings show the model trading higher.

Notes on the table: the Lean column works only with Sonnet discipline and tolerance for cap friction — Pro's weekly envelope is shared with the owner's personal Claude use. The Recommended column's headroom is deliberate: Max 5x's nominal weekly Sonnet envelope (140–280 h) covers the Claude share (~80 h/mo ≈ 18 h/wk) several times over even under the class action's pessimistic re-rating, and Codex Plus is the starting tier with a defined upgrade trigger. The foreman-brain line is a range because the Portal wallet is metered credit: the $20 Plus tier ($22 of credits) covers an ordinary month of one-owner conversation, and $50 is the honest top of the expected band before the wallet size — not the design — needs revisiting (§4). The All-API column uses our earlier verified token model (~1.5M tokens per agent-hour, cache-adjusted, Sonnet-class $2/$10) — it is what this same factory costs with no subscriptions and every brain at full metered price, i.e. roughly 3× the recommended build. One-time costs: €39 server setup (≈ $44). Electricity, bandwidth and the owner's own internet are inside the rent. One sizing estimate, labelled as such: in a powerful week the foreman alone can draw roughly $10–25 of Portal credit, so sustained heavy use lives at the top of the $20–50 band; the Codex seat's own $20 plan sits in a separate bucket and is unaffected, and the local fallback (§4) covers any gap automatically.

6.1 Alternative configuration — the simpler option: two subscriptions

For an owner who values simplicity over the last $30–60, the same factory wires up with two subscriptions and no wallet, using the door OpenAI opened in §2.3:

Why choose it: one less account; no metered balance to watch or top up; and Pro's limits are far above Plus's, so the single shared OpenAI allowance has real headroom at one-owner pace — with the programme's per-app cap (10–100% of the allowance) set on Hermes as a safety valve, so the foreman's conversation can never consume the builder's entire week.

The trade-offs, honestly: (1) One shared pool. The foreman and Bay 2 now draw on the same OpenAI allowance; a very heavy week can still pinch — where the recommended design's separate buckets (Portal for the foreman, Plus for Codex) structurally cannot starve each other. (2) The foreman's brain changes vendor. GPT-class instead of Sonnet-class. On the evidence available we score that a wash: Nous's own guidance ranks the Sonnet class the best general-purpose agentic model and GPT-5.5 Pro the best heavy reasoner — same league, different strengths (the ~44–55% frontier band of §1.2 contains both). (3) Portal's shelf is given up — 300+ models and the bundled tool gateway (search, browser, image, TTS) behind one OAuth. Nothing else changes: Claude Code's seat, the local model's two jobs, the QC gate and the blueprint mechanics are identical. The recommendation stands with the main table — this variant buys simplicity at ≈ $30–60/mo over the recommended range, and for some owners that is the right trade.

6.2 Alternative configuration — the starter option: one subscription, one vendor

The budget rung: one AI subscription in total, using the §2.3 door for everything it can reach and the local model for the rest:

Why choose it: it is the cheapest complete configuration of the factory — one vendor, one subscription, one bill — and the natural launch configuration: it proves the machine end to end (conversation, briefs, dispatch, gated shipping) at minimum spend. The upgrade path is pure addition: adding Max 5x later is one subscription and one bay, arriving at the §6 or §6.1 wiring with no rebuild. The signals to climb are observable in operation — a week where the shared pool pinches, or a rising rate of jobs needing second passes.

The trade-offs, honestly: (1) One shared allowance for everything. The foreman's conversation and the sole builder draw on the same Pro pool. Burn is steeply model-dependent — OpenAI's published credit rates put the flagship model at roughly 100× the cheapest tier per token (§2.3) — so model discipline is load-bearing in this variant. Verified colour on the pool's shape: Pro $100 carries 5× the Plus allowance, weekly cap only, and OpenAI publishes no raw weekly number (§8, item 4); heavy users have reported draining the $100 plan in a matter of hours on the flagship model, and OpenAI halved new Pro $200 allowances in October 2026 (§2.3) — allowances bind, and they move. Overflow is not a hard stop: extra credits bill at plain API prices (§2.3). (2) No independent second-vendor checker on staff — so checking runs as a ladder. The layers, cheapest first: (a) Instruments, not brains — linters, type checkers, security and secret scanners: deterministic, free, local, no opinions. (b) The hard test gate — nothing merges unless the full suite is green; the backbone in every configuration. (c) The local model's first pass, given a written checklist instead of an open brief — spec compliance, edge cases, error handling — plus the duty to write tests for the new code and run them, so a failing self-written test is a finding; this converts the local model's weak judgement into mechanical work, which is what it earns its keep at (build breaks, obvious bugs, missing edge cases), because §1.2's evidence (multi-turn chains at ~33–38%) is precisely why it cannot be seated as a judge of design or subtle logic. (d) A fresh-session Codex review under an adversarial brief ("you did not write this; your only job is to find what is wrong") — same family as the builder, so 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. (e) Flagship-model review for risky diffs only (money, auth, deploys) — review costs a fraction of building, so frontier-grade judgement is rented per-diff where the stakes are. (f) The optional review wallet — a small pay-per-use budget at the rival vendor (an Anthropic API key, ≈ $10–20/mo at review volumes, off by default) 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, at the admitted cost of slightly breaking this variant's one-subscription purity, deliberately and cheaply. With the wallet on, the starter runs ≈ $205–215/mo (plus the same one-time €39 ≈ $44 server setup). Layers (a)–(c) are standard in every configuration's quality gate; the ladder matters most here, where no second vendor is on staff. The honest residue stands even with the ladder climbed: no frontier rival reads every line in the starter — layers (e) and (f) exist so the lines that matter most are the ones that get read — and a weak "reviewed" stamp remains worse than an honestly labelled gap, which this variant continues to label. (3) The best-measured builder is benched. Claude Code is the strongest measured coding agent in its class (companion runtime study); Codex alone covers everyday work indistinguishably — the test gate does not care which vendor produced passing work — but the step down shows on the hardest ~5% of jobs and as a slightly higher second-pass rate. (4) Monoculture risk. A single vendor's outage, model regression, or allowance change touches foreman, builder and checker simultaneously; the two-vendor configurations never share that fate. The ladder, stated once: ≈ $194 starter / ≈ $235–265 recommended / ≈ $294 simpler — every rung plus the same one-time €39 (≈ $44) server setup, charged once per server and never monthly — the recommendation stands with §6; this variant is the on-ramp, not the destination.

6.3 The hardware dimension — which server the factory stands on

Every figure so far prices the factory on the EX101 (§6's building: €84/mo). The server itself is a choice, and the four tiers below are the candidates we priced. Specs and monthly prices were checked against Hetzner's own pages and price announcements on 25 Oct 2026; Hetzner adjusts prices — the April 2026 round moved several tiers — and stock varies, so every figure here is a check-at-checkout figure, not a promise.

Sourcing, stated plainly: CPU, core counts, RAM class and storage come from Hetzner's own product pages and product matrix (hetzner.com, retrieved 25 Oct 2026); the monthly and setup figures for the AX42 (€46 + €39) and the EX101 (€84 + €39) come from Hetzner's own press releases announcing those models. Two figures could not be pinned to a Hetzner-published base price on the day: the EX44's current monthly price reads ≈ €50 after the April 2026 price round (a Hetzner customer invoice report puts one HEL1 unit at €50.76/mo post-hike; plan listings track €39.44/mo pre-hike, with a €99 setup), and the EX63's €69/mo + €39 setup comes from launch listings quoting hetzner.com. Hetzner's configurator does not serve base prices to a page fetch, so the order-time checkout figure governs, as it always has in this study. One further availability flag: the EX101's own page remains live, but the model no longer appears in Hetzner's current EX matrix (a Xeon-class model now tops that line) — order-time confirmation applies there too.

The AI costs ex-server, from §§6–6.2: starter $100 (one ChatGPT Pro subscription), recommended $140–170 (foreman brain $20–50 + Claude Max 5x $100 + ChatGPT Plus $20), simpler $200 (ChatGPT Pro $100 + Claude Max 5x $100). At €1 = $1.12, each server's monthly rent converts to ≈ $52 (AX42), ≈ $56 (EX44), ≈ $77 (EX63) and $94 (EX101 — the figure already established in §6). The totals:

The EX101 column reproduces §§6–6.2 exactly — the ladder widens the choice; it does not move the published numbers. Setup fees sit outside every total above, charged once per server: €39 (≈ $44) for the AX42, EX63 and EX101, €99 (≈ $111) for the EX44. (The €39 callouts in §§6–6.2 were written about the EX101 and remain correct for it; this section generalises the fee to the server it belongs to.)

The sweet spot, ruled: the ~€50 14-core tier (EX44 class) is the baseline pick. The reasoning is about what the box actually does. It 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 — and cores are what let everything breathe simultaneously. All four tiers clear the memory wall (each carries the same 64 GB), so the 8-core tier is not memory-poor; it is parallel-poor, and for serious multi-workload use that makes it the false economy of the row. The 24-core EX101 remains the growth pick — the factory is unchanged on it, only faster and roomier — not the requirement. And climbing later is a bounded, known cost rather than a leap of faith: Hetzner's documented upgrade path for dedicated servers (docs.hetzner.com, Upgrading a Dedicated Server) runs support request → new box ordered in parallel → data copied across (both boxes billed during the overlap) → old box cancelled. Priced honestly, that is one month of double rent plus the new model's setup fee and an afternoon of copying — and the address change is invisible to the owner, because the factory's doors are reached through Tailscale, not raw addresses.

Two honest caveats close the section. First, the cheap tiers are Europe-only (FSN1/Nuremberg and HEL1/Helsinki class locations) and stock comes and goes — the tier wanted may not be the tier in stock on ordering day, which is another reason the ladder is a ladder and not a single rung. Second, a hardware honesty note on §1.4: the local model's generation-speed estimates there (15–30 tok/s short-context, 8–18 tok/s toward 64K) were estimated on the 24-core DDR5 machine. On the 14-core DDR4 sweet-spot box the local model runs slower — how much slower is an estimate on top of an estimate, and we label it that way rather than inventing a number. The cost lands where the design can afford it: the grunt engine and the understudy get slower; the rented foreman, who carries the owner's day, is untouched. The day-one measurement duty in §7 stands on whichever tier is ordered.

7. Verdict — the software factory, specified

The verdict in one breath: build the factory exactly as the candidate architecture describes, with one correction the research forced — the foreman's brain is rented, not local: a Sonnet-class brain on a $20–50 prepaid wallet staffs the desk, the free local model stands by as fallback and does the grunt work, and hard briefs escalate to Opus-class thinking from the same wallet under a human-approval process. That is the difference between a charming demo and a factory that survives its first tangled order. Everything else in the candidate design survived contact with the evidence, including the part that surprised us: the engines' flat subscriptions are not a loophole — used through the vendors' own CLIs, they are the documented, intended way to run this, and they are worth ~$200–480/mo against metered billing at this workload.

The blueprint (Dokploy project: "the factory"):

• Front office — OpenWebUI (Compose service, Tailscale-only): the owner's window. One connection: Hermes's API server (API_SERVER_ENABLED=true, port 8642). The owner types plain language here and nowhere else.
• Foreman — Hermes (Dokploy's official Hermes template, v2026.6.19; named volume for ~/.hermes): profile pinned to the AgentForgeTools world only, rulebook in its SOUL/skills, terminal backend = Docker. Brain: Sonnet-class model via the Nous Portal wallet (primary); fallback_providers: → the local Qwen endpoint (below); delegation model = the local model (subagents are cheap talk); bundled claude-code / codex skills enabled for dispatch.
• Local model — llama.cpp server (Compose service): Qwen3-30B-A3B-Instruct-2507, Q4_K_M GGUF, --jinja, fixed -c 65536, Flash Attention on, prefix caching on, model resident 24/7, CPU-fenced slice of the box. Seats: the foreman's failure fallback, and Bay 3's grunt engine. Expected manners: ~15–30 tok/s early in a context, slower at deep context — ample for bulk work, and the reason it is the understudy rather than the desk.
• Assembly line — three bays, each job in its own Docker container + git worktree:
  • Bay 1 — Claude Code (claude -p, authenticated by a claude setup-token one-year token from the owner's Max 5x plan). The primary builder: Sonnet-class model as the workhorse, Opus called up for the hardest jobs only (§2.1).
  • Bay 2 — Codex CLI (codex exec, signed in with the owner's ChatGPT Plus). Second builder and standing reviewer of Bay 1's diffs.
  • Bay 3 — OpenHands (Agent Server): parallel jobs and the grunt tier; runs the local model for cheap bulk work, cheap API models when the local queue is busy. (OpenHands is API/local-model billed by design — no subscription route exists for it, and none is needed at its tier.)
• Quality control — the gate: no merge without green tests + Codex's review pass; two red gates on one job escalate to the owner as a plain-language incident note. QC is machinery, not a model — this is deliberate: the cheapest reliable "AI" in the building is a test suite.
• Shipping dock — Git: every bay pushes branches to GitLab; the site's push-to-deploy pipeline is the template for product shipping. Nothing reaches production except through the dock.
• Fences: the whole agent world is resource-capped at roughly a third of the box (standing design), the front office and panel are never public, and the owner's separate workstation desktop lives outside the fence entirely.

The simpler variant: an owner who prefers two subscriptions to a wallet plus two can run §6.1 instead — ChatGPT Pro on double duty (foreman brain + Bay 2), ≈ $294/mo plus the one-time €39 (≈ $44) server setup, one shared OpenAI pool as the accepted weakness. It is a legitimate configuration, not a compromise of the architecture; the recommendation above is preferred on structure (separate buckets) and price, in that order.

The starter variant: an owner minimising spend can run §6.2 instead — one ChatGPT Pro subscription covering the foreman's brain and the only builder bay, the local model as first-pass checker in front of the test gate, ≈ $194/mo plus the one-time €39 (≈ $44) server setup. It proves the machine at minimum cost and upgrades by pure addition; its accepted weaknesses are the single shared pool, the labelled checking gap, and one-vendor exposure.

What we are NOT claiming: that the free local brain was good enough to face the owner all day — the evidence says it is not (§1.2), and the design never asks it to. The local model works where its weaknesses do not matter: bulk grunt work and emergency fallback. The factory works because judgement-facing work — the conversation, the briefs, the building, the review — rides on rented pro-tier brains and mechanical gates, while the foreman's own job stays narrowed: talk, translate, dispatch, narrate.

8. Claims we could NOT verify (flagged, not buried)

1. Exact local tok/s on the real EX101. No public benchmark of Qwen3-30B-A3B Q4 on an i9-13900 at 64K exists; our 15–30 / 8–18 tok/s figures are estimates synthesised from bandwidth arithmetic and adjacent benchmarks (our local-inference study). First act after the server lands: measure, don't trust. (The figure now bounds Bay 3's grunt throughput and fallback quality rather than the daily conversation, which rides on the rented brain.)
2. BFCL V4 official-leaderboard overall for Qwen3-30B-A3B-Instruct-2507. The official board is script-rendered and did not yield its table to text retrieval; §1.2 therefore relies on three independent replications run under official BFCL protocols (v3 and V4 subsets), which agree with each other (multi-turn 33–38%) but are not the board itself.
3. Anthropic's 6 May 2026 limit-doubling and current effective allowances. The doubling is reported by multiple secondary trackers, not confirmed here from an Anthropic page; and the effective weekly allowance is genuinely contested (see the Kahn filing's allegations vs Anthropic's marketing hours). The blueprint survives either way — Max 5x has headroom under both accounts — but the exact hours should be treated as soft.
4. OpenAI's Codex weekly allowance. OpenAI publishes 5-hour estimates and says weekly limits "may apply"; it does not publish the weekly numbers. Plus-tier sufficiency at our workload is therefore a judgement, with Pro $100 as the defined fallback.
5. Hermes-as-manager field reports, specifically. The field-report corpus (§1.5) is dominated by OpenClaw (same pattern, different harness) plus general Hermes setups, most of them with cloud brains; a large body of Hermes-foreman production reports does not yet exist in either brain configuration. The BFCL evidence is model-level and solid; the harness-level interaction (Hermes's retries and scaffolding recovering model errors, local or rented) is plausible but unmeasured in public.
6. Long-term tolerance of setup-token-driven workloads. claude setup-token is documented by Anthropic for CI/scripts today (Oct 2026). Whether Anthropic further restricts unattended, agent-dispatched subscription workloads in future terms revisions is unknowable; the fallback if it ever changes is metered API for Bay 1 (~$325/mo at this workload) — painful, not fatal, and the reason the blueprint keeps an API wallet warm.

Sources (retrieved 24–25 Oct 2026 unless noted)

• Hermes Agent documentation — LLM and Model Providers; Quickstart (64K context floor); API Server; Fallback Providers — hermes-agent.nousresearch.com
• Open WebUI documentation — Hermes Agent (connect-an-agent) — docs.openwebui.com
• Dokploy — Deploy Hermes on Dokploy (template v2026.6.19) — dokploy.com/templates/hermes
• Anthropic — Claude Code docs, Authentication (claude setup-token; updated 2026-10-22) — code.claude.com/docs/en/iam; Legal & Compliance page (19 Feb 2026) as quoted in enforcement analyses
• Kahn v. Anthropic, PBC, N.D. Cal. 3:26-cv-05763 (filed 14 Jun 2026) — Anthropic's July-2025 tier-hour emails as quoted in the complaint; allegations unproven
• OpenAI Codex pricing/limits as published on OpenAI's pricing pages and retrieved via Oct-2026 trackers (codepick.dev; developersdigest.tech; morphllm.com; aibuildersuse.com — checked 19 Oct 2026)
• Nous Portal — plan page (Free/Plus $20/Super $100/Ultra $200; credits +10%) — portal.nousresearch.com/manage-subscription
• OpenAI — "Sign in with ChatGPT" plan usage for third-party tools (launched 29 Sep 2026; Hermes Agent a named launch partner; per-app caps 10–100% of the shared allowance) — TokenPost announcement summary; DevDay announcement coverage, The New Stack (via URALLNEWS / Bitcomme)
• Hermes Agent documentation — LLM and Model Providers (OpenAI Codex: "ChatGPT or Codex Subscription" provider, device-code OAuth) — hermes-agent.nousresearch.com/docs/integrations/providers
• BFCL evidence: arXiv 2610.23148 (App. L, BFCL v3 on Qwen3-30B-A3B-Instruct-2507); arXiv 2602.03219 (Table 1, BFCL multi-turn + τ-bench); arXiv 2604.21590 (BFCL-V4 multi-turn); OrchestrationBench, ICLR 2026
• Community/practitioner: clawmage.ai (OpenClaw+Ollama production patterns); dev.to — lars_winstand (context-blowout post-mortem), amiri83 (Hermes + Claude Code 24/7 build); guides.edgible.com; betterclaw.io; LinkedIn — Faizan Javed (context-decay supervisor pattern, 4 Oct 2026); vincentvandeth.nl (Hermes/Max terms analysis); dplooy.com & evermx.com (Apr 2026 enforcement timelines)
• Hetzner — EX101 press release (€84/mo + €39 setup) and hardware docs — hetzner.com
• Hetzner (§6.3, retrieved 25 Oct 2026) — dedicated-server product pages and product matrix (AX42 / EX44 / EX63 / EX101: CPU, cores, RAM class, storage) — hetzner.com; AX42 launch press release (€46/mo + €39 setup) — hetzner.com pressroom; Upgrading a Dedicated Server (support-request / parallel-box migration path) — docs.hetzner.com. EX44 current price (≈ €50/mo, €99 setup) and EX63 price (€69/mo + €39 setup) per plan listings and launch listings quoting hetzner.com (whtop; Server Hunter; April-2026 price-round customer reports), flagged in §6.3 as not pinned to a Hetzner-published base price
• Prior AgentForge studies (same workspace): agentic-coding-powerhouse-runtime-choice-20261025-0522; local-llm-efficiency-and-gpu-servers-20261025-0517; cheap-dedicated-servers-vs-hetzner-20261025-0353
• EUR/USD 1.1203 — Finnhub, 25 Oct 2026