OpenCode 2.0: a maior atualização de todas (grátis + modelos locais)

Autoria: Leon van Zyl · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: OpenCode 2.0: Biggest Update Ever (Free + Local Models) · Canal: Leon van Zyl · 14:26 · Assistir no YouTube

Tópicos: Agentes de IA, Engenharia de software com IA, Ferramentas de desenvolvimento com IA, Modelos locais e open source

Resumo

Leon van Zyl apresenta os novos recursos do OpenCode 2.0 enquanto cria um app simples para dividir contas. A atualização permite compartilhar sessões entre o terminal, o app para desktop e o celular, além de executar tarefas e subagents em segundo plano. O vídeo também demonstra code mode, worktrees e plugins criados pelo próprio agent. Por fim, mostra como configurar modelos gratuitos e executar modelos locais com Ollama.

Pontos-chave

As sessões do OpenCode são compartilhadas entre terminal, app para desktop e celular.
O OpenCode aceita modelos de vários provedores e também modelos locais.
Tarefas e subagents podem ser executados em segundo plano sem bloquear a interação com o agent principal.
O code mode permite que o agent escreva scripts para executar várias chamadas de ferramentas.
Worktrees permitem testar alterações em uma cópia do código antes de integrá-las à branch principal.
Agents podem criar plugins, como um que solicita permissão antes de ler arquivos .env.
Modelos gratuitos podem ser úteis para começar, mas o vídeo alerta que os prompts podem ser usados para treinamento.
Ollama permite executar modelos localmente, sem depender de uma conexão com a internet.

Capítulos

Início	Capítulo	Resumo
00:00	Novidades e instalação do OpenCode 2.0	O apresentador atualiza o OpenCode, demonstra a instalação e apresenta o app para desktop.
02:41	Sessões compartilhadas e modelos gratuitos	O vídeo mostra a seleção de modelos e o compartilhamento de uma sessão entre terminal e app para desktop.
05:22	Tarefas em segundo plano e subagents	O apresentador executa tarefas e um agent de revisão em segundo plano, com acesso à sessão também pelo celular.
08:05	Code mode e worktrees	O vídeo demonstra chamadas de ferramentas via code mode e alterações isoladas em uma worktree antes de integrá-las.
10:43	Plugins e modelos locais com Ollama	O apresentador cria um plugin para proteger arquivos .env e configura um modelo local com Ollama.

Citações

Seu terminal, o app para desktop e até o celular compartilham a mesma sessão. — 00:00

Podemos mover a tarefa inteira para segundo plano e continuar interagindo com nosso agent. — 05:22

Code mode permite que o agent escreva o script que executa todas essas ferramentas de uma vez. — 08:05

A vantagem de executar esse modelo localmente é que ele é seguro e funciona offline. — 14:26

Conceitos e entidades

OpenCode (ferramenta): Agent de programação open source apresentado no vídeo, com suporte a vários modelos e interfaces.
OpenCode 2.0 (ferramenta): Atualização do OpenCode que adiciona recursos como sessões compartilhadas, tarefas em segundo plano, worktrees e plugins.
Beam (modelo): Modelo gratuito escolhido no vídeo para criar o app e realizar alterações no código.
Big Pickle (modelo): Modelo gratuito usado como subagent para revisar o código do app.
Ollama (ferramenta): Ferramenta usada no vídeo para baixar e executar modelos localmente.
Qwen3.8 (modelo): Modelo recomendado pelo apresentador para tarefas de programação, executado localmente com Ollama.
LM Studio (ferramenta): Aplicativo citado como opção para usar modelos locais com OpenCode.
Playwright MCP (ferramenta): MCP cujas instruções são usadas no exemplo de code mode para instalar a integração e abrir o app.
Leon van Zyl (pessoa): Apresentador que demonstra os recursos do OpenCode 2.0.

Tradução completa (pt-BR)

