ChatGPT Desktop Can Now Run Ollama Models. The Boundary Matters

Ollama published version 0.34.0 release candidate one on September 5 with a feature that would have sounded contradictory a year ago: ChatGPT Desktop can now use Ollama models directly. The setup is available through the Ollama app on macOS. A user can keep the ChatGPT interface while sending selected model requests to local or Ollama managed compute.

The obvious reading is that ChatGPT gained local models. The more important reading is architectural. The interface, agent environment, model, and compute location are becoming separate choices. That is exactly the separation builders need if they want better models without rebuilding the workflow every month.

I have not tested this release candidate yet, so this is not a performance review. The useful evidence is in Ollama's release notes, merged pull request, and routing tests. They show how much translation work is required to make a familiar agent interface genuinely model flexible.

One interface can now reach two compute paths

Ollama says the integration uses the existing ChatGPT and Codex profile, allowing users to continue chats and retain configured plugins, MCP connections, and skills. The implementation adds an Ollama model selector inside the macOS app integration. Changing the selected set requires a ChatGPT restart, and the current code allows a limited catalog rather than pretending every installed checkpoint will behave identically.

Underneath that interface, Ollama runs a local proxy. Requests for models in the Ollama routing catalog go to Ollama. Requests for native OpenAI models continue to the ChatGPT service. Project tests explicitly send one request for an Ollama catalog model and another for a native model through the same endpoint, then verify that each reaches the intended destination.

That is a small implementation detail with a large product implication. Model switching no longer has to mean switching the entire application. The conversation surface can stay stable while the execution target changes per request. A closed client can become a shell around an open model, at least for the paths the integration supports.

For founders, this is the useful form of optionality. Nobody wants to retrain a team, recreate tool connections, and migrate chat history whenever a new open model becomes good enough. If the client and the inference provider are separable, evaluation becomes a routing decision rather than a product migration.

Local inference is not the same as a local workflow

There is also an important limit. Selecting an Ollama model does not make every part of ChatGPT Desktop local. The client remains ChatGPT Desktop. Plugins, MCP servers, account services, updates, and any native requests have their own data paths. A local model only proves that model inference can take the local route for that selected request.

Ollama's implementation recognizes this boundary. Its routing tests verify that authorization headers, ChatGPT account identifiers, compression metadata, and turn metadata are removed before a local request reaches Ollama. That is good engineering. Credentials meant for one provider should not leak into another provider merely because both share a client endpoint.

The same tests also reveal the complexity behind the simple toggle. The proxy translates reasoning effort controls, preserves tool calls, handles response compaction, carries images through compacted responses, and supports client tool search. OpenAI compatible does not mean every agent feature has identical semantics. Compatibility is a translation layer that must be tested feature by feature.

This matters more for agents than for chat. A basic prompt and answer can survive a rough compatibility layer. An agent depends on tool schemas, tool results, reasoning settings, images, compaction, and state that persists across many turns. One incorrect conversion can silently change behavior long after the first request succeeds.

The model is becoming a runtime choice

My preferred agent architecture already treats the application boundary as stable. Agents should call a service contract, not know which machine holds the weights. A router should choose between local hardware and remote APIs according to capability, privacy, queue depth, and cost. The Mac mini can coordinate work while an RTX workstation, a DGX Spark, or an API performs the actual inference.

This Ollama integration brings the same idea into a mainstream desktop client. The user chooses the environment and workflow first. The model becomes a replaceable execution component behind it. That weakens one of the most persistent sources of vendor lock in: the assumption that the best interface and the selected model must come from the same company.

It does not eliminate lock in. The interface still owns conventions, state, and supported feature shapes. The Ollama proxy contains substantial code specifically because different model runtimes do not expose identical behavior. If your workflow only works through one client's private assumptions, changing the model provider is progress, not full portability.

The practical goal is not ideological purity. It is to keep each boundary visible. Know which client stores the conversation. Know which proxy rewrites the request. Know which runtime executes the model. Know which tools can reach the network. Know where account credentials stop. Then decide which components need alternatives.

The test I would run before trusting it

Start with one noncritical workflow on macOS and one Ollama model whose tool behavior you already understand. Run the same task once through Ollama directly and once through ChatGPT Desktop. Compare the system instructions, tool schemas, tool results, image handling, compaction behavior, and final answer. Watch Ollama's request logs and confirm that the selected model actually receives the request.

Then repeat with a native OpenAI model and verify that routing changes without losing the conversation or tool configuration. Do not use sensitive data until network inspection confirms which requests stay local and which services still communicate externally. Because this is a release candidate, keep the prior Ollama version available and expect integration edges.

The important news is not that ChatGPT Desktop has another model menu. It is that a popular agent client can preserve the workflow while the compute path changes underneath it. Test one real tool using task from both routes. If the behavior survives, you have gained practical model optionality instead of another checkbox labeled local.