Skip to main content

2  The Efficient ASI Hypothesis

2.1 Chapter status

Field	Value
Chapter ID	the-efficient-asi-hypothesis
Part	Part I - Foundations, Alignment, and Governance
Status	conceptual
Manuscript maturity	v0.2 manuscript draft
Last updated	2026-07-14
Primary source records	viea, rmi, cgs, rankfold_neuralfold, bbvca_v9, simulation_scaling, beastbrain, beastbrain_timeless, aletheia, moecot
Claim label	Design rationale
Evidence level	argument
Source queue	primary: viea, rmi, cgs; supporting: rankfold_neuralfold, bbvca_v9, simulation_scaling, beastbrain, beastbrain_timeless, aletheia; connector/recovery: moecot
Source loading state	source notes: viea, rmi, cgs, rankfold_neuralfold, bbvca_v9, simulation_scaling, beastbrain, beastbrain_timeless, aletheia, moecot, ext_scaling_laws_neural_language_models_2020, ext_chinchilla_compute_optimal_2022, ext_emergent_abilities_2022, ext_emergence_mirage_2023, precision_contract; raw cache: viea, rmi, cgs, rankfold_neuralfold, bbvca_v9, simulation_scaling, beastbrain, beastbrain_timeless, aletheia; connector/recovery: moecot
Test state	costed_route_record.valid.json passes protocol fixture validation for route state, task contract ref, outcome state, cost classes, hidden-cost checks, support-state effect, and non-claims. AsiStackProofs.Efficiency proves additive and componentwise-monotone seven-class cost accounting plus an executable finite selector whose result is listed, eligible, and minimum over authored eligible candidates; cheaper unauthorized and failed-quality routes do not displace it, and open-obligation promotion without a residual record is invalid. AsiStackProofs.ResourceEconomicsRefinement supplies the stronger nine-stage request-to-closure lifecycle, while python3 scripts/validate_efficiency_route_search_probe.py independently agrees on 2 synthetic route traces and rejects 6 expected-invalid controls. Route-search completeness, cost-estimate accuracy, measured efficiency, benchmark performance, model quality, and downstream compression utility remain open.

2.2 Drafting guardrail

Efficiency here means choosing and reusing cognition under a complete contract, not merely spending fewer tokens or preferring smaller models. The argument therefore begins with quality, authority, verification, residual, fallback, and total-cost accounting together. It does not claim that small models are sufficient for ASI, that scale is unnecessary, or that this repository has measured an efficiency gain.

It inherits the stack boundary from the opening frame and asks the first design question that boundary makes possible: where should cognition be spent, where should it be reused, and where should the remaining burden stay visible?

2.3 Human Reading Path

Concrete lens. Always-maximal routing is the strongest simpler baseline and may win on small or novel workloads. Always-cheapest routing may win only by weakening quality or moving repair outside the accounting boundary.

The stack is now defined, but it cannot remain only a governance diagram. A good architecture should spend high-cost cognition where the contract demands it, reuse prior work when it remains valid, and preserve enough evidence that shortcuts do not become hidden errors.

The important distinction is between thrift and recklessness. The architecture is not arguing that every task should be made cheap. It is arguing that cost, quality, authority, uncertainty, and residual work should be visible together, so the system can choose the smallest adequate route without pretending that adequacy has been proved when it has not. Efficiency is governed only when saved work remains visible.

The target is not austerity; it is measured adequacy under a trace that later layers can challenge. Efficiency becomes trustworthy only when the saving remains visible after verification and repair costs are paid. A cheap answer earns use only when the accounting survives review, and every apparent saving should carry the evidence debt that keeps thrift accountable when efficiency looks too easy elsewhere.

2.4 Problem

2.4.1 A concrete failure: the cheap route that hid its repair bill

Imagine a service that classifies one hundred supplier invoices. Three routes are authorized: a cached template for familiar layouts, a small model for ordinary cases, and a larger verifier for ambiguous currency and tax fields. The router reports a lower average latency after sending almost everything to the cached template. On the first dashboard the result looks like an efficiency win. A month later, an invoice from a new country exposes a decimal separator the template never represented. The downstream payment system accepts the wrong amount, an operator reconstructs the invoice, the route is rolled back, and every invoice touched by the template must be rechecked. The cheap route did not make the work cheaper; it moved verification and repair into a delayed, high-cost residual. This is an illustrative scenario, not a reported benchmark. Its purpose is to make the denominator visible.

2.4.2 Worked trace: useful work per total contract cost

State	Route decision	Cost or residual that must remain visible
R0 contract	Currency, tax, and supplier identity are fixed as the quality predicate.	A route cannot silently weaken the predicate.
R1 proposal	The cache proposes a parse with confidence and coverage metadata.	Cache lookup and coverage checks count as cost.
R2 verification	Novel format is sent to the larger verifier; familiar formats stay cached.	The fallback decision and rejected lower-cost route are recorded.
R3 acceptance	Only fields that satisfy the predicate become accepted work.	Unresolved invoices remain residuals, not successes.
R4 update	A repeated novel layout is compiled into a new procedure after review.	Compilation, regression tests, and rollback preparation enter the denominator.

The readable claim is simple: spend the expensive route where the contract needs it, and make every saved unit of work carry its remaining burden. The normative rule is to compare routes on accepted quality, total contract cost, and residuals together. The formal binding is the route record’s predicate, authority ceiling, verification outcome, fallback, and residual fields. The strongest simpler baseline is always-maximal routing. It can be better on a small or novel workload, which is why the hypothesis is conditional on repetition, route diversity, and a fixed predicate rather than a promise that the stack always wins.

