PrimeCode adds a full graphical interface to OpenCode CLI right inside VS Code

PrimeCode is a VS Code extension that gives OpenCode CLI a full-fledged graphical interface and moves agent work from the terminal into a familiar IDE. The project doesn't change OpenCode itself, but adds a visual layer on top of it, making it easier to track the progress of a long session and understand what exactly the agent is doing.

Why the terminal isn't enough

OpenCode is inherently strong as a CLI tool: it's fast, flexible, and fits well into a developer's usual workflow. But on long tasks, the terminal becomes a narrow window: it's hard to quickly evaluate the sequence of tool calls, understand which files the agent has already touched, what changed between steps, and how much context or tokens were spent on a specific segment of work. When a session stretches for hours, such opacity becomes as much of a problem as the model's errors themselves.

This is exactly the problem PrimeCode is trying to solve. The extension gives developers a proper visual surface inside VS Code, so they don't have to jump between the editor and console, but can see the agent's state right next to the code. This is especially useful where control matters: when you need to quickly check the context, track side effects, or revert to a previous action without manually reading through a long terminal log.

For team work, it also lowers the barrier to entry for those who don't like living in the CLI.

What the UI shows

According to the author's description, PrimeCode doesn't try to become a fork of OpenCode or a separate product. The logic stays in the CLI agent, and the extension communicates with it through an SDK and SSE streaming, meaning it receives events in real time and turns them into an understandable interface inside the IDE. This is an important architectural detail: the user gets visual control without giving up the already familiar tool and its launch scenarios in their workflow.

"Not a fork, not a separate product — exactly a UI layer on top of OpenCode".

From what's already been announced, the interface should address the most painful points of long agent sessions. This isn't about decorating the terminal, but about observability: when you can see not just the model's response, but the entire trace of its actions. For an IDE, this is a natural format, because developers make decisions on the spot, right next to files, diffs, and change history.

Such a layer saves time on manually reconstructing the agent's previous steps. tool calls in chronological order file changes throughout the session current context and interaction history token spending at individual stages * continuation of existing OpenCode sessions ## Old sessions without loss The author separately emphasizes compatibility with existing OpenCode sessions. If agent work began earlier in the terminal, it can be opened through PrimeCode and continued inside the extension without losing context.

The dialogue history, tool calls, and overall session state are picked up — the things usually lost when trying to switch to a different interface. For work tasks, this is critical, because migration between tools often breaks the flow and forces you to start almost from scratch. In practice, this model makes PrimeCode not an alternative to OpenCode, but an enhancement for those cases where the CLI is no longer enough.

The same agent process can be run the usual way, and then connected to in VS Code when you need an overview of what's happening, navigation through steps, and more convenient work with the results of changes. This is a neat path for a product that wants to strengthen the experience without breaking the already established stack.

What this means

If PrimeCode is brought to a stable state, OpenCode could gain an important bridge to a wider VS Code audience. For developers, this is not a replacement for the CLI, but a way to make agent work more transparent, more convenient, and less tiresome on long sessions, especially when it's important to simultaneously see the code, action history, and current resource spending in one window, without constant manual switching between tools and terminal.