The architecture every serious local-AI product converges to.

Three current architectures. None survive the platform shift to local AI.

Cloud LLM services are rented inference. The model knows everyone and nobody in particular. Each session starts over. The data leaves the device. The bill scales with usage. Apple, Tesla, and any OEM shipping a serious consumer product on top of cloud inference is structurally subordinate to whoever owns the cloud — and that is not the OEM.

Monolithic on-device models — Apple Intelligence today — solve the data and latency problem but introduce a different one. There is one model, configured per task by adapters or prompts. The model has no persistent identity. When it updates, the user starts over. The model cannot specialize per-user without manual fine-tuning. The model cannot safely retrain on user output because recursive self-training collapses the distribution.

Tool-using agent frameworks — LangChain, AutoGen, the orchestration ecosystem, and the recently proliferating "Agent OS" products — provide dispatch and memory but treat the agent as a stateless function. The agent does not persist across sessions in a meaningful sense, does not own its tools as managed assets, and does not preserve identity across model substitution. When the underlying model changes, the agent effectively becomes a different agent in the same chair.

Adaptive Query is the architecture that survives. The agent is the durable thing. Models, knowledge sources, and adapters are managed assets the agent governs. Identity, cognitive state, and accumulated lineage persist across every change to the components beneath. The architecture is structurally different from cloud, monolithic, and orchestration approaches, and it is the convergent answer to the question every OEM is asking quietly: how do we ship local AI that actually becomes the user's?

What the substrate actually does

A semantic agent is instantiated on the device at first power-on and persists across the lifetime of the device, across reboots, across model upgrades, and across the substrate runtime updating itself. The agent comprises four persistent fields — identity, cognitive state, lineage, and governance policy — that no subordinate component is permitted to modify.

The agent owns a tool registry: a local data structure of managed inference endpoints. Each endpoint comprises a model artifact, an interface specification, and an associated governance scope. The endpoints are installed, retrained, replaced, archived, and removed under governed lifecycle operations. Whether the device runs three small specialized models or thirty, the agent's identity is unchanged across any sequence of tool substitutions.

A dispatcher routes inference requests from host applications to the appropriate tool, conditioned on the agent's current cognitive state. A lineage field records every dispatch, every outcome, every policy event in an append-only sequence. That lineage is the substrate's training signal. When a tool is due for retraining, the agent derives a supervised corpus from the lineage — real-world outcomes, not recursive model output — and fine-tunes the tool under policy. The model collapse problem that haunts self-training cloud systems does not apply, because the signal does not come from the model.

The most visible embodiment is the personal corpus model: a fine-tuned model whose weights internalize the user's accumulated work — code, prose, decisions, preferences — without retrieval at inference time. The user authors something. The artifact enters the lineage. The corpus assembly module derives an incremental training corpus under the user's governance policy. The model is fine-tuned. The next authoring session is assisted by a model that is materially closer to the user. The loop runs continuously, governed by policy, on the user's hardware, with the user's data never leaving except under explicit disclosure authorization.

Blocking power

The architecture is protected by a recent provisional patent application (USPTO Serial No. 64/070,239, filed May 20, 2026, titled "Agent-Resident Execution Substrate with Governed Inference Tool Registry and Lineage-Derived Personal Corpus Model Training") and composes with ten other filings covering cognition, identity, network, content, perception, and governance primitives.

A competitive consumer-grade local AI product has three options. First, build the substrate architecture and license. Second, design around with materially worse architecture — no persistent agent, or no tool registry as managed-asset class, or no identity preservation — and accept that the product cannot safely retrain, cannot specialize per-user across model upgrades, and cannot preserve the agent the user has built up over time. Third, stay in the cloud and cede the local-AI platform shift to whoever ships the substrate.

For Apple, the architecture is what Apple Intelligence needs to evolve into once foundation-model-with-task-adapters proves insufficient at the multi-task per-user scale. For Tesla, it is the layer the in-vehicle agent must run on once the agent must survive software updates and learn from accumulated driving lineage. For robot OEMs, it is the runtime the agent runs on between encountering counterparties, retraining tools from sensor lineage, and migrating across hardware refresh.

In each case, the architecture is convergent. The patent claims the architecture, not a marketing name. The portfolio behind it claims the cognition, identity, governance, content, and perception primitives that compose into it. The blocking position is the integration architecture — the place where everything else meets.

Scale-invariant by design

The same architecture runs on a Mac Mini in a home office, a shared workstation in a small studio, an enterprise server in a hospital or law firm, an embedded controller on a factory line, a vehicle, a robot, or a wearable. "Local" means local to a single operational entity — one human, one household, one team, one factory, one fleet — not "small." The defining property is that the agent operates within the trust and governance boundary of the entity it serves, not within a multi-tenant cloud that aggregates many entities.

A factory's substrate has the same shape as a consumer's. An autonomous vehicle's substrate has the same shape as a household robot's. The architecture's claims include configurations for personal, workstation, enterprise, industrial, embedded, robotic, vehicular, household appliance, wearable, and federated multi-device deployments. The primitives compose; the deployment context configures.