00:00 O OpenCode 2.0 foi lançado, e esta é a maior atualização que esse agent de programação open source já recebeu. Seu terminal, o app para desktop e até mesmo seu celular compartilham a mesma sessão. Agora, os agents podem ser executados em segundo plano enquanto você continua trabalhando. Ele pode escrever os próprios plugins enquanto você acompanha. E já vem com modelos gratuitos, então você pode criar seus apps ou acompanhar este vídeo sem pagar nada. Neste vídeo, vamos criar um app simples, mas também vamos conhecer todos os novos recursos do OpenCode 2.0 ao longo do caminho. Primeiro, se você já usa o OpenCode, é muito fácil atualizá-lo.

00:34 No OpenCode, basta executar o comando /update. Na verdade, aparece uma dica aqui. Então, vou executar o comando Update, assim. Depois, vou clicar em Upgrade. Em seguida, basta reiniciar o OpenCode. Agora estou usando o OpenCode 2.0, como você pode ver aqui embaixo. Se esta é a sua primeira vez usando o OpenCode, vou deixar o link para este site na descrição do vídeo. A instalação é muito simples. Se você usa Linux ou Mac, pode copiar o comando curl.

01:05 Ou, se você usa Windows, acesse o NPM e copie este comando. Depois, basta executá-lo no Prompt de Comando ou no PowerShell. Isso instalará o OpenCode. Vale mencionar também que o OpenCode tem um app para desktop. Mais uma vez, acesse o site e clique em Download. Ao rolar a página para baixo, você encontrará o app para desktop do OpenCode. Há versões para Mac, Windows e Linux. Vou baixar o app para Windows. Basta executar o arquivo que você acabou de baixar. É realmente simples assim. Agora também temos acesso ao app para desktop.

01:38 Você pode acompanhar usando o app para desktop ou o terminal. Vou usar o terminal, mas não se preocupe: todos os recursos funcionam nos dois. A propósito, tenho um curso gratuito que ensina a usar agents de programação com eficiência. Ele é voltado tanto para quem faz vibe coding quanto para desenvolvedores experientes. O curso ensina o framework que uso para criar qualquer projeto, com modelos gratuitos ou até modelos de ponta. Mais uma vez, é totalmente gratuito, e vou deixar um link na descrição. Recomendo que você crie uma nova pasta para o seu projeto. Vou criar a pasta bill splitter na minha máquina.

02:09 Depois, vou abrir o Prompt de Comando nessa pasta. E vou simplesmente executar o OpenCode. Assim, garantimos que todos os arquivos criados pelo agent para este projeto serão armazenados nessa pasta. Se você executar isso na raiz da sua máquina, sabe-se lá onde ele vai acabar adicionando todos esses arquivos. Se estiver usando o app para desktop, o processo é muito parecido. Basta clicar neste menu suspenso aqui embaixo, selecionar Add Project e, depois, escolher a pasta na sua máquina. E é só isso. Um dos novos recursos do OpenCode é que suas sessões são compartilhadas entre o

02:41 app para desktop, o terminal e também o app para celular. Vou mostrar como isso funciona. Vou iniciar a sessão no terminal e depois voltar ao app para desktop para mostrar que a mesma sessão também está disponível lá. Mas, primeiro, vamos selecionar nosso agent. O OpenCode oferece suporte a praticamente qualquer provedor, então você não fica limitado a um único modelo ou provedor. Ele também oferece suporte a modelos locais. Se executarmos o comando /models, podemos escolher entre uma grande variedade de modelos.

03:14 Temos modelos de provedores como OpenAI, Google, Anthropic e outros. E, se você tiver modelos locais usando Ollama ou LM Studio, também poderá selecioná-los aqui. Para este tutorial, vamos escolher um dos modelos gratuitos. Vou usar o Beam. Nunca usei esse modelo antes, mas já vamos ver se ele é bom. Por favor, crie um app simples para dividir a conta, que funcione no navegador. Beleza, ele entendeu.

