Inference at the Ambiguity Frontier Tony Malott · Published 2026-08-11 https://shareplane.malott.ai/architecture/inference-at-the-ambiguity-frontier/ A general thesis for AI-native systems Inference at the ambiguity frontier. The real opportunity in AI is not to put a model inside every operation. It is to use intelligence to discover the rules, formalize them, and then remove inference from work that no longer requires judgment. Inference belongs where uncertainty remains. Determinism belongs everywhere behind it. The model is interchangeable. The architectural boundary is not. Not the target Maximum agent autonomy The target Maximum system autonomy The constraint Minimum necessary inference 01 · The conversion Every solved reasoning problem should become infrastructure. New work begins as ambiguity. AI is useful precisely because the rules are incomplete. But once decisions stabilize, continuing to ask a model to rediscover them is an inference tax on knowledge the system already owns. 1 Ambiguity The desired outcome exists, but the rules are incomplete. 2 Reasoning Humans and models explore semantics, tradeoffs, failures, and edge cases. 3 Specification Decisions crystallize into schemas, invariants, templates, and acceptance criteria. 4 Executable policy Rules become validators, state machines, gates, and deterministic transforms. 5 Automation Software executes the known path cheaply, quickly, and reproducibly. Do not keep buying the same answer. When a decision is stable enough to express as an algorithm, move it out of the model path. The model should advance toward the next unresolved boundary while software owns the known terrain. if state_is_ambiguous: reason() elif rule_is_stable: encode_as_policy() validate_deterministically() execute() else : escalate_exception() 02 · The economics The economics flip when reasoning becomes a capital expense instead of a transaction tax. Inference-heavy systems repay for judgment on every execution. Deterministic systems concentrate the expensive thinking in design and change, then amortize it across every future run. Inference-heavy operation Reason again every time total_cost ≈ inference_cost × executions Useful while the problem is unresolved. Wasteful once the same class of decision is repeatedly reconstructed. Deterministic operation Reason once, execute repeatedly total_cost ≈ design_cost + cheap_execution × executions Expensive up front because judgment must be made explicit. Then the cost curve flattens and the knowledge keeps paying dividends. Economics Inference becomes exceptional Frontier models stop being the default engine for routine operations. ↓ cost per operation Quality Variance gets engineered out The same input and policy produce the same result instead of a fresh interpretation. ↑ repeatability Speed Execution outruns deliberation Software performs known transformations without reconstructing intent on every run. ↑ throughput Assurance Evidence becomes native Inputs, code state, transitions, outputs, and failures can be reproduced and audited. ↑ confidence 03 · Maturity A mature AI system may use less AI to operate. That is not retreat. It is accumulated knowledge. Capability rises while the fraction of routine operations requiring probabilistic reasoning falls. Inference Dependency Ratio IDR = I / O I = operational executions requiring model inference O = total operational executions A falling IDR with stable or increasing capability is evidence of architectural maturity. Inference dependency Desired direction high low exploration patterned industrialized Stage 1 Exploratory Agents perform broad workflows because the process itself is still being discovered. Stage 2 Patterned Repeated decisions become visible and reusable conventions begin to emerge. Stage 3 Industrialized Stable judgment is encoded as software, policy, validation, and CI. Stage 4 Adaptive Agents concentrate on change and exceptions, then feed new knowledge back into the deterministic plane. 04 · Architecture Separate the reasoning plane from the execution plane. This is the durable pattern. Coding agents are valuable inhabitants of the reasoning plane, not the architecture itself. Codex, Claude Code, Copilot, Gemini, and whatever arrives next can all occupy the same boundary. Reasoning plane Probabilistic 01 Novel creation Semantics, architecture, and design patterns that do not yet exist. 02 Diagnosis Telemetry violates known invariants or the observed state cannot be classified. 03 Exception handling Reality has produced a case the deterministic machinery cannot safely resolve. 04 Architecture evolution The existing system no longer fits reality and needs a new pattern. Execution plane Deterministic 01 Transforms and formatting Known schemas, templates, wrappers, metadata, and rendering paths. 02 Validation and promotion Acceptance criteria, gates, provenance, admission policy, and receipts. 03 Reconciliation and recovery State checks, retries, idempotency, restoration, and bounded repair. 04 Routine operations Known transitions execute without reconstructing intent or policy. Architecture rule The reasoning plane continuously improves the execution plane. The execution plane continuously emits evidence back to the reasoning plane. The model can change without redesigning that relationship. 05 · Where agents belong Use expensive intelligence where intelligence changes the answer. The right question is not whether an agent can perform a task. It is whether the task still contains unresolved judgment. 01 Novel creation Invent the first pattern when no stable implementation exists. 02 Architecture Explore competing designs, constraints, and failure boundaries. 03 Diagnosis Explain novel failures or telemetry that violates expected state. 04 Exceptions Handle cases the deterministic path cannot safely classify. 05 Evolution Redesign machinery when requirements or environments change. 06 Pattern synthesis Convert repeated successful reasoning into the next reusable mechanism. 06 · Field evidence The thesis became obvious only after building through the pain. The broad principle came into focus while building Control Tower, SharePlane, and the surrounding automation framework. What looked like permanent agent work repeatedly collapsed into deterministic software once the semantics were nailed down. What changed in practice Initially, operations such as publication, promotion, validation, evidence collection, recovery, and state reconciliation looked too judgment-heavy to remove from an intelligent coding agent. The surprise was that the judgment was temporary. Once the system learned the rule, the rule could be encoded. Publishing Agent interprets layout, metadata, wrapper, and placement each time. Design system + schema + deterministic renderer + CI. Promotion Agent reasons about readiness and deployment sequencing. Explicit acceptance gates, authority, provenance, and admission policy. Evidence Success is inferred from conversational traces and agent claims. Receipts bind inputs, source state, transitions, outputs, and failures. Recovery Agent reconstructs a repair strategy during each incident. Known failure classes get bounded retries, reconciliation, and deterministic restoration. Operations Coding agent expected to remain deeply involved in the operating plane. Agent becomes specialist for ambiguity, exceptions, diagnosis, and evolution. The work did not disappear. The reasoning became infrastructure. That is the compounding asset. 07 · The operational test A simple routing test prevents agents from colonizing solved work. Before invoking a model, classify the state. The goal is not anti-AI minimalism. It is disciplined placement of intelligence. Is the state genuinely ambiguous? Are requirements incomplete, multiple interpretations valid, or important facts missing? Yes → reasoning plane Has this judgment stabilized? Can the desired behavior be expressed as a schema, invariant, transition, or algorithm? Yes → encode it Has the pattern repeated? If the same successful reasoning appears again, treat repetition as a signal to manufacture reusable machinery. Yes → remove future inference 08 · The optimization target Maximum AI autonomy is the wrong objective. The stronger target is maximum system autonomy with minimum necessary inference. That distinction changes cost, reliability, auditability, and scale. Dimension Agent-operated System-autonomous Routine work Repeatedly reasoned Encoded once, executed repeatedly Cost curve Inference scales with activity Reasoning concentrates in change Failure mode Interpretation variance Invariant violation with explicit handling Auditability Conversation and agent traces Inputs, code state, transitions, receipts Scale More work means more reasoning More work mostly means more execution Agent choice Operational dependency Replaceable reasoning capability Long-form argument Inference Belongs at the Ambiguity Frontier The real opportunity in AI is not automating more work with models. It is discovering which work should never require a model again. AI architecture Deterministic systems Operational autonomy Field-tested thesis For the past several years, much of the AI conversation has centered on a simple question: How much work can we give to AI? I increasingly think that is the wrong question. A better one is: How much reasoning can we eliminate once the problem has been understood? That distinction changes the economics of AI, the architecture of automated systems, their reliability, their speed, and ultimately the role that intelligent agents should play inside them. Inference belongs at the ambiguity frontier. Determinism belongs everywhere behind it. AI is most valuable before the pattern exists A new problem begins with ambiguity. Requirements are incomplete. Desired behavior is still evolving. Exceptions have not been discovered. Nobody has fully defined what success means. This is where modern AI systems are remarkably useful. A capable model can explore competing designs, surface edge cases, synthesize requirements, analyze failures, challenge assumptions, and rapidly iterate toward something better. At this stage, probabilistic reasoning is a feature. But as the work continues, uncertainty starts disappearing. Decisions stabilize. Interfaces become known. Failure states become understood. Acceptance criteria become explicit. What began as a reasoning problem becomes a specification, and a mature specification can become software. The mistake is stopping halfway Many AI implementations reach the reasoning stage and remain there indefinitely. An agent solves the same class of problem repeatedly. Every transaction requires another model invocation. Every invocation adds latency, cost, and some probability of variation. If the reasoning has already converged, that is not sophisticated automation. It is an architectural failure wearing an AI badge. The better outcome is to take what the model helped discover and compile that knowledge into the system. A formatting decision becomes a template. A deployment decision becomes policy. A validation rule becomes code. A routing decision becomes a state machine. A recovery procedure becomes automation. At that point the model has done something more valuable than completing another task. It has helped make itself unnecessary for that task. The economics change completely An inference-heavy system pays repeatedly. Every execution consumes compute, introduces model latency, and carries probabilistic behavior into the transaction path. A deterministic system pays primarily during design and engineering. Inference-heavy: total_cost ≈ reasoning_cost × executions Deterministic: total_cost ≈ design_cost + inexpensive_execution × executions For a process that runs once, the distinction may not matter. For a process that runs a million times, it is enormous. The infrastructure becomes accumulated reasoning. Every invariant encoded in software is a decision that no longer needs to be made. Reliability changes too A probabilistic agent may perform a task correctly hundreds of times and still interpret an instruction differently on the next execution. That flexibility is useful when circumstances genuinely differ. It is dangerous when they do not. If an article must conform to a known publishing schema, a model should not rediscover the schema every time. If software must pass specific release gates, an agent should not reinterpret those gates on every deployment. If provenance and rollback data are required, machinery should enforce them. Do not ask intelligence to exercise judgment where judgment is no longer required. The most mature AI systems may use less AI As an AI-enabled system matures, the amount of inference required to operate it may decrease. That sounds backwards in an industry racing to add agents to everything, but it follows directly from accumulated knowledge. At first, an agent may perform an entire workflow. Later, repeated portions become understood well enough to automate conventionally. Eventually the agent is concentrated at the boundaries where genuine uncertainty remains. The operational core becomes increasingly boring, which is one of the nicest things you can say about infrastructure. The AI moves from operator to architect, diagnostician, exception handler, and explorer. The agent is interchangeable This principle is not about one coding agent. Codex, Claude Code, GitHub Copilot, Gemini, or a future system can all occupy the reasoning plane. Different models will have different strengths, costs, context windows, tools, and failure modes. Those differences matter when choosing an implementation. They should not define the architecture. The model is interchangeable. The boundary between probabilistic reasoning and deterministic execution is the durable design decision. What changed my thinking I understood parts of this intellectually before I understood them operationally. Building Control Tower, SharePlane, and the surrounding automation framework made the difference painfully clear. Initially, I assumed intelligent coding agents would remain deeply involved in routine operations because so much of the work appeared to require judgment. Publishing was an obvious example. An article had to be interpreted, structured, formatted, wrapped in the correct design system, placed correctly, validated, previewed, and eventually promoted. Except once the design language is settled, it becomes components. Once article structure is settled, it becomes a schema. Once metadata requirements are known, they become validation. Once promotion behavior is known, it becomes CI. Once acceptance criteria are known, they become gates. Once evidence requirements are known, they become receipts. The work did not disappear. The reasoning became infrastructure. That realization repeated itself across the system. Things I initially believed required an agent frequently turned out to require an agent only until we understood them well enough. Then we wrote software. The hard part is up front This approach asks for considerably more work at the beginning. States must be defined. Invariants have to be discovered. Authority has to be explicit. Retries, failures, concurrency, idempotency, provenance, rollback, validation, and recovery cannot be waved away with a vague assumption that the agent will figure it out. That work is tedious and tends to produce unimpressive demos. An autonomous agent operating a UI can be impressive in five minutes. A transactional boundary or deterministic reconciliation loop usually cannot. Six months later, the difference is obvious. The demonstration still needs intelligence every time it runs. The engineered system does not. AI should manufacture leverage The larger opportunity is not to use AI merely to complete more transactions. It is to use intelligence to manufacture systems that stop needing intelligence for solved work. Solve the difficult problem. Extract the pattern. Formalize it. Encode it. Test it. Then stop solving it. Every repeated successful reasoning path should create pressure toward reusable machinery. Over time the framework itself becomes a machine for converting reasoning into deterministic capability. From agent autonomy to system autonomy The industry often equates autonomy with an AI agent making more decisions. But a deterministic system that observes state, applies known policy, executes safely, validates results, records evidence, recovers from known failures, and escalates only unknown conditions is also autonomous. In many operational domains, it is the stronger form. The goal is not maximum agent autonomy. The goal is maximum system autonomy with minimum necessary inference. That architecture scales better, costs less, behaves more predictably, and is easier to audit. When something genuinely novel happens, the expensive intelligence remains available exactly where it adds value. The endgame The most advanced AI systems may not be the systems making the largest number of model calls. They may be the ones that know when not to make one. They will invoke intelligence at the boundary of uncertainty, convert successful reasoning into durable mechanisms, push known work into cheap and reproducible software, and reserve probabilistic computation for the places where reality actually demands it. Not AI everywhere. Not deterministic software everywhere. A disciplined boundary between the two. The compounding advantage AI discovers and extends the rails. Software runs the trains. The hard work is turning judgment into durable structure. It is slow, tedious, and easy to postpone. It is also the work that compounds. Every stable decision removed from future inference permanently reduces cost, latency, variance, and operational risk. Frontier Reason where reality is still ambiguous. Compilation Convert stable judgment into executable policy. Operations Let deterministic systems carry the recurring load. SOURCE REFERENCES Inference at the Ambiguity Frontier https://github.com/pinklon/shareplane-platform/issues/387 Issue #403 identity split repair https://github.com/pinklon/shareplane-platform/issues/403 Why we built ADK 2.0 https://developers.googleblog.com/why-we-built-adk-20/ Workspace agents https://openai.com/academy/workspace-agents/ Scaling Managed Agents: Decoupling the brain from the hands https://www.anthropic.com/engineering/managed-agents Compiled AI: Deterministic Code Generation for LLM-Based Workflow Automation https://arxiv.org/abs/2604.05150