DEV Community: OpenPilot

OpenPilot vs Cursor, Cline and Continue: an honest comparison (from the person who built OpenPilot)

OpenPilot — Sun, 18 Oct 2026 05:47:59 +0000

I'm the solo dev behind OpenPilot, an open-source desktop agent that runs on whatever model you give it. People keep asking how it compares to Cursor, Cline and Continue, so here's my best attempt at a fair answer. I'm obviously biased, so I've stuck to things you can check in each project's own docs or code, and I've linked them. Where another tool is better, I say so.

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

	Cursor	Cline	Continue	OpenPilot
License	Proprietary	Apache-2.0 (JetBrains plugin not open-sourced)	Apache-2.0	MIT
Form factor	Full editor	VS Code ext, JetBrains plugin, CLI, desktop app (v0.0.x), SDK	VS Code ext, JetBrains plugin, CLI	Standalone desktop app (Electron)
Bring your own key	Yes, on Premium and above (OpenAI, Anthropic, Google, Azure, Bedrock); not on Free/Plus	Yes	Yes	Yes, it's the only way it works
Local models (Ollama / LM Studio)	Not among the documented BYOK providers	Yes	Yes	Yes (Ollama preset; LM Studio via custom base URL)
Any OpenAI-compatible endpoint	Not documented for BYOK	Yes	Yes	Yes
Approval before commands/edits	Has agent review and security settings (see their docs)	Yes, every edit and command by default, with auto-approve available	—	Yes for shell commands, file writes and edits: Deny / Allow / Allow all for this session
Undo / checkpoints	—	Yes (checkpoints)	—	No. Use git
Tab autocomplete	Yes (Cursor's own models, even with BYOK)	—	Yes	No
MCP	Yes	Yes	Yes	Yes
Maintained	Yes	Yes, very active	No, read-only repo	Yes (solo)
Price	Free tier, paid from $8/mo	Free (you pay your model provider)	Free	Free (you pay your model provider, or nothing with local models)

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.

Run a local coding agent with LM Studio + OpenPilot

OpenPilot — Sat, 17 Oct 2026 05:46:16 +0000

A few days ago I wrote up how to run OpenPilot with Ollama. I've also been testing it through LM Studio, so here's that version. It's shorter, because LM Studio does most of the work.

Quick context if you haven't seen it: OpenPilot is a small open-source desktop app I built because I wanted something Cursor-style that would run on whatever model I picked, including local ones. The agent works inside a folder you choose, reads and edits files, runs shell commands, and asks before doing anything sensitive.

Why LM Studio

You can browse and download models from inside the app, no terminal needed.
It runs an OpenAI-compatible server on your machine, which is exactly what OpenPilot talks to.
It's easy to see how much memory a model will need before you load it.

Step 1: Get a model

In LM Studio's model search, grab a Qwen 3 model. I've had good results with Qwen 3 8B and Qwen 3 27B. If you're not sure what your machine can handle, start with the 8B.

Step 2: Load it with a bigger context window

This is the one step people miss. When you load the model, raise the context length above the default. An agent sends file contents, tool results and its own history back to the model on every turn, and a small window fills up fast. If replies suddenly get confused or cut off halfway through a task, this is the first thing to check. How high you can go depends on your RAM/VRAM.

Step 3: Start the local server

Open the Developer tab and switch on "Start server", or from a terminal:

lms server start

By default it listens on http://localhost:1234, and the OpenAI-compatible base URL is http://localhost:1234/v1. If you changed the port in LM Studio's server settings, use that one instead.

Step 4: Install OpenPilot

Windows: OpenPilot-Setup.exe (portable .exe on the releases page too)
macOS (beta): .dmg for Apple Silicon or Intel from Releases
Linux: no installer yet, but git clone, npm install, npm start works from source (Node.js 20+)

Neither build is code-signed yet, because I'm one person. On Windows click More info, then Run anyway on the SmartScreen prompt; on macOS right-click the app and choose Open.

Step 5: Connect the model in OpenPilot

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

Name: the model identifier LM Studio shows for the loaded model
Base URL: http://localhost:1234/v1
API key: LM Studio doesn't need one by default, so any placeholder works (if you turned on authentication in LM Studio's server settings, paste that token instead)

You can add more models later in Settings and switch per chat, so it's easy to keep a small fast model and a bigger one side by side.

Step 6: Pick a folder and give it something small