03:46 Mas estou recebendo esta mensagem: a chave de API expirou; crie uma nova chave de API no console do OpenCode e substitua-a no armazenamento de cliente e segredo. Para corrigir esse problema, vou voltar aos modelos. Depois, podemos pressionar Control+A para conectar uma integração. Vamos acessar o OpenCode Console e pressionar Enter. Vamos clicar em Add Account. Vou acessar a conta do OpenCode Console. Ele vai pedir que você entre com sua conta do Google ou com seu e-mail e senha, o que estou fazendo fora da tela neste momento.

04:17 Agora autorizei esta conexão. E pronto. Vamos tentar de novo. Ótimo, agora está tudo funcionando. Certo, foi muito, muito rápido. Quero voltar ao app para desktop e, daqui, ir para a página inicial. Olha só: agora também podemos ver no app para desktop a sessão que iniciamos no terminal. Vamos clicar nela. E este é mesmo o app que acabamos de criar. Claro que também podemos selecionar o modelo aqui, como o Beam. Vamos pedir a ele: por favor, inicie

04:50 um servidor de desenvolvimento. Passe-me a URL. Quero mencionar que esses modelos gratuitos no OpenCode podem ser ideais se você está começando a programar com agents ou se é estudante. Mas, para trabalho profissional, é preciso ter cuidado. Você pode usar esses modelos de graça, mas, em troca, o OpenCode talvez também treine com seus prompts. Então, se isso for uma preocupação, é melhor entrar com sua conta do OpenCode, fornecer sua chave de API do Claude, usar um desses serviços pagos ou talvez até executar um modelo local na sua máquina.

05:22 O OpenCode também permite executar os agents e as tarefas em segundo plano. No momento, esta tarefa de iniciar um servidor de desenvolvimento está bloqueando a conversa inteira. Então, não consigo mais interagir com o agent. O que podemos fazer é pressionar Control+B ou clicar neste pequeno botão aqui. Isso enviará a tarefa inteira para segundo plano, permitindo que continuemos interagindo com nosso agent. Vou clicar nesta URL. Pronto, agora podemos acessar nosso app nesse servidor de desenvolvimento. E, já que estamos falando de executar tarefas em segundo plano, também podemos pedir ao nosso agent para

05:54 executar outros agents ou subagents em segundo plano. Basta pedir isso ao agent, assim. Podemos pedir que ele inicie um agent de revisão em segundo plano. Em vez de usar o Beam, vamos ver quais outros modelos estão disponíveis. Vamos executar o Big Pickle como agent em segundo plano. Use o Big Pickle para o agent de revisão em segundo plano. Entendi. Nosso agent diz que iniciou um agent de revisão em segundo plano usando o Big Pickle para revisar o código do app de divisão de contas.

06:25 Vou compartilhar as descobertas quando ele terminar. Vamos clicar aqui. Depois, podemos clicar neste agent de revisão. Podemos ver as instruções que o agent principal deu ao subagent. Mas, se eu mover a câmera por um instante, podemos abrir a barra lateral e ver mais detalhes sobre esse subagent. E aqui vemos que o modelo é mesmo o Big Pickle. Gosto da ideia de combinar diferentes modelos para diferentes tarefas. E sim, o Big Pickle também é gratuito. A propósito, se você estava curioso para saber o que estava acontecendo no terminal, se eu simplesmente

06:59 fechar isto, veremos no terminal exatamente a mesma sessão. E, se eu abrir o app no celular, acontece a mesma coisa. Posso iniciar uma sessão no PC, sair e continuar trabalhando pelo celular. E, a propósito, se você nunca experimentou o Big Pickle, ele é um modelo de programação razoável. Infelizmente, não dá para enviar mensagens diretamente aos subagents, mas acho muito legal que todas essas informações estejam disponíveis desde o início. Para voltar ao agent principal, basta clicar nesta opção aqui. Se quiser ver o que os subagents estão fazendo na visualização do terminal, basta