The architecture needs a non-scale-only theory for how useful capability can increase without spending maximal cognition on every subtask.

ASI as a stack has an economic consequence. If every task is routed to the largest available model with the fullest available context, the system may look capable while burning verification budget, hiding residuals, and making repeated work non-durable. If every task is routed to the cheapest component, the system may look efficient while silently dropping constraints that only a stronger verifier, richer memory packet, or human review could preserve.

The efficient-ASI hypothesis is therefore not “small models are enough” and not “scale is unnecessary.” It is a claim about allocation. Efficient routing spends cognition where the current contract demands it, compiles repeated work into durable tools or memories, preserves fallback paths, and makes the unpaid residual visible. RMI supplies the ratchet language, CGS supplies the smallest-adequate-structure language, BBVCA v9 supplies exact repair and rate honesty, and Simulation Scaling supplies the reminder that feasibility is always contract-relative.

Efficiency in this book is always three-sided. A route must say what quality it preserved, what cost it paid, and what residual it left behind. Any two-sided account is suspect. Low cost without quality is failure. High quality without cost accounting is not an efficiency claim. Low cost and high apparent quality without residual accounting is often just deferred work.

2.5 Why existing approaches are insufficient

A scale-only allocation policy cannot, without additional state, select among routes using task-specific quality predicates, authority ceilings, total costs, residuals, or fallback readiness.

A scale-only account has no native place to record why a cheap route was adequate, why a costly route was necessary, what quality predicate was satisfied, what verification was skipped, or what residual burden remains. It also makes benchmarks too easy to misuse. A benchmark gain can represent genuine capability, prompt overfitting, hidden context cost, more human correction, a larger model invoked in the background, or a compression decision that moved complexity into an uncounted repair stream.

External comparison sharpens the accounting target. Sparse MoE work such as ext_sparse_moe_2017, ext_gshard_2020, ext_switch_transformer_2021, ext_expert_choice_routing_2022, and the ext_moe_llm_survey_2024 source note shows conditional computation, expert routing, sharding, communication overhead, stability, load balancing, and system constraints as efficiency surfaces. FrugalGPT-style routing in ext_frugalgpt_2023, Hybrid LLM in ext_hybrid_llm_2024, and RouteLLM in ext_routellm_2024 frame query-dependent cost-quality tradeoffs and learned route selection. LongLLMLingua in ext_longllmlingua_2023 frames prompt compression as a context-cost surface. Speculative decoding, multi-token prediction, Medusa, and EAGLE (ext_speculative_decoding_2022, ext_multi_token_prediction_2024, ext_medusa_2024, ext_eagle_2024) frame fast generation as a propose/verify/accept surface. BIG-bench in ext_bigbench_2022 shows why broad task suites can pressure capability claims without resolving hidden route cost or residual burden. The route-ledger design uses those records as baseline vocabulary for routed cognition and benchmark pressure, not as reproduced efficiency evidence for the ASI Stack.

Those external records also show the boundary of the claim. Conditional computation can reduce the amount of active model computation, but it does not by itself say whether the selected expert had authority, whether the route preserved a task predicate, or whether overload and fallback were recorded. Cost-aware cascades and learned routers can reduce visible spend, but they can also omit verification, repair, provenance, or human-review costs if the record is too narrow. Prompt compression and fast decoding can reduce context or latency cost, but they do not prove that downstream utility, citation faithfulness, tool authority, or residual obligations survived. Broad benchmarks can reveal scale-sensitive behavior, but they cannot by themselves tell whether a cheaper route preserved the same predicate under the same authority ceiling. Efficient ASI treats those families as partial cost surfaces that need a shared accounting interface.

The route ledger plays the same role for efficiency that the claim ledger plays for belief: without a record, success is ambiguous. A useful efficiency claim names the task contract, quality predicate, chosen route, rejected lower-cost routes, verification result, fallback route, residual obligations, and final cost. Without those fields, “efficient” becomes an aesthetic judgment rather than an architecture property. For the human reader, the route ledger is the receipt that distinguishes a genuine saving from a cost that has merely been moved elsewhere.

Self-improving systems sharpen the accounting problem. If a system can rewrite prompts, compile tools, cache procedures, add specialists, or change routing policy, then it can also make its own efficiency look better by moving costs out of view. The route ledger blocks that move by keeping verification, fallback, repair, human review, and regression costs attached to the route that caused them.

2.6 Core Claim

[the-efficient-asi-hypothesis.core, label: Design rationale, support: argument] On repeated workloads with multiple authorized routes, selecting the lowest-cost route that satisfies a fixed quality predicate and compiling reusable work can improve useful-task success per total contract cost over always-maximal and always-cheapest policies, provided authority, verification, residual, and fallback obligations remain intact.

The claim remains at argument support. RMI supports residual escrow and ratcheting, CGS supports smallest-adequate-structure reasoning, BBVCA and RankFold/NeuralFold support compression vocabulary, Simulation Scaling keeps feasibility tied to scope and fidelity, and Aletheia/BeastBrain variants support risk-weighted verification and routing vocabulary. None of those source notes is a reproduced efficiency benchmark in this repository.

2.6.1 Claim-source mapping status

Appendix C now maps this core claim to every assigned source note. Nine mappings also carry reviewed local raw-cache passage references in the manifest. The complete authenticated moecot connector text has been passage-reviewed; its private text is not published and runtime artifacts remain unimported. The mappings justify the design vocabulary, not measured efficiency.