Pick a git-tracked or throwaway project so you can diff or revert anything. Then try something concrete, like:

Look at package.json and add a "Scripts" section to README.md explaining each one.

You'll see the file reads, edits and shell commands as cards, and approve or deny prompts for anything sensitive.

Honest limits

Small local models are good at focused edits and worse at long multi-step chains. Break big tasks into smaller ones, or switch to a bigger model for those.
There's no loop guard yet, so a model can occasionally repeat itself. Stop it and rephrase.
Unsigned builds, macOS is still beta, and no Linux installer.
Telemetry: anonymous usage data (app opens, which features and models get used, token counts; no chats, files, paths or keys) is on by default. You can turn it off during Getting Started or in Settings, About.

Links

GitHub: https://github.com/ibmshaikh/OpenPilot
Site: https://openpilot.in
The Ollama version of this guide: https://dev.to/openpilot/run-a-local-coding-agent-with-ollama-qwen-3-using-openpilot-3j8n

If a model works well (or badly) for you in LM Studio, please open an issue and say which one. That's the most useful thing I can get right now.

Disclosure: I drafted this post with help from an AI assistant. The steps are based on my own LM Studio testing and LM Studio's docs; if something doesn't match what you see, open an issue and I'll fix it.

One week of launching a solo open-source desktop agent: the real numbers

OpenPilot — Thu, 15 Oct 2026 05:50:50 +0000

A week ago OpenPilot, the open-source desktop agent I built because I wanted a Cursor-style tool that runs on my own model, had 1 GitHub star. I launched it on Product Hunt on October 9 and wrote a couple of posts here. This is a short, honest look at what actually happened, mostly so I remember it and partly in case it's useful to someone else launching a small project alone.

The numbers

All of these come straight from GitHub's API and the Product Hunt page, nothing rounded up.

	Oct 9 (before launch)	Oct 15
GitHub stars	1	18
Forks	0	4
Windows installer + portable downloads (all releases, all time)	170	423
macOS downloads (dmg + zip)	6	14
Open issues	0	1

Product Hunt: it finished launch day at #9 with about 88 upvotes and 54 followers. On launch day itself there were zero comments from other people, and one thoughtful question came in the next day.

What I learned

Upvotes are not installs. For most of launch day the Product Hunt page was getting attention but almost nobody was downloading. The "Visit website" button sends people to the landing page, and from there it's another click or two to GitHub Releases. When I put a direct Windows download link (plus a note about the unsigned-app warning) in the maker comment, downloads started moving. That's the single change I'd make earlier next time.

The unsigned installer costs people. Windows SmartScreen and macOS both warn on unsigned apps. Explaining it up front helps, but I'm sure some people bounce. Signing is on the list.

I'd rather write tutorials than announcements. An "it's live" post says nothing new after the first day. A step-by-step setup post, like the one on running it locally with Ollama and Qwen 3, answers the question people actually ask, which is "will this work with the model I already run?"

Slow and steady is still something. Downloads jumped in the first few days after launch and have settled to roughly 15 to 20 new installs a day. Not a rocket, but real people are trying it.

What's next

