TL;DR
The same model, the same workload, the same rules. One architecture produces a 99% classification rate at $0.127 per human turn. The other produces a 60% classification rate that requires scaling to a frontier model to recover. The model is the same. The architecture is what extracted the capability. Ten Trillion Triangles TPipe is the extraction mechanism. Below is the proof, the math, and the interactive comparison.
The 30B model that beat Opus 4.6
The claim is empirical. The Open-Autogenesis gameplay loop runs a legality check on every player turn. The check is four classification problems stacked together: classify the play type, read the rule book entry, verify the player has the points, decide what changes the rule book authorizes. A naive single-prompt design hands all four to the model in one system prompt and asks for a free-form verdict. The model picks one. The verifier has to trust it. The classification rate is 60% on Claude Opus 4.6.
The same workload, the same rules, the same transformation function, the same legality rectifier, but the substrate in the loop. The classification rate is 99% on Qwen 3 Coder 30B-A3B. The 30B model is not smarter than Opus 4.6. The architecture is what made the 39 percentage point difference.
The cost follows the architecture. Same workload, same model, same Qwen 30B:
- Without the substrate, the legality check fails often enough that the operator has to scale the model up to recover accuracy. The cost basis is whatever the frontier model bills.
- With the substrate, the legality check runs at 99% on the 30B model. The cost basis is whatever Qwen 30B bills.
The substrate owns the difference. The per-game cost is 30× cheaper because the substrate lets the small model do the work the small model can do, instead of forcing the operator to scale to a frontier model to do the work the brain-locked design cannot extract.
The four mechanisms that extract capability
Every model has a capability ceiling. The substrate lowers the floor on what the model has to do. Lowering the floor raises the ceiling on what the model can deliver. The four mechanisms that lower the floor are the substrate’s competitive advantage. They are not “more inference.” They are better inference, inference that does the work the model can do, with everything else going to infrastructure. They are the reason Ten Trillion Triangles TPipe extracts capability from a 30B model that the framework-as-brain design cannot reach at any price.
Structured JSON output. A classifier that returns a Legal? data class with two fields (isLegal: Boolean, changesToMake: String) returns roughly 200 tokens of output. A classifier that returns “Based on my analysis of the rules and the player’s available points, I believe this play is legal, but with the caveat that…” returns roughly 2,000 tokens of output. Same classification. Same accuracy. Ten times the output cost. The substrate forces the typed return. The model commits to typed fields. The substrate parses the JSON, then runs the transformation function. The output is what the work needs, not what the model’s chain-of-thought wants to produce.
Segmented memory. Naive prompting loads the entire conversation history, the entire rule book, the entire lorebook, and the entire previous world state into every LLM call. The model parses the lot. Most of it is irrelevant to the current turn. The substrate loads only the segments relevant to the current turn, sized to the model’s natural prompt spaces, and tags the segments so the model can route attention at the structure rather than the prose. A segment that does not matter to the current turn costs zero tokens. The model spends its input budget on the segments that matter.
Transformation functions. The substrate’s intervention layer intercepts the model’s output. If the model returned a Legal? verdict that contradicts the rule book, the transformation function rewrites it. If the model returned a changesToMake string that references a forbidden field, the transformation function drops the change. If the model returned a soft ethics appeal in place of a verdict, the transformation function rewrites the verdict to isLegal = false with empty changesToMake and the legality rectifier re-runs the rule book. The world state never sees a malformed or ungrounded verdict. The marginal cost of the transformation function is zero tokens on the LLM bill. The savings show up as eliminated retries, eliminated reverted turns, eliminated game stalls.
Reasoning pipes at the same model tier. The reasoning pipe runs first, on the same 30B model as the main pipe, producing a structured ReasoningResponse data class. The reasoning pass’s output feeds into the main pipe’s prompt as pre-processed context. The main pipe does not have to “think inline” because the thinking already happened in a separate, typed, smaller-cost forward pass. The framework-as-brain design would have to encode the reasoning as free-form chain-of-thought inside the main prompt, burning 2× to 3× the input tokens, with output that is prose rather than structured fields.
The four mechanisms total roughly 1.1× to 1.3× the tokens a naive single-prompt design would consume, not 4× to 10× less. The savings come from the downstream effects: eliminated retries, eliminated malformed output, eliminated model self-verification overhead, eliminated chain-of-thought reasoning in the main prompt. The substrate’s economics are not “the model sees fewer tokens.” The substrate’s economics are “the system as a whole spends fewer tokens on the work that did not need the model.”
The framework-as-brain design pays the bill the substrate avoids
A framework-as-brain design (LangChain, LangGraph, CrewAI, AutoGen, Google ADK) has to solve the same four problems. The framework solves them by giving the model responsibility for them. That is the architectural fact that makes Ten Trillion Triangles TPipe extract capability from a 30B model the framework-as-brain design cannot match at any tier.
| Problem | Substrate design | Framework-as-brain design |
|---|---|---|
| Typed output | Schema injected into prompt; transformation function parses JSON | Prose output; framework does best-effort parse, often fails |
| Memory segmentation | Substrate loads only the relevant segments for the turn | Framework hands conversation history, full vector results, the whole kitchen sink |
| Verification | Transformation function rewrites the output before it reaches world state | Model is asked to self-verify in the same forward pass |
| Reasoning | Reasoning pipe runs structured pre-pass at same model tier | Free-form chain-of-thought burned into the main prompt |
Each row forces the framework-as-brain design to spend more tokens at lower accuracy. The 30B model that scores 99% under the substrate scores 60% under the framework. To recover the lost 39 percentage points, the framework has to scale to a frontier model. The substrate does not have to scale.
The scaling math is the entire post. Qwen 3 Coder 30B-A3B on Bedrock Flex costs $0.07725/M input tokens. Claude Opus 4.6 costs roughly $5/M input tokens. The factor is 65× on input alone. The composite per-turn cost difference is 30× to 40×. A framework-as-brain design that has to scale from Qwen 30B to Opus 4.6 to recover accuracy pays 30× to 40× more on inference. The substrate design that does not have to scale pays 1×.
The operator who runs the framework-as-brain design at consumer price points loses money on inference alone. Every $25 subscriber costs the operator $30 in Opus 4.6 bill. Every $50 subscriber costs the operator $60. The subscription model returns a negative gross margin on every customer. The product is unviable at the price point. The market segment closes.
The substrate design runs the same 30B model at the same workload. The operator does not scale. The 30B model is the deployment target. The $25 tier is comfortable. The market segment opens.
The interactive proof
The chart below is the actual math. Three sections. Section 1 shows what each turn costs under both architectures. Section 2 shows the per-user cost across multiplayer and single-player modes. Section 3 shows the $25 tier viability, which is how many games per month each architecture can afford at the same subscription price.
The numbers worth glancing at first:
| Turn type | Qwen 30B (substrate) | Opus 4.6 (brain-locked) | Multiplier |
|---|---|---|---|
| Human turn | $0.127 | $2.99 | 24× |
| AI player turn | $0.150 | $3.64 | 24× |
| NPC turn | $0.025 | $0.61 | 24× |
A complete R25 4-player multiplayer game runs $5.10 on Qwen Flex / $13.20 on Qwen Standard, vs roughly $153 on Opus 4.6. The per-user share at 4P multiplayer: $1.28 to $3.30 on Qwen 30B vs $38 on Opus 4.6. The $25 tier’s inference budget at 80% margin is $20. Qwen 30B through the substrate covers 6 to 16 games per month. Opus 4.6 in a brain-locked design covers 0.5 games per month. The tier is unviable.
Where the substrate’s extraction runs out
The substrate extracts capability from the model up to the model’s capability ceiling. The 30B model handles the autonomy check on the current rule book. The rule book grows. The model has to handle more. The architecture has to either scale up or partition harder.
The substrate’s answer is partitioning. The substrate’s primitives (Pipe, Connector, Splitter, Pipeline, Manifold, PumpStation, DistributionGrid) all partition the work. The work the model cannot do is partitioned to infrastructure. The work the model can do is partitioned to the model. The partitioning is auditable in the trace. The operator can see which partition is failing when the workload gets harder.
The framework-as-brain answer is “scale up the model.” The substrate’s answer is “refactor the partition.” The substrate’s answer scales with engineering effort. The framework’s answer scales with model cost. The substrate’s answer compounds. The framework’s answer compounds against the operator.
The 30B model handles the legality check. When the rule book grows to a point where the 30B model cannot hold the relevant subset in context, the substrate partitions the rule book into smaller segments. Each segment becomes a separate Pipe. The Pipes run in sequence, each one answering a fraction of the question. The model does not have to hold the whole rule book at once. The cost grows linearly with the rule book’s segmentation, not exponentially with the model’s capability ceiling.
The framework-as-brain design runs the same workload with the same rule book growth. The model has to hold the whole rule book in context because the framework has no primitive for partitioning the question. The model scales to Opus 4.6 to handle the load. The cost grows. The subscription tier has to grow with it. The market closes by degree.
The substrate’s partitioning is structural. The framework’s scaling is procurement. The substrate owns its own growth. The framework rents its growth.
The receipts
Every claim in this post cites the open-source Autogenesis codebase. The classifier at identifyPlayAgent.kt. The validator at validator.kt. The model wiring at globals/BedrockConfig.kt with the Qwen 3 Coder 30B-A3B identifier qwen.qwen3-coder-30b-a3b-v1:0. The cost numbers in the chart are from the Subscription & Inference Cost Model. Same trace-derived token basis the production model runs on.
Ten Trillion Triangles TPipe is the only architecture that extracts capability from a 30B model at the cost basis the consumer market requires. The substrate made the 30B model a viable deployment target at consumer price points. The same 30B model without the substrate is unviable at the same price points. The substrate owns the difference.
The cheapest game on Ten Trillion Triangles TPipe is the one where the model is not the brain. The model is the mouth. The substrate is the brain. The architecture is the differentiator.