Source	What it supports	Limit
viea	Routed work, workflow-to-tool compilation, durable artifacts, feedback, residuals, benchmarks, and regression coverage.	No reproduced route-cost measurements, deployment logs, or benchmark results.
rmi	Benchmark pressure, specialist attempts, loop closure, residual escrow, arm/router improvement, regression preservation, and harder frontiers.	Conceptual architecture here; no reproduced benchmark, prototype inspection, or proof from the note.
cgs	Smallest adequate structures with compact seeds, rule systems, memory/state, residual/error, verification, and governance interfaces.	No local CGS benchmark, proof, or implementation.
rankfold_neuralfold	Artifact-compression economics, residual bit cost, deterministic reconstruction, manifests, codec parameters, and checks.	No local compression benchmark, implementation artifact, or reproducible ratio.
bbvca_v9	Generate-verify-repair compression, reconstruction contracts, retained detail, residuals, repair streams, fallback, boundary costs, and proxy-rate honesty.	No BBVCA Prototype A implementation or reproduced compression ratio.
simulation_scaling	Contract-relative feasibility tied to scope, clockspeed, fidelity, efficiency, and bottlenecks.	Theoretical synthesis only here; no physical experiment or simulation benchmark.
beastbrain	Local state, persistent memory substrates, routing by semantic intent/tier/critical path/capability, and paging of attention, experts, and memory.	SSD-first, hardware, and performance claims remain source-reported.
beastbrain_timeless	Roadmap-independent BeastBrain framing for local intelligence, hardware adaptation, SSD-native memory, planning, verification, and multimodal interaction.	Does not validate hardware adaptation, geometric verification, or distributed scaling.
aletheia	Verification and context effort routed by risk, uncertainty, ambiguity, and historical failure.	No live-oracle, adversarial, or implementation evidence for route quality or efficiency.
moecot	Compact orchestration, specialist lanes, readiness gates, promotion blockers, residual tracking, ledgers, replay, and handoff.	Runtime and benchmark artifacts have not been ingested or reproduced.

2.7 The denominator of useful efficiency

The hypothesis rises or falls on its denominator. Raw tokens, model calls, latency, or accelerator time are useful measurements, but none is the object the architecture is trying to maximize. The numerator is useful accepted work: a task outcome that satisfies the prospectively fixed quality predicate, stays inside its authority ceiling, survives the required verification, and leaves its remaining obligations visible. The denominator is total contract cost: generation, context acquisition, routing, verification, repair, fallback, human review, rollback preparation, delayed failures, maintenance, and the opportunity cost imposed on other work.

This definition prevents three common substitutions. First, throughput is not usefulness: generating more candidates can increase verifier load while leaving accepted work unchanged. Second, local savings are not system savings: a smaller worker may transfer cost to a stronger reviewer, a human operator, or a later repair. Third, average cost is not enough when the cheap route creates a heavy tail of rare but expensive failures. A route is efficient only relative to a named task distribution, risk tier, baseline family, time horizon, and failure-accounting policy.

The comparison must include both obvious degenerate policies. An always_maximal policy asks the strongest available route to do every task; it can waste cognition and prevent reuse, but it supplies a serious quality baseline. An always_cheapest policy minimizes visible inference cost; it exposes whether governance is merely adding ceremony to a route that was already adequate. The proposed adaptive policy earns credit only if it improves useful accepted work per total contract cost over both, with matched task access, tuning effort, verification, fallback, and outcome observation.

Compilation and memory add a temporal dimension. The first execution of a procedure may cost more because the system creates a tested tool, cache, specialist, or proof artifact. Later executions may be cheaper, but only while the artifact’s assumptions, dependencies, authority, and regression tests remain current. Amortization is therefore versioned. A stale reusable artifact is not accumulated intelligence; it is deferred validation debt.

The hypothesis also has a natural weakening condition. On novel, high-uncertainty, or high-consequence work, the strongest route plus broad verification may dominate because route prediction is unreliable and errors are expensive. The architecture should be allowed to learn that selectivity has no value in such a regime. “Use minimum viable intelligence” is a policy candidate, not an axiom.

2.7.1 Scaling laws, emergence, and capability forecasting

Efficiency governance must reason about scale without turning an empirical fit into destiny. Kaplan et al. report power-law relationships between cross-entropy loss, model size, data, and compute in a bounded language-model regime. Hoffmann et al. show why the allocation matters: within their studied family, a smaller model trained on substantially more data outperformed larger undertrained systems under a comparable compute budget. The policy lesson is not one eternal parameter-to-token ratio. It is that model size, data quantity and quality, optimizer, architecture, training duration, and lifecycle cost must be planned jointly and re-fit when the regime changes.

A Scaling Forecast Record should bind:

• architecture, tokenizer, objective, optimizer, data mixture and quality;
• parameter, token, FLOP, wall-time, energy, hardware, and failure denominators;
• fitted response variable and why it matters;
• training range, uncertainty, residual structure, and break tests;
• downstream capability and risk metrics kept separate from training loss;
• prospective predictions, decision thresholds, and later backtests; and
• invalidation triggers for architecture, curriculum, post-training, retrieval, tool, routing, memory, or inference-time-compute changes.

The distinction between loss and capability is essential. A smooth cross-entropy curve can coexist with a task metric that appears to turn on abruptly. Wei et al. catalogue such apparent emergent abilities. Schaeffer, Miranda, and Koyejo show that discontinuous or nonlinear scoring can create apparent emergence from smoothly changing outputs in studied settings. Both observations matter: the former warns that operational capabilities may cross useful or dangerous thresholds; the latter warns that the threshold may be a measurement artifact.

The stack therefore does not choose “emergence is real” or “emergence is a mirage” as a global position. It runs a threshold protocol:

