VS Code Agents: новый AI‑первый редактор от Microsoft для разработчиков и студентов — VogueTech

Что нового

Microsoft запустила отдельное приложение VS Code Agents – Insiders. Это не очередное расширение для VS Code, а самостоятельный редактор, который изначально строится вокруг AI‑агентов.

Ключевые отличия:

Отдельное приложение: своя установка, профиль, настройки и хранилище данных. Можно держать рядом обычный VS Code, VS Code Insiders и VS Code Agents — конфликта не будет.
Agent‑first интерфейс: вместо привычной схемы «открыл файлы — пишешь код — иногда зовёшь Copilot» всё строится вокруг чата с агентами. Ты формулируешь цель, а редактор управляет выполнением.
Три встроенных агента:
- Agent — автономно пишет и правит код, запускает команды, чинит ошибки.
- Plan — сначала строит подробный план реализации, не трогая файлы.
- Ask — отвечает на вопросы о кодовой базе, ничего не изменяя.
Четыре среды выполнения агентов:
- Локальный агент в редакторе.
- Агент Copilot CLI, работающий в фоне через командную строку.
- Облачный GitHub Copilot Coding Agent, который сам открывает pull request.
- Поддержка сторонних агентов от Anthropic (Claude) и OpenAI.
Гибкие уровни автономии: от режима, где агент спрашивает разрешение на каждую команду, до «автопилота», который всё делает сам.

VS Code Agents – Insiders ориентирован на студентов, начинающих разработчиков и инженеров, которые хотят работать с агентным стилем разработки: когда ты задаёшь цель, а не диктуешь каждую строчку кода.

Как это работает

Отдельный релиз‑канал и архитектура

VS Code Agents – Insiders — это pre‑release‑канал нового приложения. По аналогии с VS Code Insiders (ночные сборки VS Code), здесь ты получаешь ранний доступ к функциям, заточенным под агентный подход.

Сравнение трёх приложений:

VS Code (stable)
- Канал: стабильный релиз.
- Основной сценарий: ручное редактирование кода, Copilot — в виде дополнений и чата.
- Agent Mode: есть, но включается отдельно через настройки.
VS Code Insiders
- Канал: nightly, самые ранние экспериментальные функции.
- Основной сценарий: тот же, что у стабильного VS Code.
- Agent Mode: есть, плюс самые свежие экспериментальные возможности агентов.
VS Code Agents – Insiders
- Канал: pre‑release, но как отдельное приложение.
- Основной сценарий: «опиши цель — агент её выполнит». Редактор — поверхность для ревью.
- Платформа агентов: локальные агенты, Copilot CLI, облачные агенты, сторонние модели.

Главное архитектурное изменение — agent‑first UI. Ты открываешь не файлы, а Chat view:

Выбираешь тип сессии (где будет работать агент): Local, Copilot CLI или Cloud.
Выбираешь персону агента: Agent, Plan или Ask.
Задаёшь цель: «Сделай CLI, который…», «Разбей задачу на шаги», «Объясни, как устроен этот модуль».
Приложение само решает, какие файлы читать, что редактировать, какие команды запускать.

Четыре способа запускать агентов

1. Локальный агент

Локальный агент работает прямо в редакторе на твоей машине. Он видит:

все файлы в рабочей папке;
встроенный терминал;
установленные расширения VS Code;
MCP‑сервера, которые ты подключил.

Это удобно для задач, где нужно держать процесс под контролем:

быстрый прототипинг и брейншторминг;
работа, завязанная на локальный контекст (упавшие тесты, вывод линтеров, логи дебаггера);
использование инструментов из расширений VS Code или своих MCP‑серверов.

2. Агент Copilot CLI

Copilot CLI агент запускается из командной строки и работает в фоне. Он использует Git worktree — отдельную рабочую копию репозитория на новой ветке. Это даёт изоляцию: агент не трогает твой основной working tree.

Подходит, когда:

есть чётко определённая задача, а ты хочешь параллельно заниматься другим;
нужно прогнать несколько proof‑of‑concept‑подходов в разных ветках;
тебе комфортнее сценарий «headless» — без постоянного визуального контроля.

3. Облачный агент (GitHub Copilot Coding Agent)

Облачный агент работает удалённо и интегрирован с GitHub. Ты можешь назначить GitHub issue на Copilot (поставить исполнителем copilot или упомянуть его в комментарии), и агент:

