AI agents in VS Code: from smart chat to full tool-powered workflows

Home » Python » AI agents in VS Code: from smart chat to full tool-powered workflows

AI-powered coding inside Visual Studio Code has gone way beyond simple autocomplete, and modern AI agents can now read your workspace, run tools, refactor entire features and even help you design and deploy complete applications directly from the editor. If you have experience with JavaScript and React and you have been using VS Code for years, the landscape of AI extensions and agent workflows in the editor may feel radically different from what you remember from the early days of GitHub Copilot.

Instead of thinking only in terms of “code suggestions”, the new wave of AI in VS Code revolves around agents, tooling, and integrated model workflows that cover the whole lifecycle of an AI-enhanced application: discovering and testing models, building agents with tools, evaluating quality, optimizing performance and finally deploying everything to local or cloud environments. In this guide we will walk through what AI agents in VS Code can do today, how Microsoft’s AI Toolkit and Azure AI Foundry extensions structure this experience, and how this compares to more traditional assistants like GitHub Copilot so you can pick the best setup for your personal projects.

What AI agents in VS Code actually are today

When people talk about “AI agents in VS Code” nowadays, they are referring to much more than chat bubbles in the sidebar. Modern agents follow a full agent loop: they can read and analyze your files, decide which parts of the codebase to touch, run commands, orchestrate tools and iterate on their own plan until they reach a reasonable solution. These capabilities resemble the idea of multi-agent control in modern IDEs, where coordinated agents take on larger tasks.

VS Code’s built‑in AI features sit on a spectrum of interaction modes that share the same large language models under the hood (like GitHub Copilot-hosted models and other LLMs), but feel very different in day‑to‑day work: some are ultra‑lightweight and barely interrupt your flow, while others behave like autonomous collaborators that take over big refactors or architecture changes.

The first layer is inline suggestions: those ghost‑text completions that appear as you type. These are powered by specialized completion models and don’t involve a full agent loop or tools; they just try to predict your next edit, including “next edit suggestions” that can hint where the following change should happen. They’re perfect when you simply want faster typing, not a full AI conversation.

On top of that you get inline chat, a small chat interface directly in the editor that lets you request focused changes around a specific selection or file. Instead of switching to a side panel, you can type instructions where you are: things like “extract this into a reusable hook” or “convert this React class component to a function with hooks.”

The heavier end of the spectrum is where agents and chat sessions live. Here you interact in a dedicated chat view where agents can reason about multiple files, maintain context over time and call tools. This is where the new agent types (Agent, Plan, Ask, and your own custom agents) start to feel like an actual teammate embedded inside VS Code rather than just a glorified autocomplete.

AI Toolkit for VS Code: the hub for models, agents and workflows

AI Toolkit for Visual Studio Code is Microsoft’s comprehensive extension aimed at developers and AI engineers who want to build, test and ship intelligent applications using generative models, all without leaving the editor. Think of it as your integrated development environment for AI itself: from early experimentation and prompt design to evaluation, optimization, and deployment.

This toolkit integrates tightly with many popular model providers, including OpenAI, Anthropic, Google and GitHub‑hosted models, while also supporting local models through ONNX and Ollama. That means you can mix and match cloud and local models, experiment with each, and decide which combination best fits your performance, privacy or cost constraints. If you are interested in how to alojar modelos de lenguaje localmente, the toolkit’s local model support is particularly relevant.

The extension organizes its capabilities into several major sections accessible from the AI Toolkit icon that appears in the VS Code Activity Bar once the extension is installed. The main entry points are My Resources, Model Tools, Agent and Workflow Tools, MCP Workflow and Help and Feedback, each acting like a dashboard for different parts of your AI development lifecycle.

My Resources is where you see everything you can already use in your current environment: deployed models, defined agents and MCP servers. For example, under Models you’ll find the deployments available for your AI applications, while Agents lists your active AI Toolkit agents and MCP Servers gathers the Model Context Protocol servers you are connected to.

Model Tools is the workspace where you actually construct and refine your AI foundation. Here you can browse the Model Catalog to discover models from GitHub, ONNX, Ollama, OpenAI, Anthropic, Google and other sources, compare options side by side and choose the most adequate model for each task. The Model Playground gives you an interactive chat environment to test prompts, tweak parameters, and explore multi‑modal features like image or file inputs.