1. freeze the capability definition and operational consequence;
2. report continuous, probabilistic, and decision-threshold metrics together;
3. control prompt, contamination, model family, loss, and evaluation budget;
4. fit smooth and change-point alternatives prospectively;
5. test sensitivity to scoring resolution and aggregation;
6. backtest the forecast on later checkpoints without outcome-aware refitting;
7. stop or narrow authority when a risk-relevant threshold is crossed even if its mechanism remains uncertain; and
8. decline a broad emergence claim unless the transition survives alternate metrics, neighboring scales, seeds, and independent reproduction.

Forecasting is useful even when it is wrong—if the error is retained. A forecast residual can expose a new data regime, architecture interaction, evaluation artifact, or capability mechanism. Deleting the failed forecast would make scaling analysis look accurate while depriving the stack of its most important evidence. Model scaling, routed composition, retrieval, distillation, recurrence, test-time search, and tool use should compete on the same useful- outcome and lifecycle-cost frontier rather than receive separate accounting.

2.8 Alternatives, failure case, and decisive evidence

The strongest alternative explanation is that apparent routing gains come from task heterogeneity and benchmark leakage rather than an architectural advantage. Easy tasks are cheap for almost any policy, hard tasks are sent to the strongest model, and the router receives credit for a partition the benchmark already revealed. A second alternative is that a frontier model with prompt caching, speculative generation, and good tool use captures most of the benefit without a persistent specialist stack. A third is that verification and governance costs erase the savings once human time and long-tail repair are measured honestly.

A competent test must make those explanations compete. Freeze a natural task cohort before final evaluation; tune adaptive, always-maximal, always-cheapest, and strong monolithic-with-tools baselines under matched budgets; prevent outcome-aware rescue; and report the joint frontier of accepted-task success, unsafe release, false refusal, latency, compute, reviewer burden, repair, rollback, and maintenance. Route-selection accuracy is secondary: a router can choose the nominal expert and still produce no useful answer.

The decisive failure case is a hidden-cost win. Suppose the adaptive route uses half the model compute and passes the immediate test suite, but it doubles review time, misses a policy dependency, and requires a later rollback. The route is neither efficient nor safely adequate, even if a token-only dashboard calls it a success. The ledger must attach those downstream effects to the decision that caused them.

Evidence would change the conclusion in either direction. Repeated, source-disjoint natural workloads showing a robust improvement over all strong matched baselines would support a bounded efficiency claim for that task and deployment envelope. Results showing no advantage after full lifecycle cost, unstable gains across seeds or domains, systematic tail failures, or an always-maximal/monolithic baseline matching the frontier at lower governance cost would narrow or reject the hypothesis. This repository has not yet run that decisive comparison; the chapter remains an argument and a measurement contract.

2.9 Mechanism

Efficiency becomes meaningful only when the stack records what it chose not to spend. VIEA keeps work durable through artifacts, feedback, and regression coverage. RMI turns solved and unsolved work into ratchet pressure and residual escrow. CGS asks whether the structure is the smallest adequate one, while BBVCA v9 and RankFold/NeuralFold expose repair and residual costs for compression. Simulation Scaling keeps feasibility tied to scope and fidelity. BeastBrain and MoECOT keep routing and specialist-lane economics visible, and Aletheia prevents verification effort from being counted as optional decoration.

The concrete mechanism is a costed route ledger around a minimum-viable-intelligence decision.

flowchart LR
  A["Task contract"] --> B["Quality predicate"]
  A --> C["Authority ceiling"]
  B --> D["Capability profile"]
  C --> D
  D --> E{"Lowest authorized route<br/>that can satisfy predicate?"}
  E -- "yes" --> F["Small route"]
  E -- "no" --> G["Escalated specialist / human route"]
  F --> H["Artifact"]
  G --> H
  H --> I["Verification"]
  I -- "pass" --> J["Regression / tool / memory candidate"]
  I -- "partial or fail" --> K["Residual + fallback route"]
  K --> D

How to read the route ledger: The route ledger starts with the task contract, quality predicate, and authority ceiling before it selects any route. The cheap path is valid only when verification passes; partial results loop back as residuals and fallback work rather than being counted as efficiency.

The route ledger turns “use minimum viable intelligence” into a reviewable decision rather than a slogan. The system tries to spend only the cognition the contract demands, but it must also say which cheaper routes were rejected, which stronger route remains available, and what residual burden survives the result. Repeated cognition should harden into durable artifacts, tools, procedural memory, specialist arms, or regression tests. Compression should be counted only after the verifier and repair path expose what the compact representation did not carry.

RMI gives the route decision a ratchet: solved work should become regression coverage, reusable tools, specialist arms, or procedural memory; unsolved work should become residual escrow rather than narrative success. CGS gives the route decision its compactness test: a small seed, rule system, memory, residual, verifier, and governance interface is useful only when it remains adequate for the target. BBVCA v9 gives the compression analogue: generated structure is counted only after verification and exact repair. Simulation Scaling prevents the architecture from treating simulated or synthetic evaluation as free; scope, fidelity, clockspeed, and bottlenecks have to be in the contract.

The output is not a vague “use the cheapest model” policy. It is a record that explains why a route was adequate for a task and what it failed to discharge. A route can be useful while still failing to prove efficiency; a route can be cheap while still creating too much repair; and a route can be powerful while still being wasteful if its output never becomes reusable evidence.

2.9.1 Route outcome states

The ledger also gives efficiency a set of outcome states:

