Durante quase duas décadas pensamos no Visual Studio Code da mesma forma.
Era um editor.
Excelente, extensível e rápido, mas continuava sendo um editor.
Depois chegaram GitHub Copilot, as extensões de IA e os primeiros agentes. Parecia uma evolução natural: um editor com inteligência artificial integrada.
Mas as atualizações mais recentes do VS Code mostram algo diferente.
Não se trata mais apenas de escrever código com a ajuda de um modelo.
A Microsoft está construindo um ambiente onde os agentes podem descobrir modelos, executar ferramentas, manter sessões paralelas, gerenciar contexto, controlar custos e automatizar fluxos completos de desenvolvimento.
Em outras palavras, VS Code começa a parecer mais um runtime para agentes do que um editor de texto.
O que mudou?
As versões recentes incorporam várias capacidades importantes:
-
descoberta de provedores de modelos diretamente do Marketplace;
-
janelas de contexto de até 1 milhão de tokens;
-
provedor oficial do Ollama;
-
sessões paralelas de agentes;
-
visibilidade do custo por conversa;
-
criação automática de Pull Requests a partir de uma sessão de agente.
Cada uma parece uma melhoria incremental.
Mas juntas contam outra história.
O modelo deixa de estar integrado na IDE
Durante anos escolhíamos um editor e, com ele, herdávamos as ferramentas disponíveis.
Hoje acontece o contrário.
VS Code começa a se comportar como uma plataforma onde o modelo é simplesmente outro componente intercambiável.
Do Marketplace é possível descobrir novos provedores e conectá-los ao fluxo de trabalho do desenvolvedor.
Isso significa que uma equipe pode trabalhar com:
-
Claude;
-
GPT;
-
Gemini;
-
Ollama;
-
modelos open weights;
-
provedores internos.
Tudo a partir da mesma experiência.
A IDE deixa de definir o modelo.
O desenvolvedor decide qual usar.
Ollama deixa de ser uma integração “da comunidade”
Outro detalhe importante é a incorporação de um provedor oficial para o Ollama.
Até pouco tempo atrás, executar modelos locais implicava instalar extensões de terceiros ou configurar endpoints manualmente.
Agora passa a fazer parte do fluxo padrão.
Isso reduz o atrito para equipes que desejam:
-
manter o código dentro de sua infraestrutura;
-
experimentar com modelos open weights;
-
trabalhar sem depender permanentemente da nuvem;
-
controlar melhor custos e privacidade.
A execução local deixa de ser um caso especial.
Começa a se tornar uma opção de primeira classe.
Um milhão de tokens muda o tipo de problemas que podemos resolver
Janelas de contexto de grande tamanho costumam ser apresentadas como uma corrida de números.
Mas seu impacto real não está no marketing.
Está no tipo de trabalho que um agente pode realizar.
Com um milhão de tokens é possível analisar:
-
repositórios completos;
-
documentação extensa;
-
múltiplos microsserviços;
-
especificações técnicas;
-
históricos de conversas.
Em vez de fragmentar o trabalho em dezenas de prompts, o agente pode raciocinar sobre uma parte muito mais ampla do sistema.
As sessões paralelas mudam a forma de trabalhar
Um dos maiores gargalos dos primeiros agentes era a sequencialidade.
Enquanto um agente analisava um problema, o resto do trabalho tinha que esperar.
As sessões paralelas começam a romper essa limitação.
Por exemplo:
-
uma sessão revisa a arquitetura;
-
outra implementa uma feature;
-
uma terceira gera documentação;
-
outra executa testes.
O desenvolvedor deixa de conversar com um único assistente.
Começa a coordenar vários fluxos de trabalho simultaneamente.
O custo deixa de ser invisível
Uma das novidades menos chamativas pode acabar sendo uma das mais importantes.
VS Code agora mostra o custo associado às conversas.
Por que isso importa?
Porque muitas organizações não gerenciam mais apenas alguns prompts por dia.
Gerenciam milhares de interações entre desenvolvedores e agentes.
Quando o consumo de tokens passa a fazer parte do orçamento de engenharia, deixa de ser um detalhe técnico e se torna uma métrica operativa.
Ver o custo na própria IDE ajuda cada equipe a entender o impacto de suas decisões.
Do chat para o Pull Request
Outra mudança interessante é a possibilidade de criar automaticamente um Pull Request a partir de uma sessão de agente.
Parece uma simples automatização.
Mas representa uma mudança no fluxo de desenvolvimento.
Antes o agente terminava quando gerava o código.
Agora pode completar uma parte significativa do processo:
-
implementar mudanças;
-
executar verificações;
-
preparar o commit;
-
gerar o Pull Request.
O agente deixa de produzir apenas código.
Começa a produzir trabalho pronto para revisão.
Todas as peças começam a se conectar
Se observarmos as novidades dos últimos meses, aparece um padrão muito claro.
VS Code já integra:
-
modelos intercambiáveis;
-
terminal;
-
Git;
-
Browser Tools;
-
MCP Servers;
-
sessões paralelas;
-
contexto massivo;
-
controle de custos;
-
automatização de Pull Requests.
Não são funções isoladas.
São componentes da mesma plataforma.
Cada lançamento adiciona uma nova capacidade ao ambiente onde vivem os agentes.
O que é realmente um runtime para agentes?
Em desenvolvimento de software falamos de runtime como o ambiente onde um programa pode ser executado e acessar os recursos de que necessita.
Se trasladarmos essa ideia para os agentes, o conceito muda muito pouco.
Um runtime para agentes fornece:
-
acesso ao sistema de arquivos;
-
terminal;
-
navegador;
-
ferramentas externas;
-
modelos;
-
memória;
-
contexto;
-
políticas de segurança;
-
observabilidade.
O modelo é apenas uma peça.
O verdadeiro valor está em tudo que o rodeia.
E isso é precisamente o que a Microsoft parece estar construindo.
A competição não é mais entre modelos
Durante muito tempo a conversa girou em torno de uma única pergunta:
Qual modelo é melhor?
Hoje a pergunta começa a ser outra.
Qual plataforma permite que os agentes trabalhem melhor?
Porque um modelo excelente com poucas ferramentas pode se revelar menos útil que um modelo ligeiramente inferior integrado em um ambiente capaz de navegar aplicações, executar comandos, usar MCP Servers, criar Pull Requests e trabalhar com múltiplas sessões simultâneas.
A diferença já não está apenas na inteligência.
Está nas capacidades.
O editor deixa de ser o centro
Talvez essa seja a transformação mais importante.
VS Code já não evolui apenas para ajudar a escrever código.
Evolui para coordenar agentes.
O editor continua lá.
Mas aos poucos deixa de ser o protagonista.
Se torna a interface a partir da qual observamos, dirigimos e supervisionamos um conjunto de agentes capazes de usar ferramentas, modelos e contexto para completar tarefas cada vez mais complexas.
E se essa tendência continuar, em alguns anos provavelmente deixaremos de falar do “editor” que usamos.
Começaremos a falar do runtime de agentes sobre o qual construímos nosso trabalho diário.