Everything below was checked on October 17, 2026. These tools change fast, so if something is out of date, tell me in the comments and I'll fix it.

The short version

• Cursor is the most polished experience: a full editor with Tab completion, cloud agents and its own models. It's proprietary, and on the Free and Plus plans you can't use your own API keys or third-party models.

• Cline is the most capable open-source option. It's Apache-2.0 and ships as a VS Code extension, a JetBrains plugin, a CLI and an early desktop app. It works with basically any provider, including Ollama and LM Studio. If you want open source and maximum features, start there.

• Continue was a pioneering open-source assistant, but its repo is now read-only and no longer actively maintained, after a final 2.0.0 release.

• OpenPilot is a small, chat-first desktop app (MIT, Electron). You point it at a folder, bring any OpenAI-compatible model, and approve what it runs. It's simpler and much younger than the others, and it's a one-person project.

Side by side

Sources: Cursor BYOK docs, Cursor plans, Cline README, Continue README and docs, OpenPilot source.

A "—" means I couldn't confirm it from official docs. Please don't read it as "no".

Cursor

Cursor is a full editor, and it's genuinely good at being one: Tab completion, Plan Mode, cloud agents, code review and a long list of integrations. Its BYOK docs are clear about the trade-offs.

• Supported key providers are OpenAI, Anthropic, Google, Azure OpenAI and AWS Bedrock.

• Custom keys only work for chat models. Tab keeps using Cursor's built-in models.

• Requests are routed through Cursor's servers for final prompt building, even with your own key. Cursor says the key isn't stored.

• On the current plans table, Free and Plus don't include third-party models or your own API keys. Premium ($30/mo) and up do.

If you're happy inside Cursor and paying for a plan that fits, I honestly don't think you need OpenPilot. Where it's a poor fit is if you want to run a model on your own machine, use a provider that isn't on that list, or keep requests from passing through a third-party backend.

Cline

Cline is what I'd recommend to most people asking for "open-source Cursor". It runs in VS Code and JetBrains, as a CLI (npm i -g cline), and now as a desktop app. Its features include:

• Plan and Act modes

• Checkpoints, so you can undo the agent's work

• Diffs you can review

• Linter and compiler awareness

• Rules and skills, MCP and plugins

• Multi-agent teams and scheduled agents

• A huge provider list: Anthropic, OpenAI, Gemini, OpenRouter, Bedrock, Vertex, Groq, Ollama, LM Studio and any OpenAI-compatible API

By default it asks before every file edit and terminal command, and you can switch on auto-approve.

Compared with that, OpenPilot is a much smaller tool. Cline's desktop app is newer (v0.0.x at the time of writing), but the project overall is far more mature than mine.

Continue

Continue deserves credit for pushing open-source, any-model coding assistants early. As of now, its README says the continuedev/continue repository is no longer actively maintained and is read-only. The team shipped a final 2.0.0 of the VS Code extension, CLI and JetBrains plugin, and that release also removed anonymous telemetry. You can still install it, but don't expect fixes.

OpenPilot: what it actually is

I built OpenPilot because I wanted a Cursor-style agent where I pick the model, including local ones, without living inside a particular editor. In practice:

• It's a desktop chat app. You add one or more models with a name, a base URL and a key. There are presets for OpenAI, Anthropic, OpenRouter, DeepSeek, Groq, Together, Mistral, xAI, MiniMax and Ollama, or you can use any custom OpenAI-compatible URL. You can switch models per chat.

• You pick a workspace folder. The agent can list, read, write and edit files there, and edits show a diff preview. It can also run shell commands (output streams into the chat), plan with a todo list, and hand side tasks to short-lived subagents.

• Shell commands, file writes and file edits pause on an Allow / Deny card unless you turn on "Enable all permissions" in Settings → Agent, which is off by default. I wrote up how that loop works, and where it doesn't protect you, in a separate post.

• MCP servers can be turned on per chat. It also has skills (type /), persistent memory, token usage by model, and optional web search through TinyFish.

• Keys stay on your machine. There's no account.

Honest limits:

• It's a solo project at v1.0.5.

• The Windows installer is unsigned, so SmartScreen will warn you. macOS is an unsigned beta, and on Linux you build from source.

• There's no checkpoint or undo. Work in a git repo.

• There's no Tab autocomplete, and it isn't an editor. I use it next to one.

