A desktop manager for the OpenCode CLI

OpenCode is a popular open-source AI coding agent CLI — the project lives at sst/opencode on GitHub. It is terminal-first: you run it from the shell, authenticate with opencode auth login, and let the agent plan and execute multi-step changes inside a repository. OpenCode is provider-agnostic, which means you bring your own model access — Anthropic, OpenAI, or other providers you configure — rather than being locked to one vendor's subscription.

OpenCode ships a polished TUI for that single-session workflow. The terminal interface is genuinely good for focused work in one repo: prompts, tool calls, and file edits stay in one surface. What it does not provide is a desktop manager for many projects, many parallel agents, and an operations layer around shipped products. That is the gap a OpenCode GUI fills.

An OpenCode GUI is a desktop app that sits on top of the OpenCode command-line tool and gives you a graphical way to run it — instead of driving the agent only through its terminal TUI. The CLI and TUI are excellent for one session in one checkout. They are less suited to juggling several repositories, comparing diffs side by side, running OpenCode next to Claude Code or Grok in the same workflow, or turning production signals into scoped agent tasks without losing context.

Aiola is that graphical layer. It is a local-first desktop app for macOS and Windows that turns OpenCode into a managed, multi-project workspace: parallel threads, a central view across every repo, tasks that trigger agents, cron-style automations on your existing subscriptions, and an operations layer — web analytics including AI-bot crawl tracking and AI Assistants referrals, app logs that spawn one-click fix-threads, a feedback inbox, and GSC/Bing indexing — around the code. Aiola is not a model provider and it is not an IDE; it is the manager above the CLI you already use.

OpenCode's TUI solves the in-terminal experience well. The moment you run OpenCode in more than one repo — or want it beside Claude Code, Codex, Cursor, and Grok CLI — the hard part stops being the agent and starts being coordination. Which project had which run? What did OpenCode change yesterday in the other service? Where is the task you meant to hand off? In a TUI-only workflow that state lives in your head and in a dozen tabs.

An OpenCode manager solves the coordination problem:

• One window shows every project's active threads, recent changes, and pending tasks.
• Threads keep each line of work isolated, with optional git worktrees so concurrent OpenCode sessions do not stomp the same checkout.
• Queued turns let you line up follow-ups without losing context when a long run is still going.
• Sessions restore after restart, so work you left open is still there when you reopen Aiola.
• Task boards that execute — not just track — hand scoped outcomes to OpenCode and return results to your workflow.
• Automations let OpenCode run on a cron-style schedule with the provider access you already pay for.
• Terminals, a notebook, a canvas, diffs, and a built-in browser sit next to the agent instead of in other apps.

Aiola is the layer above OpenCode's TUI for many projects and many agents — not a replacement for the TUI when you want a single focused terminal session.

Aiola wraps the OpenCode CLI with the surfaces a multi-project workflow needs:

• Threads — each thread is an independent OpenCode session with chat, file-by-file diffs, branches, a terminal, and a built-in browser. Run several in parallel and split them side by side or lay them out on a canvas.
• Git worktrees — optionally isolate concurrent OpenCode changes so two threads in the same repo do not fight over one working tree.
• Tasks — a per-project board that can trigger an OpenCode agent and hand the result back as a pull request.
• Automations — schedule recurring OpenCode jobs (triage, checks, summaries) that run on your machine with your own provider access.
• Agent personas and skills — reusable configurations with role, skills, and memory so OpenCode threads start with the right context.
• MCP server — connect tools and data sources the agent can call without leaving the workspace.
• GitHub, app logs, analytics, and feedback — the operations layer that lives next to the code, not in five other tools.
• A central cross-project dashboard so you steer the whole portfolio, not one repo at a time.

Authenticate OpenCode with opencode auth login, then download Aiola and point it at your projects. Pick OpenCode as the agent per thread and bring whichever provider access you already have — Anthropic, OpenAI, or others OpenCode supports.

OpenCode is provider-agnostic by design, but it is still one CLI. Aiola orchestrates OpenCode, Claude Code, Codex, Cursor, and Grok CLI from one app, on your own subscriptions. Pick the agent per thread or per task and switch depending on the job — OpenCode with one provider on a refactor, Claude Code on a security pass, Grok on an experiment, Codex on a quick fix — without leaving the workspace. That cross-vendor reach is the difference between a single-tool surface and a real command center. Read more about how Aiola orchestrates coding agents.

If you already use a Claude Code manager or other agent GUIs elsewhere, Aiola consolidates them: all five CLIs share the same threads, tasks, automations, and central view. Running OpenCode next to the subscription agents you already pay for is the practical reason to adopt a manager instead of five separate terminal sessions.

OpenCode's terminal TUI is excellent for single-session work in one repository. If you prefer a terminal-only workflow, want to evaluate OpenCode before adding another app, or only ever run one agent in one checkout, staying in the TUI is honest advice. Authenticate with opencode auth login, point OpenCode at a repo, and see whether the agent fits before layering a manager on top.

Aiola earns its place when OpenCode work spans several repositories, needs durable context across sessions, or sits alongside Claude Code, Codex, Cursor, and Grok CLI in the same portfolio. Threads preserve each line of work; worktrees isolate concurrent changes; tasks provide an explicit queue that executes; and the central view shows what is active across every project. Logs, feedback, analytics, and GitHub surfaces are useful when a shipped-product signal should become a scoped coding task without losing its source context.

Aiola is also not a cloud runner, a model subscription, or an IDE. It will not replace the provider access OpenCode needs, hide usage limits, or validate a change for you. Keep final review, tests, migrations, and merge decisions manual. The GUI solves coordination across projects and agents — not judgment on individual diffs.

Aiola runs the OpenCode CLI on your own machine, against your own repositories. Your code is never uploaded to Aiola — it stays on your machine and goes only to the AI provider you already subscribe to — there is no cloud runner, no compute resale, and no API-key middleman. You bring the provider access OpenCode already uses. Threads, tasks, and notes are stored locally, and the analytics you collect from your own products are sent through Aiola's cloud when you enable the optional analytics, logs, and feedback layer. Read more about how Aiola keeps your data yours.

Aiola runs on macOS 11+ (Apple Silicon and Intel) and Windows 10+ (64-bit). OpenCode is cross-platform. There is nothing to configure beyond signing in to the CLIs you already use — just download Aiola, authenticate OpenCode, and point the app at your projects. See pricing for the 7-day free trial and Pro plans.