реализует изменения;
создаст pull request для ревью командой.

Сценарии применения:

нужно получить PR без локальной настройки окружения;
задача хорошо формализована и не требует доступа к локальным файлам;
важна командная работа: PR сразу попадает в обычный рабочий процесс на GitHub.

4. Сторонние агенты

VS Code Agents – Insiders умеет работать с агентами от Anthropic (Claude) и OpenAI. Можно подключить «свою» модель и запускать агентов локально или в облаке, опираясь на выбранного провайдера.

Это полезно, если:

у тебя уже есть API‑ключ и предпочтения по провайдеру;
ты разрабатываешь и тестируешь агентов под конкретную модель, отличную от Microsoft;
хочешь гибко переключаться между средами выполнения.

Переключение среды осуществляется через Agent Target в Chat view. История диалога сохраняется при переходе между средами, поэтому контекст не теряется.

Три встроенных агента: Agent, Plan и Ask

В любой среде выполнения ты выбираешь не только где, но и каким агентом работать.

Agent: выполняет работу

Основной рабочий агент. Ты задаёшь цель, а он:

решает, какие файлы читать;
какие изменения внести;
какие команды запустить в терминале;
как реагировать на ошибки.

Agent сам вносит правки в редактор, циклично дорабатывает результат и останавливается, когда завершает задачу или упирается в необходимость твоего решения.

Подходит для:

реализации фич;
исправления багов;
рефакторинга;
миграций.

Plan: сначала думает, потом пишет

Plan нужен для сложных задач, где важно сначала получить структуру, а уже потом код. Он:

строит подробный план по шагам;
задаёт уточняющие вопросы;
даёт тебе возможность отредактировать план.

После утверждения плана ты можешь передать его Agent или Copilot CLI. Это особенно полезно для крупных фич: агент получает «карту местности», а не разрозненные подсказки.

Ask: понять, а не поменять

Ask отвечает на вопросы о коде и технологиях, не трогая файлы. Он:

ищет контекст по всей рабочей папке;
анализирует код, архитектуру, зависимости;
объясняет, как всё устроено.

Ask — удобный инструмент, когда ты впервые заходишь в незнакомый проект или разбираешься с чужим модулем перед изменениями.

Уровни автономии: сколько свободы дать агенту

В Chat view есть переключатель разрешений, который определяет, насколько агент автономен:

Default Approvals
- Агент спрашивает подтверждение перед запуском команд в терминале.
- Чтение файлов и поиск выполняются без вопросов.
- Рекомендуемый режим для старта и обучения.
Bypass Approvals
- Все вызовы инструментов автоматически одобряются.
- Агент всё ещё может задавать уточняющие вопросы по задаче.
- Подходит для задач с понятной и ограниченной областью.
Autopilot (Preview)
- Все вызовы инструментов одобряются автоматически.
- Уточняющие вопросы тоже обрабатываются без участия пользователя.
- Агент работает максимально автономно до завершения задачи.

Для студентов и новичков Microsoft прямо рекомендует начинать с Default Approvals — по визуальным вызовам инструментов быстро становится понятно, как агент работает «под капотом».

Что это значит для вас

Если вы студент

VS Code Agents – Insiders закрывает типичные боли учебных проектов:

Проект «под ключ»: можно сформулировать цель вроде «Сделай CLI, который…», получить план, реализацию, тесты и PR, не проваливаясь в каждый шаг руками.
Понимание чужого кода: Ask помогает разбираться с примерами преподавателя или open source‑проектами.
Эксперименты без риска: Copilot CLI работает в отдельном worktree, не ломая основную ветку.

GitHub Copilot для студентов доступен бесплатно через GitHub Student Developer Pack, поэтому входной порог — это только установка приложения и базовая настройка.

Если вы разработчик или тимлид

VS Code Agents — это не просто чат рядом с редактором, а оркестратор нескольких агентов и сред:

можно спланировать фичу локально с Plan;
отдать реализацию Copilot CLI в отдельной ветке;
затем поручить облачному агенту открыть pull request.

Всё это происходит в одной Sessions‑панели: ты видишь, что уже сделано, какие сессии активны, и можешь переключаться между ними.

Практические сценарии:

быстрое прототипирование фич без ручной рутины;
автоматизированная работа с GitHub Issues через облачного агента;
подключение своих MCP‑серверов для доступа к внутренним базам, API, инструментам.

Ограничения и доступность

Приложение требует GitHub Copilot — без активной подписки или студенческого пакета агенты работать не будут.
Для облачного агента нужен GitHub‑репозиторий и права на создание веток и PR.
В России доступ к GitHub Copilot и некоторым облачным возможностям может потребовать VPN и обходных настроек. Это важно учитывать при планировании командного использования.

VS Code Agents удобнее всего воспринимать как рабочую станцию для агентной разработки: если ты уже пользуешься Copilot, это следующий шаг — меньше ручной рутины, больше постановки задач и ревью.

Место на рынке

VS Code Agents – Insiders логично продолжает линию продуктов Microsoft вокруг GitHub Copilot и VS Code:

VS Code + Copilot по‑прежнему остаётся оптимальным выбором, если тебе нужен классический редактор с автодополнением и иногда — чат.
VS Code Agents нужен, когда ты хочешь строить процесс вокруг агентов: от планирования до PR.

По сравнению с обычным VS Code:

VS Code Agents даёт более глубокую интеграцию с агентами (отдельный UI, несколько типов агентов, встроенное управление сессиями).
Обычный VS Code остаётся универсальным редактором, где Copilot — дополнение, а не центр интерфейса.

По сравнению с другими AI‑инструментами (вроде веб‑чатов с Claude или ChatGPT):

VS Code Agents работает прямо с репозиторием и терминалом, а не с загруженными фрагментами кода.
Поддержка MCP и расширений VS Code превращает его в платформу, где можно подключать свои инструменты и данные.

Чётких публичных бенчмарков по скорости или стоимости работы агентов в VS Code Agents по сравнению с обычным Copilot нет. С точки зрения пользователя, основное отличие — в сценариях использования и удобстве, а не в «сырых» характеристиках.

Установка

VS Code Agents – Insiders распространяется через страницу загрузки Visual Studio Code Insiders:

Перейди на https://code.visualstudio.com/insiders/.
Найди вариант Agents – Insiders рядом со стандартной сборкой Insiders.
Скачай и установи — приложение ставится отдельно от обычного VS Code.

У него свой исполняемый файл, профиль и хранилище данных, поэтому твоя текущая установка VS Code не изменится.

Как запустить

Шаг 1. Войти через GitHub и активировать Copilot

При первом запуске VS Code Agents – Insiders попросит войти через GitHub. Для работы агентов нужна активная подписка GitHub Copilot.

Если ты студент, получи Copilot бесплатно через GitHub Student Developer Pack — это набор инструментов для проверенных студентов, куда входит полная подписка на Copilot.

Шаг 2. Разобраться с интерфейсом

Главное отличие от обычного VS Code — Chat view становится центральным элементом, а не дополнением к файловому дереву.

В левой части:

Sessions — список всех сессий агентов: локальных, CLI и облачных. Там видно, какие ещё работают, какие завершены, и можно вернуться к любой.

Внизу Chat view — три ключевых элемента управления:

Session type — где запустить агента: Local, Copilot CLI или Cloud.
Agents — какую персону использовать: Agent, Plan или Ask.
Permissions — уровень автономии: Default Approvals, Bypass Approvals или Autopilot.

Справа — редактор кода. Ты не прыгаешь по файлам вручную: агент сам открывает нужные файлы и показывает диффы. Твоя задача — просматривать и принимать или отклонять изменения.

Шаг 3. Открыть рабочую папку

Через File → Open Folder открой существующий проект или создай новый из терминала. Открытая папка нужна агентам как контекст:

откуда читать файлы;
где запускать команды;
где создавать Git worktree для фоновых задач.

Как это работает под капотом: цикл агента

Когда ты отправляешь запрос агенту (персона Agent), он входит в автономный цикл:

Планирование — определяет, какие файлы и шаги нужны.
Выбор инструмента — файл‑ридер, редактор, терминал, web‑fetch, поиск по символам или MCP‑инструмент.
Выполнение — запускает выбранный инструмент и получает результат.
Оценка — проверяет результат: читаёт ошибки компиляции, вывод тестов, предупреждения линтеров.
Итерация — если что‑то не так, исправляет и пробует снова, без нового запроса от тебя.
Остановка — когда цель достигнута или требуется твоё решение.