Outcome	Meaning	Promotion consequence
adequate_minimum	The selected route satisfied the predicate, lower-cost authorized candidates were absent or failed, and residuals are recorded.	Candidate for tool, memory, regression, or field qualification.
adequate_overkill	The result passed, but a lower-cost route was not examined or not recorded.	Useful output; no efficiency promotion.
cheap_brittle	The route was low cost but failed quality, verification, or residual checks.	Residual escrow and fallback route required.
hidden_cost	The visible route passed, but repair, verification, context, or human-review cost was omitted.	Efficiency claim blocked until accounting is complete.
unsafe_saving	The route saved cost by bypassing authority, approval, verification, or rollback.	Quarantine or denial, not promotion.

These are not benchmark results. They are accounting states. They let a future implementation report that a route was useful without pretending it was efficient, or report that a route was efficient without hiding the work that made it safe enough to use.

2.9.2 Functional precision as one routed resource

The stack can route numerical precision just as it routes model capacity, context, search, deliberation, tools, and verification. A low-cost representation may be adequate for one protected contract and inadequate for another. The route may add residual precision, switch kernels, invoke the reference artifact, abstain, or escalate. This is architectural self-improvement only when the new route is qualified, observable, reversible, and cheaper on the joint quality-and-cost frontier.

Bits per weight are therefore not the efficiency objective. The denominator includes complete executable description, moved bytes, decode work, latency, energy, memory pressure, verification, routing, fallback, repair, assurance generation, and certificate renewal. The numerator is preserved useful behavior under a declared contract, including rare and high-consequence slices. A representation-independent universal optimum is neither assumed nor needed.

Precision joins other resources through substitution tests. If a stronger model at lower precision, a smaller model at higher precision, more retrieval, more verification, or a static mixed-precision baseline satisfies the contract more cheaply, the ledger should choose it. Dynamic precision earns a place only where its complete routed policy improves the measured frontier rather than merely shrinking the visible checkpoint.

2.10 Interfaces

Efficiency decisions travel through the Costed Route Record.

• Planning requests capability profiles.
• Routing selects specialists.
• Evidence decides whether efficiency claims survived quality and cost tests.

Minimum fields:

• task_id
• route_state
• task_contract_ref
• quality_predicate
• authority_ceiling
• candidate_routes
• selected_route
• rejected_lower_cost_routes
• verification_result
• outcome_state
• cost_accounting
• cost_classes
• hidden_cost_checks
• residual_obligations
• fallback_route
• promotion_candidate
• support_state_effect
• non_claims

Planning supplies the task contract and quality predicate. Routing proposes candidate routes. Governance checks authority ceilings. Execution produces the artifact. Evidence decides whether the cost/quality result is strong enough to compile into a tool, regression, memory, or capability field. Any open obligation remains attached to the route record.

A complete record should also distinguish cost classes:

• model/runtime cost
• context construction cost
• verification cost
• repair cost
• human-review cost
• regression-maintenance cost
• rollback or residual cost

This distinction matters because different layers can optimize different costs while making the whole system worse. A router may reduce model tokens by increasing context-packaging burden. A compressor may reduce storage while increasing repair. A policy update may reduce latency while increasing human review. Total-contract accounting counts the whole route, not only the cheapest visible meter.

2.11 Invariants

• Every efficiency claim names a fixed quality predicate and total contract cost.
• Every compression claim records downstream utility checks, repair cost, and residual obligations.
• Every admitted cheap or compressed route records a tested fallback or an explicit fallback-unavailable state.
• Context construction, verification, repair, human review, regression maintenance, rollback, and residual costs remain attributed to the route that caused them.
• No route may be classified as efficient by bypassing authority, approval, verification, or rollback gates.

Comparison is the efficiency hypothesis’s strongest invariant: a route is minimum viable only relative to a declared quality predicate, authority ceiling, and candidate set. If a lower-cost route was not tried, was unauthorized, or failed the predicate, the record should say so. If the system cannot reconstruct that comparison, the efficiency claim should stay as design rationale rather than measurement.

The route ledger also preserves rejected alternatives, because hidden rejections can make an apparently efficient path look cheaper than it was.

2.12 Failure modes

• Cheap inference mistaken for intelligence.
• Critical context compressed away.
• Benchmark gains that increase hidden residual burden.

The failure pattern is not only wasting compute. It is misaccounting. Cheap inference mistaken for intelligence produces brittle success. Excessive routing to frontier models hides the fact that no reusable capability was built. Compression can make the route look cheap while moving complexity into uncounted repair. Benchmarks can improve while residual escrow grows. The remedy is not a slogan about scale; it is a ledger that keeps quality, cost, residual, and fallback coupled.

Efficiency laundering is the central economic failure: the system chooses a faster path, reports the speedup, and omits the verification, fallback, review, and failure-case costs that made the path acceptable. If those costs are outside the bill, the architecture may prefer a route that is cheaper only because the expensive parts became invisible.

2.13 Minimum Viable Implementation

Start with a costed_route_record schema plus one valid fixture. It should not claim empirical efficiency. It should only prove that the book can represent the decision boundary it is asking future systems to test: task, route state, task contract, predicate, route choices, outcome state, cost accounting, cost classes, hidden-cost checks, verification result, residual obligations, fallback, support-state effect, and non-claims.

A three-route comparison is the first honest efficiency fixture: one cheap route rejected because verification fails, one expensive route accepted because it satisfies the predicate, and one compressed route blocked because repair burden exceeds savings. Lean now supplies an executable finite selector over seven explicit cost classes and proves that any selected route is listed, eligible, and minimum among the authored eligible candidates. The independent synthetic route-search probe agrees on two bounded traces and rejects lower-cost eligible route omission, hidden-cost class omission, erased residuals, compression-utility overclaim, authority bypass, and missing negative controls. Its scope is accounting and selection discipline only; candidate-set completeness and empirical truth of cost or quality declarations remain outside it.