07:32 Tudo o que precisamos fazer é pressionar a seta para baixo. E então podemos ver nosso agent de revisão aqui. Vou pressionar Enter para ir até esse agent. Agora podemos ver a saída desse subagent. Também não podemos enviar mensagens aos subagents pelo terminal. Então vou pressionar a seta para cima para voltar ao agent principal. Nosso subagent concluiu a revisão, e o agent principal aplicou as correções. Outro recurso muito legal do OpenCode 2.0 é o modo de código. Agora, deixa eu explicar primeiro o que é isso. Normalmente, os agents de programação chamam as ferramentas uma de cada vez.

08:05 Eles chamam uma ferramenta, recebem uma resposta e depois usam essa resposta para chamar a próxima ferramenta. Isso pode acabar adicionando bastante volume à context window. Em vez de chamar uma ferramenta de cada vez, o modo de código permite que seu agent escreva o script que executa todas essas ferramentas de uma vez. O modo de código vem ativado por padrão no OpenCode, mas também podemos forçar o agent a usá-lo simplesmente dando a ele um prompt. Podemos dizer algo como: “Use o modo de código para fazer o seguinte. Recupere a documentação do MCP do Playwright neste URL.”

08:36 É claro que o seu pedido pode ser qualquer coisa. Pode ser qualquer combinação de chamadas de ferramentas. Depois, vou dizer: “Por favor, instale o MCP localmente.” Aí vou dizer: “Agora use o MCP para abrir nosso app.” Vamos manter tudo bem simples. Dá para saber que o modo de código foi usado quando você expande esta linha do tempo de ferramentas. E ela geralmente se parece com isto. Você verá etapas de execução desse tipo, que chamam algo como tools dot OpenCode dot whatever. Assim, você sabe que o script foi realmente usado para executar tudo isso.

09:07 E toda essa sessão — desde pesquisar na web até instalar a ferramenta e abrir o navegador — levou uns 27 segundos. E, a propósito, gosto do fato de termos um navegador integrado neste app para desktop, é muito prático. Certo, vamos dar uma olhada no próximo recurso. Agora também podemos fazer nossos agents trabalharem em worktrees. Isso significa que, em vez de nosso agent de programação alterar a branch principal toda vez, ele fará uma cópia do nosso código, onde poderá fazer as alterações com segurança e testá-las. E, quando estivermos satisfeitos com as alterações, poderemos mesclá-las de volta na

09:39 branch principal. Olhando para nosso app, talvez queiramos adicionar os modos claro e escuro. Então, o que vou pedir ao nosso agent é: “Por favor, use a worktree para adicionar suporte aos modos claro e escuro.” Certo, que legal! Podemos ver esta linha aqui, que diz que o código foi movido para C drive, OpenCode, bill splitter theme. Então, esta é uma cópia física da nossa base de código na máquina, a propósito. Também posso mostrar isso. Se eu voltar à pasta inicial e acessar OpenCode,

10:10 agora temos esta segunda pasta com esta versão do código. Então, todas as alterações relacionadas aos modos claro e escuro serão adicionadas a esta pasta e, quando estivermos satisfeitos, vamos mesclá-las de volta na pasta principal. E basicamente podemos excluir esta cópia. E, como o Beam é absurdamente rápido, ele concluiu essa alteração em uns 44 segundos. Temos os modos claro e escuro, que realmente funcionam. Quando terminarmos, podemos simplesmente dizer: “Por favor, prossiga e mova todas as alterações para a branch principal e remova a worktree.” E, pronto, essas alterações foram mescladas de volta na branch principal.

10:43 O OpenCode 2.0 também oferece suporte a plugins, e podemos até pedir aos nossos agents que criem os próprios plugins. Podemos fazer algo assim: “Escreva um plugin que impeça você de ler arquivos .env.” Se você não conhece os arquivos .env, eles são usados para armazenar segredos, como chaves de API. E, normalmente, não queremos que nossos agents leiam essas informações. Então, vamos enviar essa instrução. Ótimo, o agent acabou de criar o plugin. Assim, quando criarmos uma nova sessão,