The Conversion tool inside Model Tools focuses on turning existing models into efficient local deployments. If you work with machine learning models from places like Hugging Face, you can convert, quantize and optimize them so they run smoothly on Windows using CPU, GPU or NPU acceleration. Meanwhile, the Fine‑tuning tool lets you adapt a pre‑trained model to your specific domain using your own dataset, either locally with GPU or in the cloud through Azure Container Apps.

Agent and Workflow Tools: building, testing and evaluating AI agents

Once you have models ready, the Agent and Workflow Tools section is where the real “agent” magic happens. This area brings together everything you need to build, deploy and refine AI agents that can act on your behalf inside VS Code and beyond.

Agent Builder is the heart of the agent workflow. It streamlines prompt engineering and agent design so you can create sophisticated AI roles that rely on structured outputs and MCP tools. You can define system prompts, roles and behaviors, and then generate production‑ready code that plugs these agents into your applications. If you want a deep read on el diseño y construcción de equipos de agentes de IA, that resource complements the Agent Builder workflow.

Bulk Run tackles the less glamorous but absolutely critical part of AI workflows: testing at scale. Instead of manually prompting a model or agent over and over, you can run batch prompt tests across multiple models simultaneously. This is incredibly useful for comparing outputs, validating behavior across different scenarios, and making data‑driven decisions about which model or prompt configuration to adopt.

Evaluation is built into AI Toolkit so you don’t have to roll your own metrics every time. You can assess model and agent performance using datasets and a set of standard evaluators such as F1 score, relevance, similarity and coherence. If your use case has special needs—say domain‑specific correctness or tone—you can also define custom evaluation criteria to judge outputs against ground truth data.

Tracing gives you visibility into what your agents and models are actually doing. It collects trace data and lets you inspect calls, decisions and timings so you can diagnose odd behavior or performance bottlenecks. On Windows, Profiling (Windows ML) goes deeper and shows CPU, GPU and NPU resource usage for ONNX models on different execution providers, as well as Windows Machine Learning events, helping you squeeze maximum efficiency from your hardware. These capabilities align well with herramientas AI para depuración and performance analysis in development workflows.

Together, these tools turn VS Code into a practical lab for AI agent development: you can design your agent, equip it with tools, run it against realistic workloads, measure how it behaves, and iterate quickly—without constantly switching between cloud portals, scripts and third‑party dashboards.

MCP Workflow: connecting external tools and servers

A key enabler of powerful AI agents in VS Code is their ability to call tools, including both tools provided by installed extensions and those exposed via MCP (Model Context Protocol) servers. The MCP Workflow section in AI Toolkit is dedicated to wiring up these servers and making them part of your agent’s toolbox.

The “Add MCP Server” entry lets you plug in existing MCP servers so your agents can query external APIs, interact with databases, or perform tasks that live outside your project’s codebase. This effectively extends what an agent can “do” far beyond reading text files and running simple commands.

If you want custom capabilities, the “Create new MCP Server” option guides you through setting up brand‑new servers that expose your own tools or services to the agent layer. This is handy, for example, when you want an agent that understands your company’s internal APIs, business logic or infrastructure commands but you don’t want to hard‑code all that into prompts. Enterprise scenarios increasingly adopt agentes de IA con roles to capture business rules and permissions.

Once MCP servers are wired into the toolkit, they become part of the toolset that agents can call automatically during their agent loop. From a user’s perspective, you just see the agent making smarter moves: it looks up information, manipulates resources and completes tasks that used to require several manual steps on your side.

Who benefits most from AI Toolkit and agent workflows

AI Toolkit and VS Code agents are not limited to hardcore ML practitioners; they’re designed to help a wide group of people working with generative AI, from everyday app developers to educators and students. The same set of tools can feel very different depending on how deep you want to go.

Traditional application developers stand to gain a lot. If you’re building web or desktop apps and want to add intelligent features such as chatbots, summarization, code generation or content filtering, these tools make it easier to integrate language models. Full‑stack developers can iterate quickly on both front‑end and back‑end logic while letting agents handle boilerplate, wiring and refactors.

Mobile developers can use the same environment to prototype AI features—for example, testing prompts for an in‑app assistant or a content recommendation engine—before committing to a specific on‑device or cloud deployment strategy. With local models via ONNX and Ollama, you can even validate privacy‑friendly setups without immediate cloud dependencies.

On the more data‑centric side, AI engineers and data scientists get tooling that fits their everyday workflows. They can fine‑tune models for specific domains, run evaluations across multiple candidates, and manage deployment targets directly from VS Code. ML engineers in particular benefit from the conversion and optimization features that help bring models closer to production on Windows environments.