The minimum is useful when a rejected low-cost path remains as visible as the accepted path.

2.14 Mature Research Target

The beyond-SOTA target is a governed route economy for cognition, not a larger model, a cheaper model, or a single acceleration trick. Conditional-computation systems, model cascades, compression schemes, fast-generation methods, and broad benchmark suites each attack one cost surface. A mature Efficient ASI stack would make those surfaces comparable by forcing every route to carry the same contract: task predicate, authority ceiling, selected and rejected candidates, visible cost classes, verification result, fallback path, residual obligations, and support-state effect.

In that endpoint, capability grows because the system learns where expensive cognition is actually necessary and where prior work can be reused without losing the predicate. Repeated work becomes tools, memories, regressions, proofs, route policies, or capability-field candidates. Compressed work carries repair contracts. Specialist lanes compete under readiness gates. Benchmarks measure not only visible score but residual burden, hidden cost, fallback cost, and regression survival. A route that merely saves tokens is not efficient until it survives the whole accounting surface.

That endpoint would outgrow both scale-only and cheap-route-only framings. Scale remains available when the contract requires it; smaller or faster routes earn use only when they preserve quality, authority, and residual honesty. The efficient-ASI claim remains at argument until route ledgers, lower-cost comparison traces, residual-accounting tests, hidden-cost audits, and quality/cost benchmarks show that cheaper cognition actually preserves the required predicates.

2.15 Codex test plan

Test	Purpose	Status
Costed route record validation	Check that the route fixture records route state, task contract, quality predicate, authority ceiling, route candidates, selected route, rejected lower-cost routes, verification result, outcome state, cost accounting, cost classes, hidden-cost checks, residual obligations, fallback, support-state effect, and non-claims.	implemented by protocol validation; validated locally
Finite minimum selector	Check that a selected route is listed and eligible, has minimum complete seven-class modeled cost among eligible candidates, and is not displaced by cheaper unauthorized or failed-quality routes.	implemented in AsiStackProofs.Efficiency with two independently matched route traces; route-search completeness, cost-estimate accuracy, and measured efficiency not proved
Open-obligation residual negative case	Check that a promotion candidate with open obligations and no residual record rejects the finite residual-promotion predicate.	implemented in AsiStackProofs.Efficiency; residual-burden measurement and utility preservation not proved
Governed route-economy lifecycle	Check that a route-economy claim moves through scoped request, resource budgeting, capacity reservation, scheduling, execution, verification, transfer, spend reconciliation, and closure while preserving identities, authority ceilings, useful-outcome/resource-bill separation, residuals, recovery, evidence transitions, and non-claims.	implemented in AsiStackProofs.ResourceEconomicsRefinement; the independently implemented refinement consumer covers all 66 routes and rejects 57 non-accepting mutations; measured efficiency, route-search completeness, cost-estimate accuracy, route quality, residual-burden measurement, benchmark performance, and support-state promotion are not proved
Efficiency route-search probe	Independently run the finite minimum selector on two bounded synthetic route traces plus expected-invalid controls for lower-cost eligible omission, hidden-cost class omission, erased residuals, compression-utility overclaim, authority bypass, and missing negative controls.	implemented by python3 scripts/validate_efficiency_route_search_probe.py; 2/2 selector agreements and 6 expected-invalid controls; no route-search completeness, cost-estimate accuracy, measured efficiency, model quality, compression utility, benchmark performance, or support-state claim
Minimum viable route test	Check whether a lower-cost authorized route fails the declared quality predicate before a higher-cost route is selected.	partially implemented by synthetic route-search probe over finite candidate sets; route-search completeness and cost-estimate accuracy not proved
Residual burden accounting test	Check that unresolved obligations remain attached to the route record instead of being hidden inside a success label.	partially implemented by synthetic route-search probe; behavioral residual-burden measurement not proved
Utility-preserving compression test	Check whether a compressed or generated representation preserves the downstream task utility claimed for it.	partially implemented by synthetic route-search probe’s compression-utility overclaim rejection; downstream compression utility not proved
Hidden-cost audit	Check that verification, repair, context, human-review, regression, and rollback costs are represented before an efficiency claim is promoted.	partially implemented by synthetic route-search probe’s cost-class audit; measured hidden-cost accounting not proved

2.15.1 Formalization hooks

Tag	Module	Target	Status
lean:efficiency.minimum_viable.operational_invariant	AsiStackProofs.Efficiency	The executable finite selector returns only a listed eligible route whose complete seven-class modeled total is no greater than every eligible candidate; cheaper unauthorized and failed-quality routes cannot displace the bounded minimum.	implemented
lean:efficiency.minimum_viable.failure_blocks_promotion	AsiStackProofs.Efficiency	A promoted result with open obligations and no residual record causes the finite residual-promotion predicate to fail.	implemented
lean:efficiency.claim_admission_lifecycle_route	AsiStackProofs.ResourceEconomicsRefinement	A reachable nine-stage route-economy lifecycle requires scoped request identities, complete resource and hidden-cost accounting, protected capacity, fallback, actual spend, useful-outcome and resource-bill separation, verification, residual and recovery records, reconciliation, evidence transition, and closure without support or external-effect authority.	implemented
lean:efficiency.route_search.probe_fixture_bridge	AsiStackProofs.ResourceEconomicsRefinement	The independent synthetic route-search consumer computes two valid and six expected-invalid outcomes over fourteen candidates, while the reachable lifecycle supplies the formal cost, verification, residual, fallback, reconciliation, and no-authority boundary; neither asset is treated as measured efficiency or complete search.	implemented

