What it is

Capy is a desktop app for coding agents that run entirely on your Mac. Ask it to change code, explain a project or just chat. A capable agent reads your files, plans, edits and runs commands, and asks before it touches anything. The model, the agent and your data all stay on your machine.

Under the hood Capy bundles two open-source engines and makes them feel like one app:

• opencode is the agent: sessions, tools, permissions, agents, skills, MCP servers and plugins.
• Ollama runs the model on Apple's MLX engine, the fastest way to run local models on Apple Silicon.

Capy starts and supervises both, wires them together, and surfaces every opencode setting in a real settings screen, so you never touch a terminal or a JSON file unless you want to. Nothing is sent to a cloud model provider; there isn't one configured.

See it in action

Open the video with pause and scrub controls
_{Real recording on an M5 Max running Qwen 3.8 27B (MLX, 4-bit) locally. Sped up 2×; waiting is trimmed.}

The example: in a small git project, you ask Capy to “plan this with your to-do list: add a slugify(text) helper to src/utils.js, add a test for it, then run the tests.” The agent writes a to-do list, explores the project, and asks for approval before each edit and before running npm test, ticking items off as it goes. It finishes with working code and two passing tests, and the Changes panel shows exactly what it did, all without a byte leaving the laptop.

Start · Architecture · Models & thinking · Settings · Develop

Start

Install

1. Download Capy-<version>-arm64.dmg from Releases.
2. Open it and drag Capy into Applications.
3. Open Capy. Current builds aren't notarized by Apple yet, so macOS blocks the first launch: open System Settings → Privacy & Security, scroll to “Capy was blocked…”, click Open Anyway, and confirm. You only do this once.

Everything Capy needs (Ollama, opencode, the browser tool) is inside the app; no Node.js, Homebrew or terminal required. Capy checks GitHub for new versions and offers the download (once builds are signed, updates will install themselves).

Or run from source

git clone https://github.com/giga-dylan/capy.git
cd capy
npm install      # also fetches the pinned Ollama + opencode builds
npm run dev

On first launch Capy starts its local services and asks you to pick a model. Download one of the recommended models, any model from the Ollama library, or import one you already have on disk (for example an MLX folder from LM Studio). Then just type:

Help me understand how this project handles authentication.

There is no setup wizard and no account. Chats work without a folder; pick a project from the folder button in the chat box when you want the agent to work on code.

Requirements: an Apple Silicon Mac with 32 GB of memory or more for the 27–30B models (smaller models need less) and macOS 14 or later.

Architecture

The window never talks to a model directly. The Electron main process starts both services on random localhost ports, gives opencode a fresh password every launch, generates opencode's config from your settings and installed models, and forwards live events (streaming text, tool calls, approval requests) to the window.

Working with the agent

Next to each chat, a right-hand panel shows the Side chat, Subagents, Changes, Files and Terminal.

Everything here is a view over opencode's own API, so it behaves exactly like opencode does.

Models and thinking

Pick from a curated list, any Ollama library tag, or import an MLX/safetensors folder or .gguf file. Models without tool support are flagged, because an agent needs tools to do real work. A separate, smaller model can handle chat titles and summaries.

Thinking (reasoning effort) follows the model. Capy reads each model's supported levels from Ollama and offers only those. Ollama silently ignores levels a model doesn't support, so guessing would mean a picker that does nothing. These were tested on real models:

Settings

Everything opencode can do is surfaced in Settings, and each screen shows what's actually loaded right now (built-in agents, skills, MCP status, formatters), not just what's configured.

Every screen edits one JSON layer that is merged over the config Capy generates, so the raw editor in Advanced and the forms never disagree. Saving restarts the agent engine in about a second; switching model, thinking or agent doesn't.

Capabilities and limits

• Local models are smaller than frontier models. Expect good results on focused tasks and slower, less reliable ones on sprawling changes. Qwen 3.8 27B on an M5 Max generates ~30 tokens/s and reads a 16K-token prompt at ~930 tokens/s.
• Memory decides the model. 27–30B models need about 32 GB; the first load of a model from a slow external drive can take ~40 s.
• Approvals are on by default. File edits, shell commands, web fetches and access outside the chat's folder all ask first. Relax them per pattern, or switch the access mode: Auto-approve lets work inside the project run freely, and Full access never asks. A switch applies instantly, even to a task that's already running.
• Browser use runs Microsoft's Playwright MCP (bundled) in Google Chrome with a separate Chrome profile; Chrome must be installed. It's an ordinary MCP server in opencode's config.
• Goal mode isn't in opencode itself. Capy enables the opencode-goal-plugin through opencode's plugin system (toggle in Plugins & hooks); it installs from npm on first start.
• Side chat forks the chat with opencode's own session.fork and runs the read-only plan agent. opencode 2.0 adds a native /btw; Capy will switch to it when 2.0 ships.
• Internet only when you ask. Model downloads, web fetch/search tools you allow, and MCP servers you add are the only network use. Chat sharing and auto-update are off.
• Claude Code compatibility is off. opencode can load ~/.claude/skills and CLAUDE.md; Capy disables that by default so it only uses what's configured in Capy. Toggle it in Skills and Rules.
• macOS on Apple Silicon only for now.

Private state and storage

Capy keeps its own opencode folders, so it never collides with an opencode you've installed yourself. Open config folder in Settings jumps straight there.

Develop

npm install          # dependencies + pinned Ollama/opencode builds in resources/bin
npm run dev          # run with hot reload
npm run typecheck
npm run dist         # arm64 DMG + zip in dist/ (signed if a Developer ID cert is available)

Pinned runtime versions live in package.json → "binaries"; bump them together with @opencode-ai/sdk and opencode-darwin-arm64, then run npm run fetch-binaries.

Releasing: bump version in package.json, commit, then push a matching tag (git tag v0.2.0 && git push origin v0.2.0). The Release workflow builds on an Apple Silicon runner and uploads the DMG, zip and latest-mac.yml to a draft release; publish it on GitHub to make it the update everyone gets.

Signing: without a certificate, builds are ad-hoc signed (users approve them once, and they can't update themselves). To sign and notarize, join the Apple Developer Program and add repository secrets MAC_CERTIFICATE_P12 (base64 of your Developer ID Application .p12), MAC_CERTIFICATE_PASSWORD, APPLE_ID, APPLE_APP_SPECIFIC_PASSWORD and APPLE_TEAM_ID. The workflow picks them up automatically. Locally, npm run dist uses a Developer ID certificate from your Keychain and notarizes when the APPLE_* variables are set.

src/main/       Electron main: services (ollama.ts, opencode.ts), settings, extensions, IPC
src/preload/    The window.api bridge
src/renderer/   React UI: chat, sidebar, pickers, settings/
src/shared/     Types shared by both sides
assets/         README images and demo

---

opencode docs · Ollama · Architecture · Settings