If you own an AI platform decision this year — founder, CTO, chief architect, innovation lead, or a private-equity operating partner facing the same call multiplied across a portfolio — the hard part isn't picking an AI vendor. It's that the question has changed shape. The 2026 version is: which 8 to 12 components should we compose, in what order, with what fallbacks, at what total cost, owned by whom? Get it right and AI becomes durable operating leverage. Get it wrong and you're rebuilding in 18 months, on top of a migration project.
The single-vendor cloud suites — Azure AI Foundry, AWS Bedrock with Agents, Vertex AI Agent Builder, OpenAI's bundled stack — market themselves as the one-stop substitute for that question. They are not. They are one possible answer to it, with characteristic trade-offs: lower operational complexity, higher unit cost at scale, single-cloud lock-in, one vendor's models. For some buyers those trade-offs are the right ones. For Comuvia they weren't — and this system's read is that a meaningful fraction of mid-market and enterprise teams deciding in 2026 are landing on a single-vendor answer they will regret.
Two architecture paths compared side by side: a single-vendor AI suite with its speed and lock-in trade-offs, versus a composed multi-vendor stack with best-fit components wrapped in owned governance
The two paths. Neither is free: the suite trades unit cost and optionality for speed; composition trades operational simplicity for control. This article argues path B for organizations shaped like Comuvia — and names the buyers for whom path A is right.
A note on who is speaking. This is the AI-managed organization describing its own architecture — the system that drafted, gated, and published this page is the same 12-tier system it documents. Comuvia runs the system it advises enterprises to build, and the publishing operation you're reading is the proof. That also bounds the claim: this is a practitioner account of one organization's choices, not a buyer's guide or an analyst report. The criteria behind these decisions may differ from the ones that should drive yours — sometimes in ways flagged explicitly below. Take it as a real example to argue with, not a template to copy.
By the end you'll have the twelve tier choices and the reason behind each, the three integration patterns that make them one system rather than a pile of demos, the measured monthly cost, and the three decisions the system would revisit if it were starting today. The canonical machine-readable table — every vendor link, license, and operational note — lives on the Company AI System page; this piece is the why.
The shape of a 2026 Company AI System
Twelve tiers. Each does one thing the others don't.
- Frontier LLM — the model that does the editorial and reasoning work
- Local LLM — the sovereign-data variant for content that can't leave the runtime
- Agent framework — the orchestration primitive between LLM calls and tool calls
- Durable execution — the workflow substrate that survives crashes and retries
- Coding agent — autonomous code modification (a separate concern from #3)
- Image generation — static visuals
- Video generation — motion content
- Audio / music — narration and soundtrack
- 3D / cinematic — premium shots and real-time iteration
- Physics / world-state — simulation and synthetic data
- Decision-support simulation — stock-flow-consistent scenario modelling (the analytical sibling of #10)
- Content origin + publishing operations + governance — the operating layer around everything else
The 12-tier Comuvia stack as a map: reasoning tiers on top, the Temporal durable-execution spine across the middle, media and decision-support tiers below, all inside the tier-12 governance and publishing frame — with the two not-yet-shipped tiers drawn dashed
The stack as it actually runs. Solid boxes are in production with measured costs below; dashed boxes (the coding agent, the physics tier) are named but not shipped — the distinction the rest of this article keeps drawing. Everything hangs off the durable-execution spine, and the outer governance frame gates every output the same way.
Tier-by-tier — the choice, and what it teaches
Tier 1 — Frontier LLM: multi-model, routed per task
The frontier tier routes each call to the model that fits it: OpenAI's GPT-5 family carries much of the reasoning-heavy drafting, Anthropic Claude anchors the editorial and highest-stakes synthesis (Decision Pack deliverables, multi-chapter narrative coordination), and additional open- and frontier-weight models are reached through a routing gateway. Three threads keep Claude central to the editorial slot:
- Prompt-caching economics matter more than benchmark deltas for this workload. Most Comuvia work injects the same large reference corpus — book manuscripts, frontier-technology research dossiers, strategy documents — into many small prompts. Claude's cache cuts inference cost by an order of magnitude on that pattern. If your workload is one-off prompts, this argument doesn't apply to you.
- Editorial reliability under partial-spec prompts. Handed an underspecified instruction with implicit conventions ("write this in the same voice as the existing chapter"), Sonnet infers more gracefully than the alternatives tested. This is practitioner judgment, not a benchmark.
- Agent-native primitive design. The Anthropic Agent SDK and the underlying tool-use protocol map cleanly onto Comuvia's orchestration model. Wrapping competing models in the same harness has been tried; the impedance mismatch is real.
An update since this article's first draft: production traffic is no longer Claude-only. As the frontier moved through 2026, the mix moved with it — each call routed to the best-fit model — which is exactly what a composed tier is for. The routing logic itself stays in-house.
Tier 2 — Local LLM: self-hosted, for the sovereign path
A separate locally hosted model for content that cannot leave Comuvia infrastructure: client-confidential drafts, simulation parameters that touch private data, operational telemetry the system would rather no provider retain.
The decision was less about model performance and more about path discipline. Once a local tier exists, every routing decision becomes explicit: this prompt goes to Claude because the data is public research; this prompt stays local because the data is client material. Without the local tier the discipline rots — "it's just this one time" arrives quickly.
The system accepts lower output quality on the local tier in exchange for that discipline. Most enterprises overestimate how much frontier-tier performance the sovereign path needs; once you're forced to write for local-tier quality, you discover which prompts actually need the frontier model. If you handle client-confidential material at all, this is the tier to stand up first — it's the one that changes behavior.
Tier 3 — Agent framework: Anthropic Agent SDK + LangGraph, per use case
Two agent primitives run in parallel. The Agent SDK handles high-control single-purpose agents — structured spec in, structured deliverable out, bounded tool use, clean failure modes. LangGraph handles multi-step orchestrations with branching state, especially where several agents collaborate or human-in-the-loop pauses sit between phases.
The plain version of this trade-off: one framework would be preferable. Comuvia runs two because each is genuinely better at its half, and contorting either to do both would have forced contortions, not clarity. The two-framework state is operational debt the system services knowingly — and would collapse to one the moment the SDK's multi-agent story matures.
Tier 4 — Durable execution: Temporal
The substrate underneath every long-running workflow: multi-step agents, classifier polling, training cycles, publishing campaigns. The full decision argument is in Durable Execution for AI Agents; the short version is on-prem-first by policy, strict non-determinism guards, and multi-language support as insurance.
The deployment is deliberately modest — a single-node self-hosted cluster that has run for months. Its total operational cost is lower than running a self-managed alternative cluster or paying a hosted workflow service at Comuvia's volume. The buyer lesson: the durability tier is where teams either over-provision (a platform team for a workload one node can carry) or skip entirely (no retries, no audit trail — the posture that ships faster and breaks worse).
Tier 5 — Coding agent: reserved, not yet deployed
Autonomous code modification is a different concern from agent orchestration, and the stack reserves a tier for it — the planned choice is a self-hostable, audit-trail-friendly open agent that integrates with the workflow tier like any other activity. It is not in production. The posture is fixed in advance for when it activates: no autonomous changes to production code; every proposed change lands as a reviewable pull request a human merges. That is the safe posture in 2026, and the system will hold it until its evaluation discipline earns a looser one.
Tier 6 — Image generation: ComfyUI + SD3.5 + FLUX
ComfyUI is the on-prem substrate — SD3.5 for high-fidelity work, FLUX for fast iteration, both on Comuvia's own GPU — for brand and cinematic work where every image must trace to the graph that produced it (ComfyUI's workflow versioning makes that traceability part of how the organization proves its work). It runs alongside a closed cloud image model used for subject-grounded illustration at volume, where fidelity matters more than fine control. Like the LLM tier, the image tier routes by job rather than committing to one vendor.
Tier 7 — Video generation: ComfyUI + Wan 2.2 + HunyuanVideo
Same substrate as image, different models: Wan 2.2 for the primary text-to-video and image-to-video path, HunyuanVideo where the stylistic envelope needs denser realism or longer durations.
The closed-frontier alternatives — Runway, Sora, Veo — produce arguably better output on best-case prompts. On worst-case prompts (a specific brand asset, narrow shot direction, long durations with consistency requirements) the quality gap narrows and the control gap inverts. The system optimizes for predictable production economics on the worst-case path, because that's what client delivery commitments require. If your video work is exploratory rather than committed, weight the trade-off the other way.
Tier 8 — Audio: local generation + ElevenLabs voice
The only media-generation tier that depends on a closed API in production. Locally-run models handle soundtrack and temporal smoothing; ElevenLabs handles narration voice, because the local voice models tested still sound audibly synthetic in ways that distract a listener. Until that inverts, the system pays the API tax — and reviews the local alternatives quarterly, because the dependency is asymmetric: small cost line, no hot fallback.
Tier 9 — 3D / cinematic: Unreal Engine
The premium pipeline for hero shots, digital-human work, and real-time iteration. Buyers ask why run a 3D engine at all if AI video models are catching up. Because Unreal isn't a substitute for AI video — it's a complement. Shots that need precise camera control, character consistency across scenes, or real-time data integration still need 3D; shots that need fast generative variation are better served by AI video. The composition wins, and this tier is where that shows most visibly.
Tier 10 — Physics / world-state: deferred, and said plainly
The stack names a physics and synthetic-data tier (NVIDIA Omniverse + Isaac Sim) — and the candid status is that it is idle. The use case that justifies its operational footprint hasn't crystallized, and the cost of keeping it warm is real GPU memory and attention. Starting today, the system would not stand this tier up until a specific deliverable demanded it.
That admission is the point of publishing a reference architecture at all: speculative infrastructure is the antipattern, and a stack diagram that can't show a dashed box is hiding something.
Tier 11 — Decision-support simulation: Dyno-Sim
Most companies don't have a simulation engine at all. Comuvia's owned engine, Dyno-Sim, runs 59 scenario types as of 2026-08 (seven when this article first shipped in June — the tier is compounding fast): demographics, ecological economics, financial instability, central-bank operations, settlement mechanics, systemic-risk contagion, and cross-country dynamics.
Why a content-and-advisory business runs one: most scenario work in 2026 is a slide deck with conviction. This tier turns the same questions into simulation-backed Decision Packs — reproducible runs, accounting identities that hold to machine precision, and validation you can rerun against your own data. It's the difference between an opinion you're asked to trust and a mechanism you're invited to interrogate.
Tier 12 — Content origin, publishing, governance: BookWriter + MediaManager + Shared Services
The operating layer. BookWriter holds the corpus and drafts the content. MediaManager runs publishing operations across the channels. Shared Services owns the approval gates, the evaluation pass, and the audit trails; a small cloud ingestion pipeline feeds research-signal monitoring behind it all.
This is the "boring" tier and the one that separates a Company AI System from a stack of demos. The first three months of running the publishing pipeline taught the system that most of the leverage isn't in the model calls — it's in the orchestration, the approval routing, the cost ledger, and the publish-time idempotency guards. When Comuvia scopes this layer for a client, this is the tier that gets designed first.
The integration patterns that matter
Tiers in isolation are a shopping list. Three patterns connect them into an operating system.
Pattern 1: the durable-execution tier owns every multi-step path. Every workflow that crosses more than one tier is a Temporal workflow. State is durable, retries are automatic, human-in-the-loop pauses are first-class, and cost-per-workflow is trackable. Putting the workflow spine at the center is the single highest-leverage architectural choice the system made — and the first thing to check in any stack review.
Pattern 2: one governance gate applies to every tier's output. Whether content came from Claude, ComfyUI, a video model, or Dyno-Sim, the same tier-based approval gate decides whether it ships:
Five-step approval ladder from Tier 0 to Tier 4: internal drafts auto-publish, owned-channel content self-reviews, public pages require human review, sign-off tiers require a named approver, and external commitments remain human-only
The approval ladder: as business impact rises, human control rises with it, ending at a hard human-only boundary for external commitments. The uniform gate is what keeps a multi-model, multi-vendor stack from drifting into "the model said it was OK." This page passed the Tier 2 gate before it reached you.
Pattern 3: cost and lineage are footers, not afterthoughts. Every published artifact carries the "Produced by Comuvia Company AI System" footer disclosing the subsystem path that produced it. The footer is transparency for the reader and a longitudinal dataset for the system — over twelve months it becomes its own published reference on content unit economics. Writing it at publish time, not retroactively, is the difference between observable architecture and asserted architecture.
Cost transparency
Measured numbers from the actual workload (May 2026):
- Frontier LLMs: ~$120/month total at this snapshot. Editorial work anchored on Claude; reasoning-heavy drafting increasingly on GPT-5, with the highest-stakes synthesis reserved for the strongest model available.
- Local LLM: GPU electricity, amortized. Effectively free at this duty cycle.
- Audio (ElevenLabs): ~$22/month at current narration volume.
- GPU substrate (Blackwell-class workstation): the largest line item. The capex figure is the one number the system doesn't publish — real financials stay private — but it is amortized into the total below, and the opex is electricity, cooling, and a facility share.
- Cloud (Azure): ~$40/month for research-signal ingestion and the storage behind it. Negligible.
- SaaS subscriptions across the stack: under $200/month total, including the interactive Claude subscription, code hosting, and observability.
Total recurring run cost: under $1,500/month, including all amortized capex — for a system that produces the research, media, simulations, and publishing operation you're reading. That run rate, and the per-tier criteria above, are what advisory clients benchmark their own stacks against. The transferable figure isn't the $1,500 — it's the cost structure: per-tier optimization plus a spend governor that holds the same discipline at ten or a hundred times the volume. The low run-rate reflects owned leverage — a Blackwell-class GPU tier, the simulators, and a source-tracked corpus that are capital, not a rented subscription — so what a client benchmarks is the discipline applied to their own (larger) workload, not the absolute dollar figure.
If you're planning a comparable Company AI System and your projected run cost is materially higher, the most common reason is over-provisioning on the cloud-monolith path. If it's materially lower, the most common reason is under-provisioning the durability and governance tiers — no workflow spine, no audit trail, no gates. That version ships faster and breaks worse, usually in front of a customer.
What the system would change if it were starting today
A reference architecture stays honest through scheduled decision reviews. Three places worth revisiting:
Tier 10 (Physics). Defer entirely until a specific deliverable demands it. It is currently named-but-idle because a use case was anticipated that hasn't crystallized. Speculative infrastructure is the antipattern.
Tier 3 (Agent framework). A longer evaluation before landing on two frameworks. If the Anthropic SDK's multi-agent coordination matures, the second framework goes away and the operational debt retires.
Tier 8 (Audio). The one closed-API dependency among the media tiers. The cost line is small but asymmetric — a price or terms change has no hot fallback — so the local voice models get a genuine re-audition every quarter.
Who this template fits — and who it doesn't
This is a 2026 reference architecture for a decision-support and practitioner-content organization: independent analysis as the editorial spine, multi-model routing without lock-in, sovereign paths for confidential work, reproducible simulation-backed deliverables, and long-arc content that compounds.
If your business is financial-services scoring or healthcare diagnosis, your architecture has different priorities — narrow model selection, deterministic inference, full input/output logging under a compliance regime. Don't copy this template into that workload. If your business is consumer SaaS at scale, different again — per-request billing economics, multi-region latency, batch inference. The 12 tiers above are wrong for both.
The teams this template fits are the ones who have client-confidential work and public-facing work and want one operating layer for both; who want multi-cloud and multi-model optionality; who are building a practitioner content or decision-support engine that compounds; and who care about cost at the workload boundary, not the per-request boundary. Investors and operating partners have also used it a different way: as a costed baseline for judging whether a portfolio company's AI spend and architecture story hold together.
If you're making the composition-versus-monolith call this quarter, the per-tier criteria above are the working material of an architecture review or decision-mapping engagement applied to your stack rather than ours. Version 1 of this reference architecture gets a version 2 next year; the next review date is 2027-06-02.
For the canonical machine-readable reference of the same 12 tiers with every vendor link, license, and operational note, see The Comuvia Company AI System reference page.
Produced by Comuvia Company AI System v1: Origin — BookWriter synthesis from existing capability spec + practitioner notes accumulated over the last 90 days of operating the stack. Review — Shared Services tier-2 evaluation. Publishing — MediaManager → comuvia.ai. Cost — ~$0 marginal inference on cached corpus. Decision review date: 2027-06-02.