Sovereign Orchestrator Pro
V6.0. The Synthetic Agency Pipeline.

Six numbers. Every one of them traceable.

The audit report (May 12, 2026) anchors every claim in this case study to a file path, line number, or data-file count in the live codebase. These six numbers are the headline metrics. The rest of the page walks down to the source.

Six months of continuous operation. 503 publishing actions in the most recent 8-day measurement window from content_ledger.json. A sustained autonomous publishing rate of ~63 actions per day across four platforms, running on a single RTX 3060 with 12 GB VRAM and a hard $8/day base budget cap.

Eleven AI agents. Eleven human roles replaced.

The cleanest way to understand the operational leverage of Sovereign Orchestrator Pro is to map each AI agent directly to the human role it performs. Every agent below is a discrete TypeScript file with its own model routing, system prompt, and inputs. Together they replace an entire digital marketing and content studio.

What this case study proves — and what it does not.

Most builder-published case studies hide their evidence gaps. The Vibe Academy standard does not. Before walking through the technical architecture, this is the one finding from the audit that an honest case study must surface: a clearly bounded gap between operational scale and proven commercial outcome. This page treats that disclosure as a teaching moment, not a footnote.

Why this disclosure leads the case study

The system has technical scale, real operational track record, and defensible build cost. It does not yet have proven attribution from publishing actions to revenue events. Both facts coexist. A solo builder learning from this case should understand that operational excellence and commercial validation are two different bars, and that documenting the gap honestly is part of what separates audit-grade engineering from marketing.

The rest of this page presents the verified architecture, agent pipeline, intelligence engine, cost discipline, operational track record, engineering history, build-cost methodology, and risk factors. Each section cites either a code path or a data file. Read the technical claims with confidence; read the commercial claims with the qualifier above.

Three local servers. One GPU. One mutex.

The system runs as three concurrent local servers, each with a discrete responsibility. A 169-line start.bat performs five sequential pre-flight checks before the controller spawns threads. Single-card GPU concurrency is enforced strictly by mutex.

Boot sequence — 5 sequential checks in start.bat

The bootstrap script (start.bat, 169 lines) is the single source of truth for what must be true before threads can launch. Each step aborts the launch on failure.

1. [1/5] Environment integrity. Validates .env exists, verifies GEMINI_API_KEY is present.
2. [2/5] Ollama daemon. Kills stale processes, starts fresh server on port 11434, verifies LISTENING state.
3. [3/5] Ollama model verification. Confirms all 5 Intelligence Engine models present locally: deepseek-r1:8b, llama3.1:8b, gemma3:4b, qwen2.5:14b, mistral-nemo:latest. Auto-pulls any missing model.
4. [4/5] Atelier Smart DB. Checks port 9000, starts external server.js if needed, falls back to local JSON if unreachable.
5. [5/5] Pre-launch cleanup. Purges stale Reddit Playwright session lock, kills zombie processes on :3200 and :24678 (Vite HMR), ensures reports/ directory exists for daily anomaly reports.

Technology stack

From package.json, verified May 12, 2026:

19 concurrent worker threads.

Verified from controller.ts:24-53 THREAD_REGISTRY array. Each thread has its own platform, interval, daily cycle count, and entry-point file. The controller staggers thread start delays so no two threads attempt to acquire the GPU mutex or post to the same platform simultaneously. The cluster below mirrors the actual app's dashboard organization exactly.

11 first-class AI agents.

The agent roster is locked in agent_models.json and the registry at agentModels.ts:14-29. Ten agents route through Gemini. One — the Intelligence Engine — orchestrates 5 sequential Ollama models locally (covered in the next section). Each agent below is implemented as a discrete TypeScript file with explicit responsibility, model routing, and inputs.

Standard pipeline order

For every WordPress and Shopify publishing cycle, the swarm orchestrator runs the agents in this exact order:

1. Atlas selects topic, product, and audience.
2. Argus surfaces pre-flight signals (trending / buying-intent / avoid).
3. Legion gates on margin and inventory (advisory).
4. Scribe generates outline, prose, and HTML in a 3-call pipeline.
5. Veritas audits the draft for brand compliance. If surgical-fix JSON is returned, the orchestrator retries up to 3 times.
6. Lumiere generates alt-text, Pinterest description, and OG image alt.
7. Hermes grades SEO from 0 to 100 with explicit checks (advisory).
8. Publish via the platform service (wordpress.ts, shopify.ts, twitter.ts, or redditPlaywright.ts).

Five Ollama models. One VRAM lane.