The formal and executable responsibilities are deliberately separated. AsiStackProofs.Efficiency owns complete seven-class cost addition and monotonicity, an executable finite selector, universal membership, eligibility, and minimum-cost consequences, concrete nonvacuity witnesses, and the residual promotion rejection. Its modeled minimum is conditional on the authored candidate set and declarations. The previous theorem-per-Boolean admission checklist and three theorems over a hand-entered probe summary were retired: normalizing one edited fixture or restating copied result counts did not add semantic evidence.

The broader policy now lives with the route economy it actually governs. AsiStackProofs.ResourceEconomicsRefinement models a reachable request-to- closure lifecycle with identity continuity, authority rejection, protected capacity, direct and displaced costs, verification, useful-outcome/resource- bill separation, residuals, recovery, reconciliation, and closure. Its independent consumer exercises all 66 routes and 57 rejecting mutations. The efficiency route-search script separately derives its two passing traces and six rejected controls from candidate eligibility and cost arithmetic instead of trusting a Lean summary literal. Together these assets organize the idea; they do not prove route-search completeness, cost-estimate accuracy, quality evaluation, measured efficiency, residual-burden measurement, benchmark performance, support-state promotion, model quality, or compression utility.

2.16 Source crosswalk

Source ID	Title	Layer	Planned use	Readiness
viea	Verified Intent-to-Execution Architecture	whole_stack_execution_spine	Keystone source. Human intent -> command contracts -> artifacts -> routing -> runtime targets -> verification -> deployment -> feedback.	source note available; local raw cache available
rmi	Ratcheting Modular Intelligence	capability_ratchet	Benchmark pressure, residual escrow, verified modular capability, regression preservation.	source note available; local raw cache available
cgs	Compact Generative Systems	compression_representation	Smallest adequate structure that can generate/govern target without hiding residual complexity.	source note available; local raw cache available
rankfold_neuralfold	RankFold + NeuralFold	compression_representation	Tensor/artifact compression. Low-rank residual coding plus functional preprocessing and probe-route fallback.	source note available; local raw cache available
bbvca_v9	BBVCA_v9_final_public_release	compression_representation	Prefer v9. Generate-verify-repair compression from seeded local laws, bounded search, two-phase rate discipline.	source note available; local raw cache available
simulation_scaling	Simulation Scaling Law	compute_fidelity_constraints	Resource constraints on scope, clockspeed, and fidelity in simulations.	source note available; local raw cache available
beastbrain	BeastBrain Cognitive Architecture	whole_stack_lineage	Architecture lineage. Organism paradigm, SSD-native/geometrically verified intelligence.	source note available; local raw cache available
beastbrain_timeless	BeastBrain Architecture: Timeless Edition	whole_stack_lineage	Definitive standalone master plan variant.	source note available; local raw cache available
aletheia	Aletheia Foundry	safe_general_intelligence_lineage	Safe general intelligence predecessor. Use ideas; avoid final branding if collision remains.	source note available; local raw cache available
moecot	MoECOT-Agent Architecture Whitepaper	implementation_reference	Concrete implementation evidence: governed low-parameter multi-core runtime, readiness gates, ledgers, replay.	source note available; connector or recovery required

The crosswalk bounds efficiency claims: sources supply design language, while measured support requires route runs, baselines, costs, residuals, and negative results.

2.16.1 External comparator crosswalk

The external comparator set is now wider than the original three-record anchor. It remains comparator-only: these sources define nearby mechanisms and failure pressures, while the ASI Stack still needs local route ledgers, baselines, negative controls, residual accounting, and accepted evidence transitions before any efficiency support-state promotion.

Comparator family	Source IDs	What Efficient ASI imports	Boundary
Sparse and distributed MoE	ext_sparse_moe_2017, ext_gshard_2020, ext_switch_transformer_2021, ext_expert_choice_routing_2022, ext_moe_llm_survey_2024	Conditional computation, expert routing, sharding, communication/stability cost, capacity/load pressure, and MoE taxonomy.	No local MoE training, router-quality measurement, sparse-model benchmark, or distributed-system result.
Query and learned routing	ext_frugalgpt_2023, ext_hybrid_llm_2024, ext_routellm_2024	Cost-quality cascades, query-difficulty routing, stronger/weaker model routing, and preference-data route learning.	No reproduced costs, query datasets, route policies, preference training, or route optimality claim.
Context and representation compression	ext_longllmlingua_2023 plus local cgs, rankfold_neuralfold, and bbvca_v9	Context-cost pressure, prompt compression, residual burden, fallback, and repair accounting.	No local prompt-compression benchmark, compression ratio, semantic-utility result, or repair-cost measurement.
Fast generation	ext_speculative_decoding_2022, ext_multi_token_prediction_2024, ext_medusa_2024, ext_eagle_2024	Draft/verify/accept accounting, future-token proposal heads, multi-head candidate generation, feature-level drafting, acceptance rate, and verifier cost.	No local speedup, quality preservation, distribution-preservation audit, MTP model, or workload transfer claim.
Benchmark pressure	ext_bigbench_2022	Broad capability-suite pressure and the need to separate score, cost, residuals, and hidden route work.	No BIG-bench reproduction, benchmark score, or general capability claim.

2.16.2 Manifest source assignment reconciliation

These rows keep The Efficient ASI Hypothesis’s manifest assignments visible at their recorded review boundary. Passage review does not establish local reproduction, performance, safety, deployment, or support-state movement.