11:14 o plugin será aplicado automaticamente. Se quiser ver todos os plugins disponíveis, você pode fazer isso pelo prompt de comando, executando OpenCode plugin list. No momento, temos apenas este plugin configurado. E, como você pode ver, esses plugins são arquivos TypeScript bem simples. Certo, só para este tutorial, vou adicionar este arquivo .env. Vamos colocar algo como: “My secret. Key equals Nothing to see”

11:46 “here.” Então, nosso agent não deveria conseguir acessar esse arquivo de jeito nenhum. Vou abrir uma nova sessão. Depois, vou selecionar meu projeto bill splitter. “Por favor, diga quais são as variáveis e os valores disponíveis no arquivo .env.” E veja só: agora o agent precisa da nossa permissão para ler esse arquivo, então posso simplesmente negar. E é isso. Isso vai encerrar esta sessão, e nosso agent não tem como ver o que há nesse arquivo, a menos que a gente dê permissão.

12:18 E, por fim, também é possível executar modelos locais. Deixe-me mostrar como fazer isso. Uma das maneiras mais fáceis de executar modelos locais na sua máquina é usar algo como o Ollama. Basta acessar Ollama dot com e clicar em “Get started”. Prefiro ir para “Download manually”. Depois, basta executar o arquivo baixado para instalar o Ollama. Em seguida, você precisa escolher um modelo. Isso vai depender do hardware que você tem. Pessoalmente, gosto de executar o Qwen 3.8. É um modelo muito bom, especialmente para tarefas de programação.

12:50 Você precisará de cerca de 16 GB de VRAM para executar esse modelo. Também há modelos menores. Uma dica que posso dar é pedir ao seu agent de programação, ao Claude Code ou à ferramenta que você estiver usando para analisar seu hardware e recomendar um modelo do Ollama que você consiga executar de forma realista. Depois, vou simplesmente copiar o nome do modelo. De volta ao terminal, podemos executar Ollama pull. E vamos inserir o nome do modelo. Pronto, agora podemos executar esse modelo na nossa própria máquina. Depois, de volta ao OpenCode, selecione um dos modelos gratuitos, como o Big Pickle, por exemplo,

13:23 ou o Beam; qualquer um dos modelos gratuitos serve. Depois, basta executar um prompt como: “Gostaria de usar os modelos do Ollama na minha máquina no OpenCode.” Acho que esta etapa talvez seja opcional. Antes, tive problemas em que o OpenCode não detectava automaticamente os modelos na minha máquina. Então, isso ajuda um pouco na configuração. Ou seja, se o Ollama já estiver em execução e o OpenCode detectar os modelos automaticamente, tudo certo. Certo, vou testar. Vou acessar Model.

13:54 Vamos para “Manage models”. Vou procurar Ollama nesta lista. Isso, temos o Ollama. Vou ativar o Ollama. E vou desativar os modelos que não quero. Vou me certificar de que o Qwen 3.8 esteja ativado. Beleza, vamos fechar isto. Vou testá-lo. No seletor de modelos, vou pesquisar Qwen 3.8. Vamos dizer “Oi”. Isso pode deixar minha webcam mais lenta enquanto carrega o modelo inteiro

14:26 na memória. E pronto. Agora estou executando um modelo local na minha máquina, no OpenCode. A vantagem de executar esse modelo localmente é que ele é seguro e funciona offline. Posso até me desconectar totalmente da rede, e tudo continuará funcionando. Conte nos comentários o que você acha do OpenCode 2.0. Se gostou deste vídeo, clique no botão de curtir e inscreva-se no meu canal para ver mais tutoriais de programação com agents. Obrigado por assistir. Vejo você no próximo. Tchauzinho.

Transcrição original