The Intelligence Engine (intelligenceEngine.ts, 646 LOC, lines 179 to 183 define the cycle list) runs as a sequential downtime learning loop on the RTX 3060. Only one model is resident in VRAM at a time. Total never exceeds 8.4 GB. Outputs are written to hippocampus.json tagged as INTELLIGENCE entries, and consumed by Gemini agents on the next swarm cycle via three explicit hooks (contentGenerator.ts:28, tweetGenerator.ts:23, strategyAgent.ts:78).

Routing and consumption

All 5 cycles write to data/hippocampus.json as entries tagged {platform: 'INTELLIGENCE'}. Three downstream Gemini agents read from this file at the start of every swarm cycle:

• contentGenerator.ts:28-41 — loadIntelligenceDirectives() for Scribe
• tweetGenerator.ts:23-40 — loadXIntelligenceBlock() for Tweet Generator
• strategyAgent.ts:78-80 — direct hippocampus filter for Atlas

$8 to $13 per day. Hard-enforced.

Cost caps live in costService.ts:26-28 as named constants. Every Gemini and X.com call increments updateCost() before invoking the API; calls beyond the cap return early without invoking the LLM. daily_costs.json persists telemetry across restarts. Budgets reset at midnight (costService.ts:79-90).

Cost-control mechanisms in code

• Daily reset at midnight — costService.ts:79-90
• Per-call cost logging — every Gemini and X.com call increments via updateCost()
• Telemetry persistence — daily_costs.json survives restarts (costService.ts:50-52)
• Budget enforcement — calls beyond cap return early without invoking the LLM
• First-sale boost — boostGeminiBudget() at costService.ts:104-115 fires once per day on first detected sale

503 publishing actions in 8 days.

The current rolling window of content_ledger.json captures 8 days (May 4 to May 12, 2026). Earlier entries have rotated out under the file's rolling-window policy. Continuous operation across the full 6-month window is independently verifiable from start.bat invocation history and daily_costs.json telemetry.

Inventory under management

• Catalog size: 684 products in product_brain.json (counted May 12, 2026). Today's Shopify Smart Sync fetched 683 — within one of the brain count, normal drift.
• OOS exclusion: 8 products auto-excluded from rotation (hippocampus.json plus the OOS detector in memory.ts).

Intelligence Engine output

• hippocampus.json total entries: 50 (post-rotation)
• INTELLIGENCE-tagged entries: 5 (one per active learning cycle in the current rolling window)
• Vector dedup: Active — duplicate intelligence summaries skipped via writeHippocampus()

Sniper system state (data/sniper_queue.json snapshot, May 12)

• 40 expired (post-cleanup; the auto-expire rule sweeps stuck approvals after 24h)
• 2 posted (manually completed)
• 4 skipped (manually rejected)
• 0 pending (next cycle will populate)

40+ discrete patches across P0 to P10.

Every phase reconstructed from [P*] code-comment markers grepped across src/. Phase markers carry the 2026-05-12 stamp; that reflects when the header comments were added, not necessarily original ship date. Selected highlights below; the full 40+ patch set is documented inline in the codebase.

Phase totals: 40+ discrete phase markers across Reddit safety, UTM attribution, intelligence engine expansion, agent promotion, compliance-audit remediation, and sniper system audit. The summary above shows 17 representative phases; the full 40+ patch set is anchored in the codebase via inline [P*] comment markers.

$266,000 to commission this from a studio.

What does it actually cost to engineer a platform of this complexity? If a company were to commission a software development agency to replicate the 21,742+ lines of code, the 11-agent interactions, and the local GPU memory management in Sovereign Orchestrator Pro, they would need a specialized team of four senior engineers. This is the Real-World Build Cost Estimate, calculated using standard 2026 market rates for senior engineering talent.

The operational comparison

The $266K above is the one-time build cost. The ongoing operational savings are equally relevant. If a digital marketing agency were to hire the eleven human roles mapped in Section 02 above as employees or contractors, the monthly cost would be in the range of $25,000 to $80,000 per month depending on geography and seniority — versus this system's verified $240 to $390 per month in actual operating cost. The pipeline compresses both build cost and run cost simultaneously.

Productivity sanity check

At approximately 17,000 LOC of complex AI orchestration code excluding scripts, and an industry-standard productivity rate of 5 to 7 LOC per hour for code involving LLM prompt engineering, OAuth integrations, and async pipelines, the 1,700-hour studio estimate is internally consistent. A solo founder working approximately 30 hours per week over 6 months totals approximately 780 hours — meaning a market rebuild via an agency would take roughly 2.2× the actual founder effort, primarily because contractors do not carry the founder's domain context, brand bible, or product catalog familiarity.

