For nearly two decades we thought about Visual Studio Code in the same way.
It was an editor.
Excellent, extensible and fast, but still just an editor.
Then came GitHub Copilot, AI extensions and the first agents. It seemed like a natural evolution: an editor with integrated artificial intelligence.
But the latest updates to VS Code show something different.
It’s no longer just about writing code with the help of a model.
Microsoft is building an environment where agents can discover models, execute tools, maintain parallel sessions, manage context, control costs and automate complete development workflows.
In other words, VS Code is starting to look more like a runtime for agents than a text editor.
What changed?
The latest versions include several important capabilities:
-
discovery of model providers directly from the Marketplace;
-
context windows of up to 1 million tokens;
-
official Ollama provider;
-
parallel agent sessions;
-
cost visibility per conversation;
-
automatic Pull Request creation from an agent session.
Each one seems like an incremental improvement.
But together they tell a different story.
The model is no longer embedded in the IDE
For years we chose an editor and, with it, inherited the available tools.
Today the opposite is happening.
VS Code is starting to behave like a platform where the model is simply another interchangeable component.
From the Marketplace it’s possible to discover new providers and connect them to the developer’s workflow.
That means a team can work with:
-
Claude;
-
GPT;
-
Gemini;
-
Ollama;
-
open weight models;
-
internal providers.
All from the same experience.
The IDE no longer defines the model.
The developer decides which one to use.
Ollama is no longer a “community” integration
Another important detail is the incorporation of an official provider for Ollama.
Until recently, running local models meant installing third-party extensions or configuring endpoints manually.
Now it becomes part of the standard workflow.
This reduces friction for teams that want to:
-
keep code within their infrastructure;
-
experiment with open weight models;
-
work without permanent dependence on the cloud;
-
better control costs and privacy.
Local execution is no longer a special case.
It’s starting to become a first-class option.
A million tokens changes the types of problems we can solve
Large context windows are often presented as a numbers race.
But their real impact isn’t in the marketing.
It’s in the type of work an agent can perform.
With a million tokens it’s possible to analyze:
-
entire repositories;
-
extensive documentation;
-
multiple microservices;
-
technical specifications;
-
conversation histories.
Instead of fragmenting work into dozens of prompts, the agent can reason about a much wider part of the system.
Parallel sessions change how we work
One of the biggest bottlenecks with early agents was sequentiality.
While one agent analyzed a problem, the rest of the work had to wait.
Parallel sessions are starting to break that limitation.
For example:
-
one session reviews architecture;
-
another implements a feature;
-
a third generates documentation;
-
another runs tests.
The developer stops talking to a single assistant.
They start coordinating multiple workflows simultaneously.
Cost is no longer invisible
One of the least flashy updates may end up being one of the most important.
VS Code now shows the cost associated with conversations.
Why does it matter?
Because many organizations are no longer managing a few prompts a day.
They’re managing thousands of interactions between developers and agents.
When token consumption becomes part of the engineering budget, it stops being a technical detail and becomes an operational metric.
Seeing the cost in the IDE itself helps each team understand the impact of their decisions.
From chat to Pull Request
Another interesting change is the ability to automatically create a Pull Request from an agent session.
It seems like a simple automation.
But it represents a change in the development workflow.
Before the agent finished when it generated the code.
Now it can complete a significant part of the process:
-
implement changes;
-
run checks;
-
prepare the commit;
-
generate the Pull Request.
The agent stops just producing code.
It starts producing work ready for review.
All the pieces start connecting
If we look at the updates from recent months, a very clear pattern emerges.
VS Code now integrates:
-
interchangeable models;
-
terminal;
-
Git;
-
Browser Tools;
-
MCP Servers;
-
parallel sessions;
-
massive context;
-
cost control;
-
Pull Request automation.
These aren’t isolated features.
They’re components of the same platform.
Each release adds a new capability to the environment where agents live.
What is really a runtime for agents?
In software development we talk about runtime as the environment where a program can execute and access the resources it needs.
If we apply that idea to agents, the concept changes very little.
A runtime for agents provides:
-
access to the file system;
-
terminal;
-
browser;
-
external tools;
-
models;
-
memory;
-
context;
-
security policies;
-
observability.
The model is just one piece.
The real value is in everything around it.
And that’s precisely what Microsoft seems to be building.
Competition is no longer between models
For a long time the conversation revolved around a single question:
Which model is better?
Today the question is starting to be different.
Which platform allows agents to work better?
Because an excellent model with few tools can end up being less useful than a slightly inferior model integrated into an environment capable of navigating applications, executing commands, using MCP Servers, creating Pull Requests and working with multiple simultaneous sessions.
The difference is no longer just in intelligence.
It’s in the capabilities.
The editor is no longer the center
Perhaps that’s the most important transformation.
VS Code is no longer evolving only to help write code.
It’s evolving to coordinate agents.
The editor is still there.
But gradually it stops being the protagonist.
It becomes the interface from which we observe, direct and oversee a set of agents capable of using tools, models and context to complete increasingly complex tasks.
And if that trend continues, in a few years we’ll probably stop talking about the “editor” we use.
We’ll start talking about the agent runtime on which we build our daily work.