• Small local models (I've tested Qwen 3 8B and 27B) do fine on focused edits but get lost on long multi-step tasks. There's no loop guard yet.

• Anonymous usage telemetry (app opens, feature and model use, token counts; no chats, files, paths or keys) is on by default. You can turn it off in onboarding or Settings → About.

So which one?

• You want the best editor experience and you're fine paying: Cursor.

• You want open source with the most features, inside your editor or CLI: Cline.

• You want a small, standalone open-source app where any OpenAI-compatible or local model drives an agent in a folder, and you approve each command: try OpenPilot, and tell me what breaks.

Links: GitHub · openpilot.in · Run it with Ollama + Qwen 3 · Run it with LM Studio

Disclosure: I drafted this post with help from an AI assistant and checked the claims against each project's docs and source on Oct 17, 2026. If I got something wrong about any of these tools, please correct me in the comments and I'll update it.

Originally published on DEV.

I wanted something like Cursor that was open source and let me use whatever model I wanted, including ones running on my own machine. I couldn't find one, so I built OpenPilot. It's a desktop app (Electron) where an AI agent works inside a project folder you pick: it reads and edits files and runs shell commands, and you approve or deny the sensitive stuff.

This post walks through running it fully locally with Ollama and Qwen 3. I've tested Qwen 3 8B and Qwen 3 27B this way (through Ollama and LM Studio) and both worked well for me.

What you need

• Windows (works today) or macOS (unsigned beta). No Linux installer yet, but building from source works on Linux.

• Ollama installed

• Enough RAM/VRAM for the model you pick (8B is the easy starting point)

Step 1: Pull a Qwen 3 model

ollama pull qwen3:8b
# or, if your hardware can take it:
ollama pull qwen3:27b

Make sure Ollama is running (ollama serve, or just open the Ollama app). It serves an OpenAI-compatible API at http://localhost:11434/v1.

Step 2: Install OpenPilot

• Windows: OpenPilot-Setup.exe (a portable .exe is also on the releases page)

• macOS: .dmg for Apple Silicon or Intel from Releases

SmartScreen tip: the Windows installer isn't code-signed yet (I'm a solo dev), so Windows will show "Windows protected your PC". Click More info → Run anyway. If you'd rather not, read the code and build it yourself (below).

macOS tip: the build is unsigned, so if macOS blocks it, right-click the app → Open.

From source (any OS, incl. Linux) — needs Node.js 20+ and roughly 1 GB free disk for npm install:

git clone https://github.com/ibmshaikh/OpenPilot.git
cd OpenPilot
npm install
npm start

If native modules complain after updating, run npm run rebuild.

Step 3: Connect the model

On first launch, onboarding asks you to connect a model. Enter:

• Name: qwen3:8b (use the exact model name from ollama list)

• Base URL: http://localhost:11434/v1

• API key: Ollama doesn't check it, so any placeholder like ollama works

Using LM Studio instead? Start its local server and use its base URL (by default http://localhost:1234/v1) with the model name it shows.

You can add multiple models in Settings and switch per chat, e.g. a small local one for quick stuff and a bigger one for harder tasks.

Step 4: Pick a workspace

Choose the folder the agent should work in. Start with a throwaway or git-tracked project so you can diff/revert anything it does.

Step 5: (Optional) web search

OpenPilot can use TinyFish for web search and page fetch so the agent can look up current docs. It's optional; skip it for a fully offline setup.

Step 6: Give it a task

Start small and concrete, e.g.:

Read README.md and add a "Running tests" section based on package.json scripts.

You'll see streaming replies, thinking blocks, file edits and shell output as tool cards, and approve/deny prompts for sensitive actions. Token usage per model is in the usage view.

Other things worth knowing about: MCP servers can be connected and enabled per chat, skills (reusable playbooks, type / in the composer), and persistent memory.

Honest limits

• Small models struggle with long multi-step tasks. 8B is great for focused edits; for longer chains it can lose the plot. Break tasks up or use a bigger model.

• No loop/retry guard yet. A model can get stuck repeating itself. Stop it and rephrase. A guard is planned.

• Unsigned builds on Windows and macOS (see tips above). macOS is a beta.

• No Linux installer yet, source build only.

• Telemetry: anonymous usage data (app opens, model/feature use, token counts; no chats, files, paths or keys) is on by default. Turn it off during Getting Started or in Settings → About.

Links

• GitHub: https://github.com/ibmshaikh/OpenPilot (MIT)

• Site: https://openpilot.in

• Bugs and model-compatibility reports welcome in Issues. If a particular local model works (or doesn't) for you, I'd love to know.

Disclosure: this post was drafted with help from an AI assistant. Field names and default ports can differ between versions, so if a step doesn't match what you see, please open an issue.