Seven risks. Every one of them in the open.

Most builder case studies hide the failure modes. This one teaches them. Every autonomous system carries operational risk; cataloging it openly is part of what separates audit-grade engineering from marketing. The severity ratings below were assigned by the assessor, not by the operator. Mitigation status reflects what is implemented in code today, not future intent. Use this table as a checklist when designing your own autonomous systems.

Assessment limitations — what this case study is not

For Vibe Academy students reading this as a model for how to publish forensic case studies on your own systems:

1. This is a technical fact-check anchored to live code, not a formal accredited business appraisal.
2. Build-cost figures use 2026 senior-engineering market rates; agency overhead, profit margin, and discovery costs sit on top of these numbers in real-world contracts.
3. No access to comparable private transaction data (PitchBook Pro, CB Insights).
4. Revenue validation is the single largest evidence gap — see R-03 above.
5. Legal IP enforceability has not been assessed.

Every claim about architecture, agents, threads, intelligence engine, cost discipline, and operational track record carries one of three citation forms: a file path, a data-file reference, or a verifiable count. Build-cost analysis uses senior-engineering market rates labeled as such. This is the documentation standard for any case study published under the DDS Vibe Academy banner.

What this case study proves and what it does not.

The audit is forensic, not promotional. The lessons below distinguish what the system has demonstrated from what it has not. A reader of this case study should leave with both lists clearly separated.

What the system has demonstrated

1. A solo founder can build and operate a synthetic agency. 78 files, 21,742 LOC, 6 months continuous operation, on consumer GPU hardware with hard $8/day budget caps. The 11-agent pipeline maps directly to 11 human marketing roles. The $266,000 build-cost figure reflects what a senior-engineering team would charge to commission this from scratch.
2. Multi-agent orchestration at this scale is feasible on a single VRAM lane. The Intelligence Engine's 5-cycle sequential Ollama pattern is a deliberate, novel architectural choice. Sequential rather than parallel inference. One mutex. Zero marginal compute cost. This is not the only viable pattern, but it is a working pattern.
3. Cost discipline can be hard-encoded. Every external API call increments updateCost() before invoking the LLM. Calls beyond cap return early. Telemetry persists across restarts. The system cannot accidentally spend more than $13/day on AI APIs because the code path does not exist.
4. Brand compliance can run as an autonomous audit loop. Veritas (gemini-2.5-flash) reviews every Scribe draft. When violations are stylistic, surgical-fix JSON triggers up to 3 retries before soft-fail. When violations are substantive, the system halts. The retry budget is itself a cost-discipline mechanism.
5. Forensic documentation is achievable for a solo project. Every metric in this case study points to a file, a line, or a data file. [P*] inline phase markers across the codebase make the engineering history reconstructable months later. This is the standard the audit applied; this case study presents it.

What the system has not yet demonstrated

1. Direct attribution from automation to revenue. R-03. The single largest evidence gap. UTM tagging is implemented (Phase P1, P3.5) but the 90-day measurement window has not closed yet.
2. Multi-tenant productization. The build-cost analysis on this page is for a single-tenant rebuild. Multi-tenant SaaS would require a meaningful refactor that has not occurred.
3. Resilience to platform terms-of-service enforcement. R-05. Reddit Playwright automation is the highest live-risk surface. The Reddit engagement thread is already hard-disabled (P0.1) pending a reply-generation fix.
4. Co-founder bus factor reduction. R-01. All institutional knowledge resides with one person. The audit + this case study are first steps toward documentation; the second step is hiring or partnering.

For other solo builders studying this as a case

The five highest-leverage choices in retrospect:

• Local-first Intelligence Engine. Putting the 5-cycle learning loop on Ollama with OLLAMA_NO_CLOUD=1 made the difference between $13/day max and an unbounded API bill.
• One file per agent. 11 agents = 11 files. No mega-files conflating roles. Phase P9.5 promotions were possible because the agents were already separable.
• Audit-grade documentation while building, not after. The [P*] inline phase markers were added during development. Reconstructing them after the fact would have been nearly impossible.
• Single GPU mutex. One acquireGpuLock() instead of trying to parallelize across a 12 GB card. Less throughput, dramatically less failure surface.
• Hard cost caps, not soft alerts. Budget enforcement at the call site, not after-the-fact telemetry. Cannot accidentally exceed.

Fifteen questions, audit-grounded.

Mirrors the FAQPage JSON-LD schema. Every answer cites a file path, data file, or audit section.