Discussions about AI vendor lock-in usually focus on model weights, proprietary fine-tuning formats, or custom prompt syntaxes. However, as frontier models shift from simple single-turn completion engines to long-running, multi-turn agentic systems, frontier labs are quietly constructing a much deeper form of lock-in: state and execution infrastructure lock-in.

OpenAI’s recent post, How two settings tripled our ARC-AGI-3 scores, provides a clear demonstration of this shift. By enabling hidden reasoning persistence across turns and automatic context compaction, GPT-5.6 Sol’s ARC-AGI-3 score jumped from 13.3% to 38.3% while consuming 6× fewer output tokens.

The performance gains are real, but so are the architectural implications for developers striving to build open, portable agentic systems.

State Persistence Without Developer Control

Under OpenAI’s Responses API, multi-turn reasoning can use either server-managed continuation through previous_response_id, which lets later responses access stored conversation state and compatible persisted reasoning items, or client-managed stateless continuation with store: false, where the client preserves and replays complete response output items, including opaque reasoning.encrypted_content.

As conversations grow, OpenAI can also use compaction to reduce their context while carrying forward selected state and reasoning. The resulting encrypted compaction item is opaque to developers: it can be stored and replayed to OpenAI, but not inspected, decrypted, or translated for another model provider.

This is not just a particularity of the OpenAI API. Anthropic’ thinking blocks and Gemini thought signatures are both encrypted, and like OpenAI, none of these providers expose the model’s raw reasoning tokens to the developers.

Developers receive only visible outputs, optional reasoning summaries, and opaque continuation state. Consequently, reasoning continuity tied to that hidden state cannot be transferred directly to another provider or open-weights model such as Llama, Qwen, or DeepSeek.

A plain-text handoff can preserve conclusions and selected context, but it reconstructs rather than transfers the model’s accumulated internal reasoning state.

Proprietary Execution Harnesses & Benchmark Inflation

The ARC-AGI-3 post highlights another growing trend: frontier labs reinforcing lock-in by pairing their models with closed, proprietary execution harnesses.

Frontier models are heavily Reinforcement Learning (RL)-trained and optimized for specific, proprietary coding harnesses and execution sandboxes (e.g., Code Interpreter environments, custom file-system wrappers, proprietary browser agents). When evaluating models using generic open harnesses, performance often lags. But when coupled with the provider’s native harness and hidden state persistence, benchmark scores double or triple.

This creates a subtle illusion: a score on ARC-AGI or SWE-bench no longer reflects just the raw capabilities of the underlying model, but rather the model + proprietary state-management + custom execution environment. The benchmark’s own authors keep provider-specific settings out of verified scoring precisely to ensure scores stay comparable across providers. 

Replicating these results outside the provider’s native API ecosystem requires developers to  re-architect significant parts of their harness.

Beyond hidden reasoning traces within a single thread, labs are increasingly embedding persistent, cross-session memory layers directly into their API endpoints.

When memory, entity tracking, and session compaction happen inside a provider’s black box: 

• Developers lose granular management: you cannot easily query, edit, filter, or export specific facts or relationships stored in the provider’s memory layer. 
• Compliance & Data Governance become murky: inspecting what the model “remembers” or deleting sensitive data selectively requires complex API workarounds. 
• Cross-model orchestration breaks: multi-model agent architectures (e.g., routing planning to Model A and code execution to Model B) cannot access the shared memory state without custom external state infrastructure.

Explicit, Open Agent State

In our previous take, Open Models Are Ready for Agents, Their APIs Are Not, we argued that open-weights models are more than capable of handling complex agent workflows, but open API standards and tooling lag behind proprietary ecosystems.

OpenAI’s Responses API and hidden reasoning persistence double down on proprietary standards. To build resilient, vendor-agnostic software, developers must treat provider-specific state management as an ephemeral optimization, not as the canonical source of truth.

The triple-digit performance bump on ARC-AGI-3 proves that state management and persistence are crucial for long-horizon agentic reasoning. But as frontier labs entangle model intelligence with opaque, non-transferable infrastructure, developers can either accept convenient performance gains at the cost of total provider lock-in, or invest in explicit, open state management that keeps your agents intelligent, resilient, and portable.

At Mozilla AI, we believe the future of AI belongs to open, interoperable agentic systems. 

This is precisely why we are building Otari: an open-source LLM Control Plane designed to give developers full operational ownership over their model infrastructure and agent workflows.

Designing portable state architectures today is the first step toward securing developer independence tomorrow.