[00:00] OpenCode 2.0 is out, and this is the biggest update this open source coding agent has ever had. Your terminal, the desktop app, and even your phone all share the same session. Agents can now run in the background while you keep working. It can write its own plugins while you watch. And it comes with free models built in, so you can build your apps or follow along with this video without paying a cent. In this video, we’ll build a simple app, but we’ll have a look at all of the new features in OpenCode 2.0 along the way. First things first, if you already use OpenCode, upgrading is really simple.

[00:34] Within OpenCode, all you have to do is run the command slash update. In fact, we get a little tip over here. So I would be just running the command. Update like so. Then I’ll click on upgrade. Then we just have to restart OpenCode. And now I am running OpenCode 2.0, which you can see down here. If this is your first time using OpenCode, I’ll link to this website in the description of the video. Installation is really simple. If you’re using Linux or Mac, what you can do is copy the curl command.

[01:05] Or if you are on Windows, go to NPM, copy this command. And simply run that command in your command prompt or PowerShell. And this will install OpenCode. It’s also worth mentioning that OpenCode also has a desktop app. Again, from their website, go to download. But when we scroll down, we can go to OpenCode desktop app. And they’ve got an app for Mac, Windows and Linux. So I’m going to download the app for Windows. You can simply run the file that you just downloaded. And it’s really that simple. And now we’ve got access to the desktop app as well.

[01:38] Now you can follow along with either the desktop app or the terminal. I’ll use the terminal, but don’t worry, all the features work in both. By the way, I’ve got a free course that teaches you how to use coding agents effectively. This has been for vibe coders and experienced developers alike. This teaches you the framework I use to build any project using free models all the way to frontier models. Again, it’s completely free, and I’ll leave a link in the description. So what I recommend you do is create a new folder for your project. So I’ll just create this bill splitter folder on my machine.

[02:09] Then I’ll open command prompt in that folder. And I’ll just run OpenCode. This will simply ensure that all the files that the agent creates for this project will simply be stored in this folder. If you run this in the root of your machine, who knows where it’s going to end up adding all of those files. If you are using the desktop app, the process is very similar. Simply click on this drop down down here, go to add project. Then select that folder on your machine. And that’s really it. One of the new features in OpenCode is that your sessions are shared between the

[02:41] desktop app, the terminal and the mobile app as well. So let me show you what that actually looks like. I’m going to start the session in the terminal and then I’m going to switch back over to the desktop app to show you that same session is available there as well. But first, let’s select our agent. OpenCode supports pretty much any provider out there, so you’re not limited to a single model or provider. It also supports local models too. If we run the command slash models. We can select from a wide range of different models.

[03:14] We’ve got models from providers like OpenAI, Google, Anthropic, you name it. And if you do have local models using Ollama or LM Studio, you can select those from here as well. For this tutorial, let’s actually select one of the free models. I’m actually going to go with Beam. And I’ve actually never used this model before in my life, but we’ll see how good it is in a second. Please. Build a simple. Bill-splitting app that runs in the browser. Cool, they’ve seen this.

[03:46] But I’m getting this message saying that this API key has expired, create a new API key in OpenCode console. and replace it with your client and secret store. To fix that issue, I’ll go back to the models. And then we can press control and A. To connect and integration. Then let’s go to OpenCode Console and press enter. Let’s click on add account. I’ll go to OpenCode console account. So this will ask you just to sign in with your Google account or your email and password, which I’m doing off screen at the moment.

[04:17] Now I’ve authorized this connection. And that’s it. So let’s try again. And cool, now everything is working. Alright, that was really, really quick. What I want to do is actually go back to the desktop app and from here let’s go to home. And look at that. Now we can see that session that we started in the terminal in the desktop app as well. So let’s click on this And this is indeed the app that we just created. And of course we can select the model here as well, like beam. Let’s just ask it. Please can you start.