Researchers, educators and students also have a clear path into hands‑on experimentation. AI researchers can explore different models and prompt engineering techniques in the playground, while educators can demonstrate capabilities live in the editor, including agent behavior, context usage and evaluation metrics. Students can learn generative AI by actually chatting with models, building simple agents and watching how different prompts and tools change the outcomes.

Key use cases for AI agents and models inside VS Code

Once all the pieces are in place, the practical use cases for AI Toolkit and VS Code agents cover almost the entire AI development lifecycle. You can start as small as interactive experimentation and end up deploying robust, well‑evaluated agents as part of real applications.

Model exploration and comparison is one of the first steps. With the Model Catalog, you can quickly browse models from Anthropic, OpenAI, GitHub and others, inspect capabilities, and then compare responses directly in the Playground or via Bulk Run. For development teams, being able to test the same prompts across multiple providers is invaluable for picking the right trade‑off between cost, latency and quality.

Running models locally via ONNX and Ollama is a big deal for privacy‑sensitive or budget‑constrained scenarios. You can keep data on your own machine while still enjoying generative features, which is particularly attractive for personal projects with confidential code or organizations that have strict compliance requirements.

Agent construction and testing is another core use case. With Agent Builder and the agent‑focused tools, you can design multi‑step assistants (for example, a code reviewer or a documentation generator), attach MCP tools, generate integration code and then use the Playground and evaluation tools to make sure your agent behaves consistently.

Finally, conversion and optimization workflows help you bridge the gap between experimentation and deployment. Converting models from repositories like Hugging Face, optimizing them for Windows hardware and fine‑tuning them with your own data means you can take local prototypes all the way to production environments without entirely recreating your setup elsewhere.

Installing and setting up AI Toolkit in VS Code

Getting started with AI Toolkit in Visual Studio Code is intentionally straightforward. The quickest route is to grab the extension from the Visual Studio Marketplace, install it and look for the new AI Toolkit icon in the Activity Bar to open its dedicated view.

If you prefer or need a manual route, you can also install the extension by following the standard “Install an extension” process documented for VS Code, then again confirm that the AI Toolkit icon appears on the Activity Bar. Once opened, you’ll see the main sections we covered—My Resources, Model Tools, Agent and Workflow Tools, MCP Workflow and Help and Feedback.

My Resources becomes your control center for Azure AI resources you can use from the editor: deployed models for your apps, existing agents you’ve configured, and MCP servers you’re currently working with. This is where you confirm what’s available before building new tools on top.

Under Model Tools you can immediately dive into browsing and testing models. The Model Catalog lets you discover various providers and compare them in one place, while the Playground gives you an interactive, multi‑modal environment where you can attach files, send image inputs and play with parameters such as temperature or max tokens.

The conversion and fine‑tuning options are accessible from the same section, letting you turn pre‑built ML models into local, optimized artifacts and train domain‑specific variants either on your machine or on Azure Container Apps with GPU acceleration. For many teams, this is the path from general‑purpose models to specialized “house models” optimized for their data.

Learning resources: guided walkthroughs and documentation

To avoid the typical “installed it, now what?” feeling, AI Toolkit ships with a getting started walkthrough that opens from the Help and Feedback section. This guided flow takes you through the Playground and basic chat interactions so you can experience the core capabilities without reading a full manual first.

You can launch the walkthrough by opening the AI Toolkit view from the Activity Bar, then looking under Help and Feedback for the Get Started entry. This opens a step‑by‑step experience that shows where to click, what to try, and how the main pieces fit together.

The same Help and Feedback area links out to detailed documentation and tutorials, including the Microsoft Foundry extension docs, a tutorials gallery, release notes under “What’s New” and the GitHub repository where you can report issues or follow development. If you’re the type who likes to understand underlying architecture, these resources go deep into how models, tools and agents interact.

For a more narrative, demo‑style overview, there are also recorded sessions where product managers walk through connecting models, evaluating performance, building intelligent agents and wiring MCP tools, all from the editor. These demos go further into Azure AI Foundry features, model deployment to Azure, visual agent design, Bing search integration, code interpreter tools and debugging of agent interactions.

VS Code’s built‑in agent types and local agent sessions

Beyond the AI Toolkit, Visual Studio Code itself now ships with built‑in agent concepts that live in the chat interface and operate as “local agents” on your machine. These agents run interactively inside VS Code, have access to your current workspace and can leverage tools from extensions and MCP servers, making them very context‑aware coding partners.

