The Most Expensive Model Is Often Compensation for Missing Control Tony Malott · Published 2026-07-27 https://shareplane.malott.ai/artifacts/the-most-expensive-model-is-often-compensation-for-missing-control/ Authored Systems Work The Most Expensive Model Is Often Compensation for Missing Control Why trust gets cheaper when intent, routing, and validation get stronger Trusted completion cost falls when intent, authority, routing, and validation carry their share of the work. By Tony Malott Published 2026-07-27 12 min Deep thesis Status Published Release Canonical URL Preview copy. This is Semantic Candidate v02, not the final SharePlane semantic lock. Why trust gets cheaper when intent, routing, and validation get stronger For a while, I used the strongest coding model I could get for nearly everything. I gave it the highest reasoning setting. I used it for hard architecture problems, but I also used it for work that should have been routine. I watched my weekly token allowance disappear fast enough that I started planning around the limit. I told myself I was paying for quality. That was only partly true. A lot of what I was buying was reassurance. I had been burned before. An agent misunderstood my intent. Context was incomplete. Instructions left room for interpretation. A tool was unavailable. Authority was ambiguous. Work passed one test and failed somewhere else. A technically valid change turned out not to be the change I wanted. Some of that scar tissue came from the technology. Much of it came from me not yet giving the system everything it needed. My response was predictable. I reached for more intelligence. That worked often enough to reinforce the habit. A stronger model could infer missing context, recover from weak instructions, notice contradictions, and reason its way around gaps. It felt safer. It was also an expensive substitute for architecture. The model was covering for the system The model was not the only thing doing work. It was also compensating for work I had not finished around it. I had not fully separated semantic judgment from implementation. I had not encoded every authority boundary. My agent instructions were still evolving. The right tools were not always present in the right lane. Validation existed, but it was not yet complete enough for me to trust a cheaper route without watching it closely. So I overprovisioned reasoning. We do this everywhere in technology. When the architecture is weak, we buy a larger server. When the data is disorganized, we buy a more powerful search platform. When the operating process is unclear, we add people. When AI execution is not trustworthy, we assign the strongest model to every task. The purchase may reduce pain. It does not remove the cause. A frontier model can reason through ambiguity. It cannot decide which ambiguity should have existed in the first place. It cannot manufacture legitimate authority. It cannot prove that the requested outcome was the right outcome. It cannot replace an independent validator by sounding confident. The model can help operate the system. The model cannot be the entire system. What changed The biggest improvement did not come from a new model release. The operating system around the models matured. I started doing the hardest semantic work before implementation. I worked through intent, architecture, public and private boundaries, evidence, acceptance criteria, and design decisions with ChatGPT before handing anything to Codex. That changed the shape of the work. Codex no longer had to discover the thesis while writing the code. It did not have to decide whether a boundary was intentional. It did not have to guess which source was authoritative. It received a smaller, clearer execution problem. I also learned that more implementation work could happen directly in ChatGPT than I had assumed. Bounded HTML, exact issue updates, repository inspection, workflow review, and narrow file work did not always require a separate coding lane. Codex remained essential for repository-local depth, bulk transformations, builds, tests, generated outputs, and sustained implementation. It stopped being the default destination for every mechanical action merely because code was involved. Then the model router became useful. Instead of selecting the strongest route out of habit, I started assigning the route based on the job. Luna handles routine governed implementation and mechanical transformation. Terra handles investigation, reconciliation, repair, and moderate ambiguity. Sol is reserved for difficult semantic adjudication, novel architecture, and high-consequence exceptions. Those names describe my current SharePlane routing convention. They are not universal claims about what any model can or cannot do. The important principle is the separation. The route should reflect the work. Fear should not be the router. The token curve collapsed The difference was immediate enough to be obvious. Work became faster. Token consumption became dramatically lighter. The weekly limit stopped feeling like an operational constraint. Jobs that once would have gone automatically to the highest route completed on a lower route with less intervention because the surrounding controls carried more of the burden. The smaller model did not become more intelligent. The task became less ambiguous. That distinction matters. A bounded instruction is an intelligence multiplier because it removes irrelevant uncertainty. Exact authority removes branches the model should never explore. A validator removes the need to trust a probabilistic self-assessment. A clear stop condition prevents a routine defect from becoming an unauthorized repair campaign. A good context package keeps the model from spending tokens rediscovering decisions already made. The model uses less reasoning because the system asks a better question. The Intelligence Stack Trusted intelligence is distributed across coordinated layers: Owner intent and acceptance — the human defines the outcome and retains acceptance. Semantic and architectural collaboration — meaning, design, contradiction, and boundaries are resolved upstream. Context and authority package — the execution lane receives the current sources, scope, and stop conditions. Model router — Luna handles routine governed implementation, Terra handles investigation and repair, and Sol handles difficult semantic adjudication and high-consequence exceptions. Codex execution — repository-local work happens inside a bounded checkout and owned path set. Deterministic tools and validators — builds, tests, schemas, and checks establish evidence outside model confidence. Receipts and recovery — the result remains inspectable, attributable, and recoverable. The flow runs from owner intent toward a trusted outcome. When evidence exposes ambiguity or failure, the work moves back through a bounded escalation path rather than silently widening authority. Trust became an engineered property Before, my trust model looked something like this: Weak specification + incomplete context + broad autonomy + expensive model = fragile confidence Now it looks closer to this: Clear intent + bounded authority + appropriate model + deterministic validation = scalable confidence That is the real change. The token reduction is useful. The architecture is valuable. I no longer have to trust a model because it is the most capable option available. I can trust the execution because the authority is explicit, the mutation is bounded, the route is appropriate, the validators are independent, and the owner gate remains intact. The intelligence is distributed across the system. I contribute intent, judgment, and acceptance. ChatGPT helps resolve semantics, architecture, design, contradiction, and execution packaging. The router assigns the right reasoning tier. Codex performs repository-local execution. Tools perform deterministic work. Validators prove mechanical conditions. Receipts preserve what happened. No single component has to be brilliant enough to compensate for everything the others failed to provide. The cheapest model is not the goal This can be misunderstood as an argument for always choosing the smallest model. It is not. A cheap model with weak instructions can burn more tokens through retries, load more context than necessary, make subtle errors, and create expensive rework. Routing itself adds complexity. Controls take time to design. Validators take effort to maintain. A strong model may be the most economical route when the problem is genuinely ambiguous or the consequence of misunderstanding is high. The objective is not minimum token cost. The objective is minimum trusted completion cost. That includes model consumption, human attention, retries, CI, infrastructure, elapsed time, correction passes, and the cost of defects that escape. A model that costs less per token but requires three attempts is not automatically cheaper. A model that completes the task on the first attempt but uses authority it did not have is not successful. A workflow that saves tokens while increasing owner intervention is not optimized. The result must be correct, authorized, validated, recoverable, and accepted. Then we can discuss whether it was efficient. Measure the outcome, not the meter Raw token consumption is easy to watch. That makes it dangerous. We tend to optimize whatever displays a number, even when the number captures only one part of the system. A better measurement set includes: cost per owner-accepted outcome; model and reasoning route; elapsed time; retries and correction passes; validation failures; owner interventions; escalations to stronger reasoning; semantic defects versus mechanical defects; CI and infrastructure consumption; work completed upstream before repository execution. The most important question is not how many tokens the agent used. It is how much the complete trusted result cost. The expensive model should be the exception handler I still want the strongest model available. I just no longer want to waste it on work that should have been made deterministic. Frontier reasoning belongs where the ambiguity is real: architecture, semantic conflict, novel synthesis, incomplete evidence, competing authorities, and decisions where the cost of misunderstanding is high. It should not be a permanent tax on unclear instructions. That is the larger lesson from this phase of building SharePlane. I thought I needed the strongest model because I did not trust AI-assisted development. What I actually needed was a system I could trust. Once I built more of that system, the economics changed on their own. The most expensive model was not always buying better work. Sometimes it was paying the interest on missing control. Evidence behind the thesis Check the work, not just the conclusion. Public research, authority, lineage, and author testimony are labeled separately. Sources can corroborate, challenge, or bound the argument; they do not replace Tony Malott's judgment. Portable public record Take the complete artifact with you. The deterministic package contains a self-contained offline article, the exact public-route snapshot, canonical public metadata, receipt, source text when available, plain-text context, claim ledger, source records, and a member-hash manifest. Download full artifact package Read plain-text context Inspect package manifest 2 public sources Sources, authority, and lineage Each record states the role it plays. Research support and governance provenance are not treated as interchangeable. Semantic And Creative Authority Issue #40 canonical semantic and creative authority Governs title, manuscript, thesis, information design, creative lock, and relationship posture. Governs title, manuscript, thesis, information design, creative lock, and relationship posture. Open source Bounded Implementation Authority Issue #165 implementation authority Governs repository implementation, validation, draft PR, and exact-head review evidence. Governs repository implementation, validation, draft PR, and exact-head review evidence. Open source Claim discipline What is asserted—and how it is bounded Research, author analysis, and personal testimony remain distinct. Supporting links and caveats stay attached to each claim. Owner Authorized Primary Principle claim:165:trusted-completion-cost The objective is minimum trusted completion cost, not minimum token cost. Support Issue #40 canonical semantic and creative authority Owner Authorized Thesis claim:165:intelligence-distributed The intelligence is distributed across the system. Support Issue #40 canonical semantic and creative authority Public boundary. No pricing, benchmark, account-tier, universal ranking, or unsupported savings claim is added. 2 sources 2 governed claims 1 portable package Connected work Continue the thinking Each connection explains why the next work belongs here. The graph records the edge; this layer makes it useful to a reader. Companions Related companion Work The Code Is No Longer the Hard Part Issue #40 operationalizes and provides an economic and operational case for Issue #146 without collapsing the two independent Works. As AI reduces the relative cost of implementation, durable engineering value moves outward into intent, authority, context, orchestration, evidence, recovery, and institutional integration. Systems Essay By Tony Malott 2026-07-26 12 min · Standard long-form article Explore the complete graph SOURCE REFERENCES Issue #40 canonical semantic and creative authority https://github.com/pinklon/shareplane-platform/issues/40 Issue #165 implementation authority https://github.com/pinklon/shareplane-platform/issues/165