[04:50] a dev server. Give me the URL. Now I do want to mention that these free models in OpenCode can be ideal if you’re starting out with agentic coding or if you’re a student. But for professional work, you have to be careful. You get to use these models for free, but in exchange, OpenCode might be training on your prompts as well So if you are worried about that, rather sign in with your OpenCode account or provide your Claude API key or use one of those paid services. Or maybe even run a local model on your machine.

[05:22] OpenCode does allow you to run its agents and tasks in the background, too. So at the moment this task to start a dev server is holding up the entire thread. So I can’t actually interact with the agent anymore. What we can do is press control B or just click on this little button over here and that will move that entire task to the background, which means we can continue interacting with our agent. I’ll just click on this URL. And there we go, we can now access our app on that dev server. And speaking of running tasks in the background, we can also get our agent to

[05:54] run other agents or sub-agents in the background too. Now we can simply do that by prompting the agent like this. So we can just ask it to spawn a background review agent. So maybe instead of using Beam. Let’s see what other models we have available. Let’s actually run Big Pickle as a background agent. Use Big Pickle for the background review agent. I’ve seen this. And our agent is saying it launched a background review agent using Big Pickle to review the bill splitter code.

[06:25] I’ll share its findings when it completes. Let’s just click on this. Then we can click on this review agent over here. We can see the instructions that the main agent gave to the sub-agent. But if I just move my camera for a second, we can open up the sidebar and here we can see more details about this sub-agent. And here we can see that the model is indeed Big Pickle. So I do like the idea of combining different models for different tasks. And yes, Big Pickle is also free. And by the way, if you were curious what was happening in the terminal, if I just

[06:59] close this. In the terminal we can see that very same session. And if I open the app on the phone, it’s the exact same story. I can start a session on my PC, walk away and continue working using my phone. And by the way, if you’ve never tried Big Pickle, it’s actually not a bad coding model. Now, unfortunately, you can’t send messages directly to sub-agents, but I do think it’s really cool that you get all of this information out of the box. To go back to the main agent, we can simply click on this option over here. If you wanted to see what sub-agents are up to in the terminal view, really all you

[07:32] have to do is press the down arrow. And then we can see our review agent over here. I’ll press enter to go to that agent. And now we can see the output of that sub-agent. We cannot send messages to sub-agents in the terminal either. Then I’ll just press the up arrow to go back to the main agent. Our sub-agent completed the review and our main agent applied the fixes. Another really cool feature in OpenCode 2.0 is code mode. Now, let me first explain what this is. Normally, coding agents would call tools one at a time.

[08:05] So they would call a tool, get a response, and then use that response to call the next tool. Now this can actually add a lot of bloat to the context window. Instead of calling one tool at a time, code mode allows your agent to write the script that runs all of these tools at once. Now code mode is enabled by default in OpenCode, but we can also force the agent to use it just by giving it a prompt. So we can say something like Use code mode to do the following. Retrieve the docs for the Playwright MCP from this URL.

[08:36] Now, of course, yours could be anything. It can be any combination of tool calls. Then I’ll say please. Install the MCP locally. I’ll just say then use the MCP to open our app. We’ll keep it super simple. You know that code mode was used when you expand this sort of tool timeline. And it usually looks something like this. You’ll see these sort of execute steps. That call something like tools dot OpenCode dot whatever. So that way you know that the script was actually used to execute all of this.

[09:07] And this entire session from researching the web, installing the tool and opening the browser, and it took like 27 seconds. And by the way, I do like the fact that we actually have an integrated browser within this desktop app, so it’s just super convenient Alright, let’s have a look at the next feature. We can now also get our agents to make changes in worktrees. This means that instead of our coding agent changing the main branch every time, it will make a copy of our code where it can safely make the changes and we can test it there. And once we’re happy with the changes, we can merge them back into