Все вызовы инструментов прозрачно отображаются в Chat view. Есть кнопка Undo Last Edit в заголовке представления, которая откатывает последнее изменение агента. Это сочетание автономии и обратимости делает инструмент пригодным для реальной разработки.

Управление сессиями

Все сессии агентов — локальные, CLI и облачные — видны в списке Sessions в Chat view.

Ты можешь:

переключаться между активными сессиями;
просматривать историю любой сессии;
передавать сессию от одного агента к другому.

Пример сценария:

Локально запускаешь Plan, чтобы спроектировать фичу.
Передаёшь план Copilot CLI, чтобы тот реализовал его в фоне в отдельном worktree.
Затем передаёшь контекст облачному агенту, который создаёт pull request.

Всё это — в рамках одного диалога, без копирования текста между разными окнами.

Кастомные инструкции: как научить агента правилам проекта

По умолчанию агент не знает стиля и соглашений конкретного проекта. Ты можешь задать их один раз в файле .github/copilot-instructions.md в корне репозитория.

Пример для проекта study-summariser:

# .github/copilot-instructions.md

## Project: study-summariser
- Language: Python 3.11+
- Package manager: uv (pyproject.toml)
- AI calls: Azure OpenAI via the openai SDK v1.x (AzureOpenAI client)
- Model deployment: gpt-4o
- Use Pydantic v2 for structured outputs
- Never hard-code credentials; always use python-dotenv and a .env file
- All functions must have docstrings
- Tests live in tests/ and use pytest
- CLI entry point: src/summariser/main.py
- Add everything sensitive to .gitignore

Любая сессия агента в этом workspace автоматически читает и учитывает эти инструкции. Это значит, что тебе не нужно каждый раз повторять требования в промпте: достаточно один раз описать их в файле.

Model Context Protocol (MCP): расширяем инструментарий агента

MCP — это открытый протокол, который стандартизирует подключение агентов к внешним инструментам и источникам данных. Удобнее всего думать о нём как о «USB для AI»: любой MCP‑совместимый сервер можно подключить как инструмент, и агент будет вызывать его так же, как терминал или файловый редактор.

Подключение MCP‑серверов настраивается в .vscode/mcp.json:

{
  "servers": {
    "exam-db": {
      "type": "stdio",
      "command": "python",
      "args": ["tools/exam_db_mcp_server.py"]
    },
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_PAT}"
      }
    }
  }
}

После этого агент может, например, во время задачи:

обратиться к локальной базе экзаменационных вопросов через exam-db;
вызвать GitHub API через MCP‑сервер.

Шаблон ${env:GITHUB_PAT} подтягивает секреты из переменных окружения во время выполнения, не кладя их в репозиторий.

Как запустить: пример студенческого проекта

Разберём, как VS Code Agents – Insiders работает на живом примере — AI‑суммаризатор конспектов для подготовки к экзаменам.

Цель проекта

Язык: Python.
Приложение: CLI study-summariser.
Вход: текстовый файл с конспектом.
Выход: Markdown с:
- темой;
- 5–10 ключевыми концепциями;
- словарём термин → определение;
- тремя экзаменационными вопросами;
- уровнем сложности (beginner / intermediate / advanced).
AI: Azure OpenAI gpt-4o с Pydantic‑моделями для структурированных ответов.

Подготовка репозитория и инструкций

В терминале:

mkdir study-summariser
cd study-summariser
git init

Открываешь папку в VS Code Agents – Insiders (File → Open Folder), создаёшь .github/copilot-instructions.md со структурой выше.

Фаза 1. Планирование с Plan

В нижней панели Chat выставляешь:

Session type: Local;
Agents: Plan;
Permissions: Default Approvals.

Отправляешь запрос в духе:

Хочу сделать Python CLI‑утилиту study-summariser. Она должна принимать текстовый файл с конспектом и вызывать Azure OpenAI, чтобы вернуть структурированное резюме: тема, 5–10 ключевых концепций, определения (термин → определение), три экзаменационных вопроса и уровень сложности (beginner / intermediate / advanced). Используй uv для управления пакетами, Pydantic v2 для структурированных ответов и python-dotenv для секретов. Точка входа CLI — src/summariser/main.py с argparse. Составь подробный план реализации.