Source	Intake role	Boundary
ext_scaling_laws_neural_language_models_2020	Passage-reviewed comparator: Scaling Laws for Neural Language Models. Supplies empirical prior art for smooth loss scaling with model size, data, and compute inside the studied language-model family, establishing why route and capability planning should use fitted curves rather than scale folklore.	The reported relationships are metric-, architecture-, data-, and regime-bound; this repository has not reproduced the runs, and loss scaling is not a downstream-capability or safety forecast. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_chinchilla_compute_optimal_2022	Passage-reviewed comparator: Training Compute-Optimal Large Language Models. Supplies the compute-allocation result that parameter count and training-token count must be optimized jointly, countering the assumption that the largest parameter count is automatically the most efficient use of a fixed budget.	The optimum is fitted within the authors’ model, data, and compute regime; the repository has not reproduced the training campaign and does not treat the prescription as architecture-independent. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_emergent_abilities_2022	Passage-reviewed comparator: Emergent Abilities of Large Language Models. Provides evidence that some benchmark scores appeared discontinuous across reported model scales, motivating threshold surveillance and held-out capability probes rather than assuming every measured ability improves smoothly.	The catalogued effects depend on model family, prompting, task, and metric and do not establish prospective predictability or abrupt underlying mechanism changes. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
ext_emergence_mirage_2023	Passage-reviewed comparator: Are Emergent Abilities of Large Language Models a Mirage?. Provides the necessary measurement counterweight: discontinuous scoring rules can transform smoothly improving outputs into apparently abrupt benchmark abilities.	The result explains studied apparent discontinuities but does not prove that every capability transition is smooth, measurement-induced, or operationally harmless. No local implementation, reproduction, performance, safety, deployment, support-state, or ASI result is established by this reconciliation row.
precision_contract	Metadata-first comparator: The Precision Contract: A Functional Rate–Distortion Theory for Behavior-Preserving Neural Computation. Corben-authored July 2026 theoretical and systems paper replacing universal per-weight precision questions with a contract-relative functional rate-distortion problem over complete executable descriptions. It proposes representation canonicalization, protected-behavior contracts, precision fields, progressive base/residual encoding, dynamic routing, full physical and assurance-cost accounting, a Functional Precision Compiler, and scoped precision certificates. Existing chapters are upgraded first; no universal bit bound, implemented compiler, preserved-behavior result, efficiency result, certificate validity, support promotion, SOTA, AGI, or ASI claim is inferred.	No passage-level source claim, local implementation, reproduction, safety, performance, deployment, support-state, or ASI result is established by this reconciliation row.

2.17 Summary

The efficient path to advanced capability is an economy of cognition. Capability grows when work can move to the smallest adequate capability, solved work can be reused, lawful structure can be compressed without hiding repair cost, and fallback routes remain available when the cheap path is not enough.

The discipline is accounting. A route is not efficient because it is small, fast, or elegant. It is efficient when the record shows what quality predicate it satisfied, what it cost, which alternatives were rejected, what residual remains, and what fallback is available. That requirement keeps efficiency tied to evidence instead of aesthetic compression. It also keeps cheap cognition from becoming an authority leak. The stack may prefer a smaller model, cached proof, compressed artifact, specialist core, or generated reconstruction only when the surrounding record still shows permission, adequacy, verification burden, and rollback. Efficiency without those records is just hidden risk.

2.18 Evidence reconciliation (2026-07-16)

The invariant protocol, field meanings, and inference limits are stated once in Living Book Methodology. This packet contains only the chapter-specific projection; its authoritative per-atom rows are the the-efficient-asi-hypothesis slice of experiments/claim_family_terminal_coverage/results/result.json.

The core remains blocked after full attempt at argument support. The strongest family attempt was Governed usefulness confirmatory campaign. Its exact boundary is: Bounded local non-core governance effect only; no family-wide truth, transfer, deployment, or chapter-core promotion. Across 24 atoms, the terminal ledger records 19 blocked_after_full_attempt; 5 retained_after_full_attempt.

Chapter-specific field	Value
Family / atom denominator	CF-01 / 24 atoms
Terminal dispositions	19 blocked_after_full_attempt; 5 retained_after_full_attempt
Core	the-efficient-asi-hypothesis.core: blocked_after_full_attempt at argument
Core attempted / missing lanes	executable, formal, source-synthesis / causal, empirical, normative, transfer
Attempted local lanes	executable, formal, source-synthesis
Missing or unproved lanes	causal, empirical, executable, formal, normative, transfer
Strongest family bundle	Governed usefulness confirmatory campaign (natural_work): One fresh 16-task held-out local confirmatory denominator after a separately frozen 40-candidate tuning pool.
Negative controls	simple baseline; evidence-freshness ablation; six co-primary checks; validator-owned laundering mutations.
Accepted transitions	v1_0_pilot.efficient_asi.no_change
Maximum inference	Bounded local non-core governance effect only; no family-wide truth, transfer, deployment, or chapter-core promotion.
Reproduction / next burden	Replay scripts/validate_p4_governed_usefulness_confirmatory.py and scripts/validate_claim_family_terminal_program.py; fill the named atom-specific lanes under a new prospective protocol.

2.19 Handoff

The efficiency denominator is incomplete until every candidate route knows where permission stops. System Boundaries and Authority therefore takes the route ledger’s task, quality, fallback, and cost fields and binds them to a principal, grant, lease, scope, ceiling, and revocation state. A cheaper route that widens authority is an unsafe saving, not evidence for this hypothesis.