Run coding agents on a local model

A coding agent does not have to send your prompt anywhere. Lanes can run a session against a model on this machine, with no tokens bought and nothing leaving the laptop. Ollama is the provider Lanes manages directly, so installing it, starting it, pulling models, and wiring a session to it all happen from one page.

It is marked Research Preview, which means it works and the rough edges are the ones we most want to hear about.

How Lanes does it

• The whole Ollama lifecycle. Install, Start server, Stop server, and Uninstall, each using the right lever for how Ollama got here: a Homebrew formula is driven through brew services, the desktop app is opened and quit as an app. You do not have to remember which one you have. Everything runs in a real terminal, so you see what happened rather than a spinner.
• Your installed models, honestly. Size on disk, parameter count, quantization, capabilities, and trained context length. The list works with the daemon stopped, because Lanes reads the manifests in ~/.ollama instead of showing you an empty page.
• A curated list sized for this machine. Recommended models carry a checked download size and a minimum memory figure, compared against the RAM you actually have. Below that sits the full ollama.com library, searchable, and a field that pulls any reference by name.
• A Fit column that answers the real question. Before you spend the download: a context figure such as 128k context means it fits with room, Fits at 64k, little headroom means you are close to the edge, and Needs ~38k, this machine fits ~24k means it cannot hold a session prompt here. No tool support means it cannot run an agent at any context size, because an agent that cannot call tools cannot edit files. Fit warns, it does not block.

Why context is the thing that decides

This is the part that catches people out. A real session sends roughly 38,000 tokens before you type anything: the harness instructions, its built-in tool definitions, and the tool definitions of every MCP server you have connected.

Ollama picks a context size from available memory, commonly far below that, and when a prompt overflows it truncates instead of failing. It keeps the head and the tail and drops the middle, so what reaches the model is tool-definition JSON with the instructions cut out. The model answers with something that looks like nonsense, and nothing anywhere reports the loss.

So Lanes sizes the context itself and bakes it in. On pull it creates a variant tagged -lanes with num_ctx set from your total memory and that model's own key/value geometry. The variant shares its data with the base model, so it costs nothing extra on disk, it survives reboots, and ollama rm undoes it. A Context window field overrides the estimate outright.

If a model still does not fit, the lever that helps most is connecting fewer MCP servers. Their tool definitions are a large share of that 38,000.

Why it matters

Marginal cost goes to zero. A model on your own machine has no meter attached, so the sessions you would think twice about starting, the mechanical refactor or the fifth attempt at a flaky test, stop having a price. Nothing is sent to a provider, which settles the client-code question before it is asked. And you keep the workspace: the same board, the same worktree per session, the same branch diff to review.

It also wires itself in. Once Ollama is serving and has at least one model, Lanes registers it as a Gateway provider automatically, never overriding a provider you picked yourself. The session picker's Model row then lists the tags your daemon really has, rather than model ids it does not serve.

Set it up

Install Lanes and open it:

brew install --cask lanes-sh/lanes/lanes && open -a Lanes

Then:

1. Open Settings, Agentic Coding, Local LLMs and hit Install if Ollama is not here yet. Lanes installs it with Homebrew and starts the server for you.
2. Pick a model with a green Fit. Browse the recommended list, check the Fit column against the download size, and pull. Lanes bakes the -lanes variant as part of the pull.
3. Start a session and choose the tag in the Model row. The Gateway row will already be pointing at your daemon.

A shortcut in the app header, next to the keep-awake button, shows live daemon state and starts or stops the server without opening Settings.

Further reading

• Local LLMs: the full page, including the Fit rules and re-baking.
• Gateway: how a session is pointed at a provider.
• Point sessions at any model provider: the same mechanism aimed at hardware you own or tokens you buy.
• Run a fleet on mixed models: local and frontier models on one board.
• A local, private AI coding workspace: the rest of what stays on your machine.

Get Lanes Desktop or read the quick start.