A proper LICENSE file in the repo (it says MIT in the README, but GitHub doesn't detect it yet, which blocks some lists).
Testing more local models and writing up what works and what breaks.
Smaller fixes from the first issue reports.

A note on privacy since it comes up: OpenPilot currently sends anonymous usage data by default (app opens, feature use, token counts, no chats, files, paths or keys). You can turn it off during setup or in Settings → About.

If you've tried it with a model that didn't behave, I'd genuinely like to know which one. Repo is here.

I used an AI assistant to help draft and edit this post. The numbers are from GitHub and Product Hunt.

Run a local coding agent with Ollama + Qwen 3 using OpenPilot

OpenPilot — Mon, 12 Oct 2026 20:46:10 +0000

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.

OpenPilot is live on Product Hunt today

OpenPilot — Fri, 09 Oct 2026 16:23:19 +0000

Quick update from a solo builder: OpenPilot launched on Product Hunt today, and it's sitting at #9 for the day as I write this. Thanks to everyone who checked it out.

If you missed the intro post: OpenPilot is an open-source (MIT) desktop AI agent that works with the model you choose. Paste a base URL, key and model name (OpenAI, OpenRouter, or a local Ollama / LM Studio server), pick a folder, and ask for something. It reads and edits files and runs commands, and every tool call shows up as a card, with sensitive actions waiting for your approval. It's not an IDE, just an agent that works in a folder you pick.

Locally, Qwen 3 8B and Qwen 3 27B have worked well for me on simple tasks.

Try it

Windows installer (direct download): https://github.com/ibmshaikh/OpenPilot/releases/latest/download/OpenPilot-Setup.exe The build isn't code-signed yet, so Windows SmartScreen may warn you. Click "More info", then "Run anyway".
Mac: unsigned beta builds on the releases page: https://github.com/ibmshaikh/OpenPilot/releases
Website: https://openpilot.in
Product Hunt: https://www.producthunt.com/products/openpilot
Source: https://github.com/ibmshaikh/OpenPilot

Honest status: Windows works best right now, macOS is an early beta, there's no Linux build yet, and anonymous usage stats are on by default (no chats, files or keys) and can be turned off in Settings.

If you try it, I'd love to hear what breaks on install and which models you want tested.

This post was drafted with AI assistance.

I wanted a Cursor-style agent that runs on my own model, so I built one

OpenPilot — Fri, 09 Oct 2026 05:50:20 +0000

Disclosure: I'm Ibrahim, the solo developer of OpenPilot. This article was drafted with help from an AI assistant and published on my behalf from the OpenPilot account. It's not related to comma.ai's openpilot driving project, which is a completely different thing.

I use AI coding agents a lot, and I really like the way tools like Cursor work: you describe a task, the agent looks at your files, runs commands, fixes things, and you watch it happen. What I wanted was that same experience, but open source and running on my own model, whether that's a hosted API or something local.

I looked around for an open-source tool that worked the way I had in mind and couldn't find one that fit. So I built it. It's called OpenPilot.

What OpenPilot is (and isn't)

OpenPilot is a desktop app, built with Electron. You give it a model, a folder, and a task. It's not an editor or an IDE, and it's not a Cursor replacement. It's a standalone agent that works inside a project folder you choose.

Bring your own model. Any OpenAI-compatible endpoint: a base URL, an API key, a model name. OpenAI, OpenRouter, a local server like Ollama or LM Studio, or your own gateway.
A real workspace. The agent can read and edit files in the folder you pick and run shell commands, with streamed output.
You stay in control. Tool calls show up as cards in the chat, and sensitive actions wait for you to approve or deny them.
Skills. Reusable playbooks the agent can load; type / in the composer.
MCP. Connect Model Context Protocol servers and toggle their tools per chat.
Memory. Persistent memory settings so the agent can keep useful context between sessions.
Token usage. Session and lifetime usage broken down by model, so you can see what things cost.
Optional web search. Plug in a TinyFish key if you want the agent to look up current docs.
MIT licensed. Read it, fork it, change it.

Getting started

Download the latest build from GitHub Releases (Windows installer or portable exe), or see openpilot.in for the guide.
On first launch, onboarding walks you through three steps: connect a model, choose a workspace folder, and optionally add a TinyFish key for web search.
For the model step, paste a base URL, API key and model name. For a local model, that's the OpenAI-compatible address of your Ollama or LM Studio server, with any placeholder as the key if your server doesn't check it.
Pick a folder you don't mind the agent touching (a scratch project is a good start), describe something small, like "add a README and a failing test for this function", and watch the tool cards.

Prefer running from source?

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

You need Node.js 20 or newer.

Honest status

I'd rather tell you the rough edges up front:

Windows is the main target right now. macOS builds exist but are early and unsigned. There's no Linux build yet.
Small local models are fine for simple things, but longer multi-step work really benefits from a stronger model. I'm planning to test more local models and write down what actually works.
Telemetry: OpenPilot currently sends anonymous usage stats by default (app opens, which models and features get used, token counts). It doesn't send chats, files, paths or API keys, and you can turn it off during onboarding or in Settings → About. I'm working on making this clearer, because I think it should be obvious and easy to opt out of.
It's early, and it's just me.

Where I'd love help

If you try it, the most useful thing you can do is tell me what broke or confused you: which model you used, what OS, what you expected. GitHub issues are the best place. If you want to contribute code, the repo is plain JavaScript and the README has a short contributing guide.

Code: github.com/ibmshaikh/OpenPilot
Download and guide: openpilot.in

Thanks for reading. I'll be posting setup tutorials (Ollama, LM Studio, MCP, skills) here over the next few weeks.