Local agents are especially suited to interactive tasks that need fast back‑and‑forth, such as brainstorming architectures, planning work, or iterating on partially defined requirements. Because they can see your files, read diagnostics and run tools, they’re also ideal for debugging, refactoring and documentation work.

Key characteristics of these local agents include full workspace access—they can read and modify files, consider your project context, and call any agent tools configured in VS Code, from built‑in capabilities to installed extensions and MCP endpoints. They can also use all models available to you, whether they’re default Copilot models or bring‑your‑own‑key (BYOK) models from other providers.

Even when you close a chat panel, the local agent session itself can remain active, and you can track and manage active sessions from a dedicated view. This persistence is handy when you’re working on long‑running tasks where the agent may need to revisit context from earlier in the day.

VS Code ships with three main built‑in agent personas optimized for different workflows—Agent, Plan and Ask—plus the ability to define your own custom agents for highly specialized tasks such as code review, testing automation or documentation generation.

Built‑in Agent, Plan and Ask modes explained

The general “Agent” persona is tuned for complex coding tasks based on high‑level requirements. Instead of micro‑editing lines of code, this agent can read large parts of your project, plan a set of changes, run terminal commands and tools, and iterate until the requested feature or refactor is complete.

In Agent mode, VS Code applies changes directly in the editor, and you get overlay controls that help you move between proposed edits and review them before accepting. Behind the scenes, the agent might call multiple tools—such as running tests, inspecting diagnostics or searching through your workspace—to get its job done. This ties directly into patterns for AI-powered debugging and testing and automated validation workflows.

You can enrich Agent mode by adding more tools, whether through MCP servers or extensions that contribute custom tools. That means your agent can, for example, reach into external APIs, talk to infrastructure services, or perform code transformations powered by other extensions, all within the same conversation.

The “Plan” persona specializes in building a clear implementation roadmap. Instead of directly editing files, it focuses on decomposing your high‑level request into structured steps, asking clarifying questions and making sure you have a solid, actionable plan. You can then hand this plan over to Agent mode or follow it manually as you implement.

The “Ask” persona is your go‑to for Q&A about code and concepts. It’s optimized for understanding, explanation and idea exploration: how a certain piece of code works, where a configuration is defined, or different ways to implement a feature. Ask uses agentic capabilities to gather context from your codebase so answers are grounded in your actual project instead of generic boilerplate.

When Ask responds with code blocks, you can hover over them and use the “Apply in Editor” action to insert or replace code in the appropriate file, giving you fine‑grained control instead of sweeping multi‑file edits. For many developers, this is the safest way to start using AI in the codebase without feeling like they’re giving up control.

Starting your own local agent sessions in VS Code

Beginning a local agent session in VS Code is very similar to starting a chat with Copilot, but with more explicit control over which persona you’re using and which tools are available during the session.

To kick off a session with the general Agent persona, open the Chat view, pick “Agent” from the agent selector and type a high‑level request in the input box. This might be something like “Implement an OAuth2 + JWT authentication flow for this app” or “Set up CI/CD for this repository using GitHub Actions.”

Before sending, you can use the tools picker to enable or disable specific tools, effectively deciding how much power you want to give the agent (for instance, whether it can run tests, modify files in bulk or call external MCP tools). Then press Enter or click Send to start the agent loop.

As the agent proposes changes and runs tools, you review and confirm or adjust its actions. You can keep sending follow‑up prompts while it’s still working to steer the direction, queue new requests or interrupt and send a different instruction immediately. This kind of conversational control lets you treat the agent like a real collaborator you are guiding in real time.

Starting with the Ask persona is even simpler: just type your question into the chat, choose Ask in the agent picker, and send. You can add specific context, such as file references or code snippets, to get more targeted answers, especially when dealing with large projects where the agent might otherwise search too widely.

For each of these personas, there are additional learning paths and tutorials—including an agents overview, hands‑on guides, documentation about tools and custom agents, and dedicated articles about the chat interface—that help you push beyond basic usage once you’re comfortable.

Stepping back, VS Code’s modern AI stack—AI Toolkit, Azure AI Foundry integration, local agents, built‑in personas and MCP tools—turns the editor into a complete AI workspace where you can discover models, craft prompts, build and evaluate agents, wire them to external services and finally embed them into your JavaScript, React or any other applications, all while keeping tight control over your codebase and development workflow.