[09:39] the main branch. So, looking at our app, we might want to add light and dark mode. So what I’m going to ask our agent is. Please use the worktree to add support for light and dark modes. All right, how cool is that? So we can see this line over here that says that the code Was moved to. My C drive, OpenCode, bill splitter theme. So this is a physical copy of our code base on our machine, by the way. I can show you that as well. So if I go back to that initial folder, if I go to OpenCode.

[10:10] We now have this second folder for this version of the code. So all of the changes related to light and dark mode will be added to this folder, and once we’re happy, we’ll merge back into the main folder. And we can basically delete this copy. And because Beam is so stupidly fast, it actually completed this change in like 44 seconds. We have light and dark mode, which actually does work. So once we’re done we can just say. Please go ahead and move all the changes into the main branch and you can remove the worktree. And just like that, these changes were merged back into the main

[10:43] branch. OpenCode 2.0 also supports plugins and we can actually ask our agents to build their very own plugins. So we can do something like this. Write a plug-in that stops you from ever reading .env files. If you’re unfamiliar with .env files, these are the files you use to store your secrets like API keys. And typically you don’t want your agents to read that information. So let’s actually send this instruction. Awesome, the agent just created the plugin, so when we create a new session,

[11:14] the plugin will automatically be applied. Now if you do want to see all the plugins that are available, you can basically do that from your command prompt by running OpenCode plugin list And at the moment we only have this one plug-in set up. And as you can see, these plugins are very simple TypeScript files. Right, so just for the sake of this tutorial, I’m going to add this .env file. Let’s just add something like. My secret. Key equals Nothing to see

[11:46] here. So our agent should not be able to look at this file at all. I’m going to open up a new session. Then I’ll select my bill splitter project. Please tell me what the available. Vars and values in .env are. And look at that, now the agent needs our permission to read that file, so I can just go ahead and deny it. And that’s it. That will stop this session, and our agent has no way of seeing what’s available in that file unless we give it permission to do so.

[12:18] And finally, you can run local models as well. Let me show you how to do that. One of the easiest ways to run local models on your machine is to use something like Ollama. So you can simply go to Ollama dot com, click on get started. I prefer to go to download manually. Then simply run the file that you downloaded to install Ollama. Then you do have to select a model. Now this is going to depend on the hardware that you have. But personally, I like to run Qwen 3.8. This is a really good model, especially for coding tasks.

[12:50] You will need about 16 GB of VRAM to run this model. There are smaller models as well. One piece of advice I will give you is ask your coding agent or Claude Code or whatever you’re using to look at your hardware and recommend the model on Ollama that you could realistically run. Then I’m simply going to copy the model name. Back in the terminal, we can run Ollama pull. And we will place in the name of the model. And that’s it, we can now run this model on our own machine. Then back in OpenCode select one of the free models, so Big Pickle as an example

[13:23] or a beam, any of the free models will do. Then just simply run a prompt like I would like to use the Ollama models on my machine in OpenCode. Now I think this step might be optional. I’ve had issues before where OpenCode did not discover the models automatically on my machine. So this just kind of helps you with that setup. This is to say that Ollama is already running and OpenCode discovers its models automatically. Right, so if you get that message, that’s perfectly fine. I’m just going to try this out, so I’ll go to model.

[13:54] Let’s go to manage models. I’m just going to look for. Ollama in this list. So yeah, we’ve got Ollama. I’m just going to enable Ollama. And I’m going to just kind of disable any models I don’t want. I’ll just ensure that Qwen 3.8 is enabled. Cool, let’s close this. I’m going to test it. From the model picker. I’m going to search for Qwen 3.8. Let’s say, hi. This might actually slow down my webcam as it loads the entire

[14:26] model into memory. And cool, that’s it. Now I’m actually running a local model on my machine in OpenCode. And the benefit of running this model locally is it is secure, it’s offline. I can actually disconnect from the network entirely and everything will continue working. Let me know in the comments what you think about OpenCode 2.0. If you enjoyed this video, hit the like button and subscribe to my channel for more agentic coding tutorials. Thank you for watching. I’ll see you in the next one. Bye-bye.