Ollama Connects to Codex App: How Local LLMs Become AI Coding Agents

Ollama has brought local LLMs closer to AI coding tools again: with ollama launch codex-app, users can connect Codex App to local or cloud models managed by Ollama.

The meaning is not just “switching model backends.” It is more like moving local LLMs from a chat window into the development workflow. The model is no longer only answering questions; it can enter a code project, understand file structure, assist with code changes, run tasks, and become part of an AI coding agent workflow.

First, Clarify: This Does Not Mean All OpenAI Features Are Permanently Free

Many online summaries frame this as “Codex is free now.” That is easy to misunderstand.

A more accurate reading is:

• Codex App is OpenAI’s AI coding tool;
• Ollama Launch can help Codex App use Ollama models;
• The model can be local, or it can be an Ollama cloud model;
• If you use a local model, inference cost mainly becomes your own hardware, electricity, and time instead of API token billing;
• Codex App, OpenAI account benefits, model availability, and official limits still depend on the current OpenAI and Ollama rules.

So this is not “all Codex capabilities are permanently free.” It is a new local-first path that lets AI coding agents depend less completely on OpenAI API, Claude API, or Gemini API.

What Does ollama launch codex-app Do?

In Ollama’s official docs, the Codex App integration command is simple:

1

ollama launch codex-app

To choose a model:

1

ollama launch codex-app --model gpt-oss:120b

To generate configuration without launching immediately:

1

ollama launch codex-app --config

To restore your original Codex configuration:

1

ollama launch codex-app --restore

Its value is reducing manual configuration work. In the past, connecting an AI coding tool to a local model often meant editing environment variables, OpenAI-compatible endpoints, config.toml, model names, and profiles by hand. Ollama Launch wraps those steps into a more direct workflow.

Why Local Models Matter for Agents

The most common old use case for local LLMs was chat:

• Writing a short piece of copy;
• Answering a question;
• Explaining a code snippet;
• Doing simple completion;
• Summarizing a document.

These are useful, but they are still mostly “question-answering tools.”

An AI coding agent is different because it works against a real project. It needs to read directories, inspect files, understand errors, edit code, run commands, check results, and iterate. In other words, it does not only output answers; it participates in task execution.

When local models connect to tools such as Codex App, Claude Code, OpenCode, Aider, or OpenHands, the role of local AI changes:

• It can scan project structure;
• It can locate bugs;
• It can modify files;
• It can generate new pages or small games;
• It can explain and refactor code;
• It can repeatedly execute, verify, and correct inside the development loop.

This is the key step from local LLMs that “can chat” to local LLMs that “can work.”

Advantages of Local Agents

1. More Controllable Cost

Large projects can consume a lot of tokens. A full project scan, long-context analysis, and multi-round repair loop can quickly accumulate cost on cloud models.

Local models still have costs, such as GPU, RAM, electricity, and time, but they do not charge directly by token. For heavy experimentation, personal projects, and offline tests, the local route is more suitable for slow, repeated iteration.

2. Offline Work Is Possible

If the model, tools, and dependencies are already prepared on the machine, a local agent can continue working offline in many scenarios. It can read local code, analyze a project, modify files, and generate pages or scripts.

Of course, tasks involving web search, downloading dependencies, or accessing online APIs still need a network. But basic code analysis and local project edits do not necessarily depend on cloud models.

3. Clearer Privacy Boundaries

Many repositories, internal documents, and experimental projects are not suitable to send directly to cloud models. Keeping the model local reduces the chance that code content leaves the machine.

This does not mean local is automatically safe. An agent may still run commands, edit files, and access sensitive paths, so permissions, sandboxing, and Git diff review still matter. But at the model inference layer, local deployment gives users more control.

Which Models Should You Try?

Ollama’s official ollama launch docs recommend larger context windows for coding tools, ideally at least 64K tokens. The reason is simple: AI coding tasks often need to read project structure, multiple files, error logs, requirements, and previous edits at the same time.

Local models worth trying include:

• qwen3-coder: code-oriented tasks;
• gpt-oss:20b: suitable for local experiments;
• glm-4.7-flash: one of Ollama’s recommended coding models;
• Larger cloud models: if your local hardware is not enough, Ollama cloud models can provide more complete context.

For Chinese scenarios, the Qwen family remains worth trying first. It is mature in Chinese understanding, code generation, reasoning, and local ecosystem support.

The Hardware Bar Is Lower Than Many People Think

Many people assume AI agents require an RTX 4090, 24GB VRAM, or even enterprise GPUs.

Reality is more flexible. Small models, quantized models, MoE models, KV cache quantization, and CPU/GPU mixed offload allow 6GB, 8GB, and 12GB VRAM machines to do quite a lot.

Of course, low-VRAM machines are not ideal for the best experience:

• Speed will be slower;
• Context cannot be too large;
• Large project scans will be difficult;
• Multi-concurrency is usually unrealistic;
• Model quality still trails 100B+ cloud models.

But for personal projects, script fixes, simple frontend pages, small games, code explanation, and offline experiments, local models are already usable.

You Can Also Use llama.cpp with an OpenAI-Compatible API

Besides Ollama, another common route is to use llama.cpp and llama-server to provide a local OpenAI-compatible API, then connect your AI coding tool to the local port.

A typical llama.cpp launch command looks like this:

1
2
3
4
5
6
7
8
9

llama-server.exe ^
 -m "models\Qwen3.6-27B-UD-Q5_K_XL.gguf" ^
 -ngl 999 ^
 -c 16384 ^
 -n 2048 ^
 -fa on ^
 --jinja ^
 --host 127.0.0.1 ^
 --port 8080

Then point the model provider to:

1
2
3
4

[model_providers.llamacpp]
name = "llama.cpp"
base_url = "http://127.0.0.1:8080/v1/"
wire_api = "responses"

This route is more flexible, but also more hands-on. Ollama Launch is simpler; llama.cpp gives more control over VRAM, context length, quantization, and inference backend.

What to Watch Out For

Local does not mean risk-free. If an agent can edit files, run commands, and create projects, it can also delete files by mistake, change the wrong code, or run commands it should not run.

Recommendations:

1. Work inside a Git repository so you can inspect diffs and roll back.
2. Do not give the agent excessive system permissions.
3. Start with a test project instead of production code.
4. Manually review important file changes.
5. Do not expose keys, accounts, or production environment configs to the agent.
6. Local models have limits; do not fully delegate complex architecture decisions to them.

Treat the local agent as an assistant that can execute tasks, not as a fully reliable engineer. The experience will be healthier.

My Take

The meaning of Ollama connecting to Codex App is that it brings local models into the AI coding workflow for real.

In the past, local models were mostly chat boxes. Now they can enter projects, read code, edit files, and run tasks. This change will make many ordinary developers rethink the PCs they already own: perhaps they do not need the most expensive GPU to build a low-cost, offline-capable, controllable AI coding environment.

Cloud models are still strong, especially for complex reasoning, large context, multimodal work, and long-task stability. But local models are catching up in the “execution tool” layer.

Future AI coding will likely be hybrid rather than purely cloud or purely local:

• Small tasks, local code, and private projects go to local models;
• Hard reasoning, large context, and cross-system tasks go to cloud models;
• Ollama, Codex App, Claude Code, and OpenCode connect both sides into one workflow.

That is the part of local AI agents worth watching.

References

• Lingdu Blog: OpenAI Codex is free? Ollama takes over AI coding agents
• Ollama Docs: Codex App
• Ollama Blog: ollama launch
• OpenAI: Introducing the Codex app