Plan выдаёт нумерованный план: от структуры проекта и Pydantic‑моделей до интеграции с Azure OpenAI, CLI и тестов. Если чего‑то не хватает или шаги нужно поменять местами — просишь его переписать части плана.

Когда всё устраивает, внизу появляется кнопка Start Implementation. Нажимаешь её и выбираешь Continue in Copilot CLI — план и контекст автоматически передаются в CLI‑агент.

Фаза 2. Реализация с Copilot CLI в фоне

В Sessions появляется новая запись сессии. Copilot CLI создаёт Git worktree — отдельную рабочую копию репозитория на новой ветке — и начинает работать в ней.

Приложение спрашивает, нужно ли Copy Changes в worktree. Подтверждаешь, чтобы агент видел .github/copilot-instructions.md и следовал правилам проекта.

Дальше можно заниматься чем угодно: запустить другую сессию с Ask, открыть другой проект или отойти от компьютера. В сессии Copilot CLI ты увидишь live‑лог: какие файлы созданы, какие команды запущены, какие тесты прошли или упали.

Агент, среди прочего, создаёт Pydantic‑модель в src/summariser/models.py:

# src/summariser/models.py

from typing import Literal
from pydantic import BaseModel, Field


class StudySummary(BaseModel):
    """Structured summary of study notes produced by the AI."""

    topic: str = Field(description="The main subject or topic of the provided notes.")
    key_concepts: list[str] = Field(
        description="A list of 5 to 10 key concepts from the notes.",
        min_length=5,
        max_length=10,
    )
    definitions: dict[str, str] = Field(
        description="A dictionary mapping important terms to their definitions."
    )
    practice_questions: list[str] = Field(
        description="Exactly 3 exam-style practice questions based on the notes.",
        min_length=3,
        max_length=3,
    )
    difficulty_level: Literal["beginner", "intermediate", "advanced"] = Field(
        description="The estimated difficulty level of the content."
    )

И интеграцию с Azure OpenAI в src/summariser/summarise.py:

# src/summariser/summarise.py

import os
from dotenv import load_dotenv
from openai import AzureOpenAI
from .models import StudySummary

load_dotenv()


def summarise_notes(text: str) -> StudySummary:
    """Call Azure OpenAI to produce a structured study summary.

    Args:
        text: Raw study notes text to summarise.

    Returns:
        A populated StudySummary Pydantic model.

    Raises:
        ValueError: If required environment variables are not set.
    """
    endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    api_key = os.getenv("AZURE_OPENAI_API_KEY")
    deployment = os.getenv("AZURE_OPENAI_DEPLOYMENT", "gpt-4o")

    if not endpoint or not api_key:
        raise ValueError(
            "AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY must be set in your .env file."
        )

    client = AzureOpenAI(
        azure_endpoint=endpoint,
        api_key=api_key,
        api_version="2024-08-01-preview",
    )

    completion = client.beta.chat.completions.parse(
        model=deployment,
        messages=[
            {
                "role": "system",
                "content": (
                    "You are an expert academic tutor. Analyse the provided study notes "
                    "and produce a structured summary with key concepts, definitions, "
                    "and practice questions."
                ),
            },
            {"role": "user", "content": f"Study notes:\n{text}"},
        ],
        response_format=StudySummary,
    )

    return completion.choices[0].message.parsed

Дальше агент настраивает зависимости через uv sync, пишет тесты, гоняет pytest и дорабатывает код до зелёного статуса.

Фаза 3. Облачный агент и pull request

После того как локальный и CLI‑агенты закончили свою часть, можно передать контекст облачному GitHub Copilot Coding Agent. Он, опираясь на историю сессии и текущую ветку, подготовит и откроет pull request в репозитории.

Для команды это выглядит как обычный PR: с diff, описанием и возможностью ревью. Разница в том, что большую часть работы сделал агент, а разработчик концентрируется на проверке и доработке.

VS Code Agents – Insiders — это шаг в сторону разработки, где ты формулируешь задачи и проверяешь результат, а не вручную ведёшь IDE за руку. Для студентов это быстрый путь от идеи до рабочего CLI‑инструмента. Для команд — способ встроить агентов в привычные процессы GitHub и VS Code без потери контроля над кодом и инфраструктурой.