A desktop agent for your local model: Snotra and OpenCode Desktop compared

The starting point is a common one by now. You have decided to run a language model yourself — because the files you work with shouldn’t leave your computer, because your company won’t send them to a cloud provider, or simply because you want to see how far an open-weight model gets you. Ollama or LM Studio is installed, a model is downloaded, and it answers in a chat window.

A chat window is not what you wanted, though. You want an agent: something that opens the folder with your notes, your offer drafts or your data, reads what is in it, and writes the result back. And you would rather not do that from a terminal.

Search for that and two open-source desktop apps come up that can work with a local model: OpenCode Desktop and Snotra. This article compares them for exactly that situation, with a focus on who each one is built for and how it feels to use, and then on what each lets the agent do without asking.

A disclosure first: I build Snotra. I have tried to compare fairly, to give OpenCode credit where it is ahead, and to name what Snotra lacks. If I got something about OpenCode wrong, the Discussions are the place to tell me.

What this comparison covers

OpenCode started as a terminal application and is best known as one. It now comes in three forms: the terminal interface, an IDE extension, and a desktop app. This article only looks at the desktop app. The question here is what someone gets who doesn’t want to work in a terminal, and my assumption is that the terminal version is a hurdle for most people who aren’t developers. That is an assumption, not a finding; plenty of people learn a terminal tool happily when it gets them what they need.

Both projects move fast. OpenCode is in the middle of a move from its first major version to a second one, with two sets of documentation; where they differ, I say so. Snotra is described as of version 1.24.2. Everything below is as of October 2026, going by each project’s own documentation and code.

Who each one is built for

OpenCode is clear about its audience. It calls itself “the open source coding agent”, and its documentation starts with which terminal emulator to use. The desktop app keeps that vocabulary: projects and sessions, Git worktrees to run sessions side by side, a Build and a Plan agent you switch with the Tab key, a review panel for changes and a built-in terminal. For someone who writes software, every one of those words means something useful.

Snotra is built around a folder, and the README describes it as keeping the folder in view “without being an IDE, for work that isn’t code”. There is no terminal in the app and no Git interface. The words on screen are a folder, a chat, a model, and a card that asks before something happens. A manual with screenshots ships inside the app and opens with F1, offline.

Neither approach is better in general. They answer different questions: OpenCode asks how a developer gets the most out of an agent, Snotra asks how someone who doesn’t write code can let an agent into a folder without worrying about it.

What OpenCode does well

• A large, active project. More than 200,000 stars on GitHub, a team behind it (Anomaly, the people behind SST), and a release almost every day. Snotra is a one-person project.
• More platforms. Signed builds for macOS on Apple Silicon and Intel, Windows on x64 and ARM, and Linux on x64 and ARM, also through Homebrew and Scoop.
• Many providers. More than 75 providers through the AI SDK and models.dev, and a subscription, OpenCode Go, that gives you open-weight models hosted for you if your own hardware is too small.
• Parallel work. Several projects and sessions at once, each in its own Git worktree if you like.
• Undo. OpenCode keeps snapshots of your files in an internal Git repository and rolls back files and conversation together.
• Fine-grained rules. Every permission can be set to allow, ask or deny, per tool and per pattern — git * allowed, rm * denied, for example.
• Remote MCP with OAuth, Agent Skills, plugins and an extension system in the desktop app.
• More than 40 interface languages, German among them.

Side by side

Connecting the local model

This is the step where the two differ most for someone who isn’t a developer.

In OpenCode’s current documentation, a local server is a custom provider in a JSON file. You write an entry into opencode.json that names the package @ai-sdk/openai-compatible, points baseURL at http://localhost:11434/v1 for Ollama or :1234/v1 for LM Studio, and lists the models you want to use, with their context limits if you want OpenCode to know them. The desktop app has a dialog for connecting providers, but it covers the hosted ones: OpenCode’s own models, a ChatGPT login, API keys. The documentation for the second version adds automatic discovery: OpenCode then looks for Ollama, LM Studio and vLLM on their usual ports and lists what it finds. Anything else, llama.cpp for instance, stays a JSON entry.

For a developer, a JSON file is no obstacle and has its advantages: it can be versioned, shared and copied into the next project. For someone who has never opened a config file, it is the point where many stop.

In Snotra, the local model is set up where the cloud models are, in Settings › Models. Add model offers Ollama as a provider of its own, with its native API, and an OpenAI-compatible provider with templates for LM Studio, MLX-LM, llama.cpp, vLLM and OpenRouter. The template fills in the address, the key field may stay empty, Load models asks the server what it has, and Apply puts the model into the list. There is no file to edit. The whole way, with a screenshot for every step, is in Setting up your first model, step by step.

What neither app can take off your hands is the model itself. A model small enough for a laptop often struggles with tool calls, and an agent without working tool calls can’t read or write a single file. OpenCode’s documentation advises raising Ollama’s context size to 16k–32k if tool calls fail; Snotra doesn’t set that size either, so the same advice applies. I measured how small models fare in Snotra in What local models taught me about my agent harness; the short version is that an 8B model gets some tool calls right and many wrong.

Using it day to day

Once a model is connected, both apps work the same way at their core: you write what you want, the agent reads files, proposes or makes changes, and you see what it did.

Seeing the changes. OpenCode collects them in a review panel, which will feel familiar to anyone who has reviewed a pull request. Snotra lists the changed files with added and removed lines under each answer, opens a line diff with one click, and marks files in the tree that the chat changed or only read. One limit on Snotra’s side: that record lives in memory and is gone after a restart.

Taking something back. Here OpenCode is clearly ahead. Its snapshots roll back the files and the conversation to an earlier point. Snotra has no undo for what the agent did; it only puts a copy of a file into the system trash before replacing it as a whole.

Language. Both apps can show a German interface. OpenCode translates into more than 40 languages, with a German translation that is largely, not completely, done. Snotra has only English and German, both complete, and starts in the system language.

Getting help. OpenCode’s documentation is thorough and written for developers. Snotra brings its manual into the app, and the agent can answer questions about the app from it.

What the agent may do unasked

Here the two projects make opposite default choices, and both explain them.

OpenCode starts permissive. Its documentation says that most permissions “default to ‘allow’” — editing files, running shell commands and fetching web pages happen without a question. Working outside the project folder asks in the first version. Reading .env files is denied in the first version and asks in the second. Everything else can be tightened in opencode.json, per tool and per pattern, and the Plan agent is restricted to planning. There is no operating-system sandbox; the documentation says plainly that shell commands run with the authority of your user account. The safety net is the snapshot history.

Snotra starts cautious. In the default mode, Smart, the agent reads without asking and asks before every change and before targeted access to a sensitive file such as .env, keys or credentials. Shell commands and Python are switched off as shipped. Once switched on, every single run gets its own card with the complete command, and there is no “allow for this session”. On macOS and Linux, commands run in a sandbox that writes only inside the folder and reaches only the domains on the card; on Windows they run with your rights, and the card says so. Auto drops the questions, but only after a confirmation in a system dialog, for one chat or one folder you choose.

Which default suits you depends on who sits in front of the screen. A developer who works in a Git repository can let the agent run and look at the diff afterwards; an unwanted change is one command away from undone. Someone working in a folder of documents that isn’t under version control has no such fallback, and a question before the change is the safety net. With a local model, which makes mistakes more often than a frontier model, that matters more, not less. That is my reading, not a measurement.

Two more points belong in a fair account. OpenCode’s local server had serious vulnerabilities this year, among them CVE-2026-22812, which allowed commands to be run through an unauthenticated server; they were fixed, and the desktop app now protects its background server with a random password. A project of OpenCode’s size also gets far more scrutiny than Snotra, so no published vulnerability on Snotra’s side is not proof that there are none. And neither app protects you from what the agent reads: a prompt injection in a file or a web page can steer any model. Snotra treats fetched text as material, not instruction, and every tool call after it still goes through approval.

On privacy, Snotra has no account, no server and no telemetry, not even opt-in. OpenCode needs no account for your own keys or a local model; I found no statement on telemetry in its documentation, and automatic updates are on by default.

What Snotra doesn’t do yet

• No sandbox and no signing on Windows. Commands run with your rights there, and SmartScreen warns on first launch (#19).
• Fewer platforms. No Intel Mac, no ARM builds for Windows or Linux.
• No undo for the agent’s changes, and the record of changed files is lost on restart.
• No worktrees and no built-in terminal, so it is no replacement for a developer’s toolbox.
• Remote MCP only arrives with the next release, and without OAuth.
• No Office output. Snotra reads PDF, Word, Excel and PowerPoint, but doesn’t write them.
• A one-person project. Interfaces and configuration can still change.

Which one to pick

Take OpenCode Desktop if you write software, work in Git repositories, are comfortable with a JSON file, and want parallel sessions, undo and a large community. If you later move to the terminal, the same configuration comes along.

Take Snotra if you want to connect a local model without editing a file, work in folders that aren’t code, and want an agent that asks before it changes anything — with a sandbox on macOS and Linux behind it.

Both are free and open source, so the cheapest way to decide is to install both and point them at the same model and the same copy of a folder.

Trying it

Snotra runs on macOS, Windows and Linux: download it here, or read the source on GitHub. OpenCode Desktop is at opencode.ai.

If you use OpenCode with a local model and see something differently, I’d like to hear it in the Discussions.