Visual Studio Code GitHub Copilot vs. Eclipse Theia AI

If you plan to build applications with AI support, especially for software development, you first need to decide which platform to use. You can build a plain web application from scratch and implement everything yourself, or build on top of an existing platform. In my previous blog posts, I explained how to customize the AI experience in Visual Studio Code and how to create a custom AI extension in Eclipse Theia. While writing those posts, I noticed many similarities, both from a user perspective and from an extension-development perspective. In this post, I compare both approaches to give you a clearer view of where they align and where they differ. If you have not read my previous blog posts and want more details, have a look at:

• Extending Copilot in Visual Studio Code
• Getting Started with Theia AI

Note:
This blog post is based on Visual Studio Code 1.113.0 and Eclipse Theia 1.70.0. There may be differences if you read it when newer versions have been released.

Strategic Comparison

In the article Why Extending GitHub Copilot in VS Code May Not Be the Best Fit for Your AI-Native Development Tool, you can already find a comprehensive overview of the differences between GitHub Copilot in Visual Studio Code and Theia AI. The article is around half a year old and is therefore not fully up to date with the latest features. However, the strategic perspective is still well described and remains valid, so the article is still worth reading if you plan to adopt either technology.

The following table extracts and summarizes an initial comparison of key aspects from that article:

	VS Code GitHub Copilot	Eclipse Theia AI
Platform	Product you can extend	Platform you can own
License	Mixture of open source parts (MIT) and proprietary parts (Microsoft products)	Completely open source (EPL)
AI customization options	Chat only	any part of the application
Licensing	Copilot subscription required	-
LLM Support	Depends on Copilot subscription AI language models in VS Code	Depends on existing providers LLM Providers Overview

AI Extension Comparison

Visual Studio Code GitHub Copilot extensions and Eclipse Theia AI extensions target similar use cases: extending the AI capabilities of the IDE. There are differences in terminology, implementation, extension capabilities, and features. In previous blog posts, I explained how to contribute Tools, MCP Servers, and Chat Extensions. The concepts already differ in naming, as shown in the following table:

VS Code GitHub Copilot	Eclipse Theia AI
Language Model Tool	Tool Function
MCP	MCP
Chat Participant	Agent

The following sections will explain the differences in more detail.

Language Model Tool vs. Tool Function

Tools provide additional capabilities to perform specialized tasks when interacting with an LLM. In Visual Studio Code, they are called Language Model Tools; in Theia, they are called Tool Functions.

Visual Studio Code

To contribute a Language Model Tool via Copilot Extension, you follow the typical contribution pattern in Visual Studio Code Extensions:

• Configure the contribution via contributes/languageModelTools section in the extensions package.json
• Implement a new class that implements the vscode.LanguageModelTool interface
• Register it in the extension via vscode.lm.registerTool()

Further details can be found in Extending Copilot in Visual Studio Code - Language Model Tool.

Eclipse Theia

To contribute a Tool Function via Theia Extension, you follow the typical contribution pattern in Theia:

• Implement a new class that implements the ToolProvider interface from the @theia/ai-core package
• Register it in a ContainerModule for injection via bindToolProvider() from @theia/ai-core/lib/common

Further details can be found in Getting Started with Theia AI - Tool Functions.

MCP Support

MCP Servers are typically configured by users via a configuration file. The usage comparison is described later in Configuring MCP Servers. MCP Servers can also be contributed and configured programmatically, for example when you contribute an extension that provides an advanced AI use case requiring dedicated tools via MCP.

Note:
MCP servers that are programmatically registered via a Visual Studio Code Copilot extension can also be installed in a Theia application if the @theia/plugin-ext extension is available.

Visual Studio Code

To contribute a MCP Server via Copilot Extension, you follow the typical contribution pattern in Visual Studio Code Extensions:

• Configure the contribution via contributes/mcpServerDefinitionProviders section in the extensions package.json
• Register a McpServerDefinitionProvider in the extension via vscode.lm.registerMcpServerDefinitionProvider()
• Add MCP servers via McpServerDefinitionProvider#provideMcpServerDefinitions()
  • A local MCP server can be configured by creating a vscode.McpStdioServerDefinition
  • A remote MCP server can be configured by creating a vscode.McpHttpServerDefinition
• Dynamic resolution (e.g. asking the user for an authorization token) can be added via McpServerDefinitionProvider#resolveMcpServerDefinition()

There are some limitations:

• To ensure that the MCP servers are registered automatically on start, you need to configure the activationEvents accordingly, e.g. onStartupFinished
• There is no API to programmatically start or stop an MCP Server in Visual Studio Code.
• Programmatically registered MCP servers do not show up in the MCP Servers section of the Extensions view.
• Programmatically registered MCP servers do not get roots set based on the current workspace directory.

Further details can be found in Extending Copilot in Visual Studio Code - Add MCP server programmatically via VS Code Extension.

Eclipse Theia

To contribute a MCP Server via Theia Extension, you follow the typical contribution pattern in Theia:

• Implement a FrontendApplicationContribution
• Get the MCPFrontendService injected
• Add MCP servers via MCPFrontendService#addOrUpdateServer()
  • A local MCP server can be configured by creating a LocalMCPServerDescription
  • A remote MCP server can be configured by creating a RemoteMCPServerDescription
• Dynamic resolution (e.g. asking the user for an authorization token) can be added directly to the MCPServerDescription via the MCPServerDescription#resolve() function
• Register it in a ContainerModule via bind()

Compared to the limitations in Visual Studio Code, programmatically registered MCP servers in Theia

• are automatically registered if the FrontendApplicationContribution is registered correctly in a ContainerModule
• can be started and stopped programmatically via MCPFrontendService#startServer() and MCPFrontendService#stopServer()
• do show up in the AI Configuration view
• Since Theia 1.69.0, roots are supported. This support was added via PR. You can configure whether the workspace should be used as a Root via the preference ai-features.mcp.useWorkspaceAsRoot.

Further details can be found in Getting Started with Theia AI - Add MCP server programmatically via Theia Extension.

Chat Participant vs. Custom Agent

To extend the AI capabilities of an IDE or application with a specialized assistant that provides domain-specific expert knowledge, you can implement and contribute a Chat Participant in Visual Studio Code or a Custom Agent in Eclipse Theia. In both cases, the benefits of such a programmatically created AI assistant are:

• you can manage the end-to-end prompt/response conversation
• you have access to the respective API, which allows deep integration with the underlying platform
• you can distribute and deploy it via extensions

Custom Agents defined via configuration files can only interact with the underlying platform if the required functionality is available as a Language Model Tool or Tool Function, or via MCP. They are also available only when the corresponding configuration files are present in the user’s workspace. Custom Agents from a user’s perspective are covered in a later section. In this section, I focus on the differences in programmatically created AI extensions.

Visual Studio Code

As the name implies, a Chat Participant contributed via a Visual Studio Code Copilot extension is intended for and limited to chat. There are no other use cases where a Chat Participant can be integrated, such as the terminal.

To contribute a Chat Participant via Copilot Extension, you follow the typical contribution pattern in Visual Studio Code Extensions:

• Configure the contribution via contributes/chatParticipants section in the extensions package.json
• Define a vscode.ChatRequestHandler which sends the chat request and handles the response
• Create a vscode.ChatParticipant via vscode.chat.createChatParticipant() by using the id defined in the package.json and the defined vscode.ChatRequestHandler
• Register the vscode.ChatParticipant in the extension by pushing it to the context.subscriptions

To use the Chat Participant, you need to invoke it with the @ syntax, e.g. @joker tell me a joke.

Further details can be found in Extending Copilot in Visual Studio Code - Chat Participant.

Eclipse Theia

Compared to Visual Studio Code, a Custom Agent in Theia is not limited to the chat. It can also be integrated into other parts of the IDE, such as the editor, the terminal, or a custom widget.

To contribute a Custom Agent via a Theia Extension, you follow the typical contribution pattern in Theia:

• Implement an AbstractStreamParsingChatAgent and define the necessary attributes such as id, name, description, prompt(s), Tool Functions, and Agent-Specific Variables, if needed.
• Register it in a ContainerModule via bind()

When implementing a Custom Agent, there are several advanced features that can improve the user experience, for example:

• Prompt Variants
• Agent-specific Variables
• Agent-to-Agent Delegation
• Custom Response Part Rendering

To use a Custom Agent in Theia, you need to invoke it with the @ syntax, e.g. @Joker a joke about scarecrow.

Further details can be found in Getting Started with Theia AI - Implement a Custom Agent.

AI Usage Comparison

The sections above covered differences in programmatic AI customization. In the following sections, I compare AI usage differences from a user’s point of view.

Using tools in prompts

How tools are used in prompts differs between Visual Studio Code and Theia. In general, there are three types of tools:

• Built-in tools provided by the platform
• MCP tools added via MCP servers
• Extension tools provided programmatically (Language Model Tool vs. Tool Function)

Visual Studio Code

In Visual Studio Code, a Tool is used when processing a prompt if:

• the tool is in the list of enabled tools and is selected automatically

  

• the tool is used explicitly by mentioning it using a leading #

  #jokeFileCreator create a file that contains a joke in the folder test
  

For tools provided via MCP, the tool is also selected by name. Assuming you added the fetch MCP server, you can use the provided tool via #fetch. Unfortunately, this is not unique because there is also a built-in fetch tool in Visual Studio Code.

By default, you will be prompted before a Language Model Tool is executed.

In the Allow dropdown, you can choose whether to allow execution once, for the current session, or generally in the current workspace. This setting is not directly accessible at the time of writing this blog post. To reset saved tool approvals, run the Chat: Reset Tool Confirmations command from the Command Palette (Ctrl+Shift+P).

In Visual Studio Code, it is also possible to configure URL approval, which becomes active when a tool attempts to access a URL.

Further details about using tools in chat in Visual Studio Code can be found in Use tools with agents.

Eclipse Theia

In Eclipse Theia, a Tool is used by mentioning it with a leading ~. There is no automatic tool resolution for prompts, so you always need to mention the tool explicitly.

@Universal create a file that contains a joke in the folder test. Use a file name that relates to the joke. ~jokeFileCreator

The name of an MCP server tool in Theia is derived from the server name and function name. It uses the following syntax:

~{mcp_<server-name>_<function-name>}

For example, to use the fetch function of the fetch MCP server, you could write a prompt like this:

@Universal show me the allowed directories ~{mcp_fetch_fetch}

By default, the Tool Confirmation Mode is Always Allow. Users can change this setting.

• Open the AI Configuration view via Menu -> View -> AI Configuration
• Switch to the Tools tab

  

• Alternatively, edit settings.json and configure ai-features.chat.toolConfirmation. For example, if you want to be prompted for approval for every tool call but allow jokeFileCreator to execute without confirmation:

  "ai-features.chat.toolConfirmation": {
    "*": "confirm",
    "jokeFileCreator": "always_allow"
  },
  

The URL approval feature is currently not supported in Eclipse Theia.

Further details about using tools in chat in Eclipse Theia can be found in Tool Functions, Using MCP Server Functions, and Tool Call Confirmation UI.

Configuring MCP Servers

As a user, you typically add MCP servers to your development environment via a configuration file. There are two basic types of MCP servers:

• local MCP servers, which are software installed on your system
• remote MCP servers, which are hosted elsewhere and provide functionality without needing local system access.

Visual Studio Code

In Visual Studio Code, you typically add MCP servers via an mcp.json file, either in the workspace .vscode folder or in the user profile to configure MCP servers for all workspaces. A mcp.json file has two main sections:

• "servers": {} - Contains the list of MCP servers and their configurations
• "inputs": [] - Optional placeholders for sensitive information like API keys

You can use predefined variables in the servers section and the variables defined in the inputs section.

{
  "servers": {
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"]
    },
    "fetch": {
      "url": "https://remote.mcpservers.org/fetch/mcp",
      "type": "http"
    },
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "type": "sse",
      "headers": {
        "X-MCP-Toolsets": "gists",
        "Authorization": "Bearer ${env:GITHUB_TOKEN}"
      }
    }
  },
  "inputs": []
}

From the example above, you can see that you need to specify the type field to define whether it is a local or a remote MCP server.

You can manage the MCP server either via

• MCP SERVERS - INSTALLED section in the Extensions view

  

• Inline actions in the mcp.json editor (codelenses)

  

• MCP: List Servers command from the Command Palette

  

After the first start of an MCP server, the server’s capabilities and tools are discovered and cached. The next time a tool is used in a prompt while the server is not running yet, Visual Studio Code can auto-start the server because of this cached information.

Using the chat.mcp.autostart setting, you can configure whether MCP servers should be restarted automatically when configuration changes are detected. This autostart setting is available only globally, not per server.

Further information can be found in Use MCP servers in VS Code.

Eclipse Theia

In Eclipse Theia, you typically add MCP servers via the general settings.json file. There is currently no support for an mcp.json file.

The settings.json file contains many settings that can be applied in Theia, not just MCP-related configuration. There is no support for predefined variables or inputs like the inputs section in mcp.json.

Comparing Visual Studio Code mcp.json and Eclipse Theia settings.json MCP server configuration, there are a few differences:

• In Theia, you do not need to specify the type field.
  For local servers, this is straightforward because only one type is available (stdio). For remote servers, Theia first tries to connect via sse, and if that fails, it falls back to http.
• In Eclipse Theia, there is an autostart field that lets you configure whether an MCP server should start automatically. The default is true if it is not set.
• For remote servers, the main URL is set as url in Visual Studio Code, while in Eclipse Theia the field is called serverUrl.
• In Eclipse Theia, you can specify the authentication token via serverAuthToken, which defaults to an Authorization header with Bearer. You can change that via serverAuthTokenHeader.

{
  "ai-features.mcp.mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/home/node/examples"
      ],
      "autostart": false
    },
    "fetch": {
      "serverUrl": "https://remote.mcpservers.org/fetch/mcp",
      "autostart": false
    },
    "github": {
      "serverUrl": "https://api.githubcopilot.com/mcp/",
      "serverAuthToken": "<your-token>",
      "headers": {
        "X-MCP-Toolsets": "gists"
      }
    }
  }
}

You can manage the MCP server either via

• AI Configuration view: Menu -> View -> AI Configuration -> MCP Servers tab

  

• Command palette: F1
  • MCP: Start MCP Server -> filesystem
  • MCP: Stop MCP Server -> filesystem

If an MCP server is not started, its capabilities and tools cannot be used. There is no auto-start based on cached information as in Visual Studio Code. However, you can configure auto-start behavior per server via the autostart field, which is enabled by default.

Further information can be found in MCP Integration.

Chat Variables

In Visual Studio Code and Eclipse Theia, it is possible, and usually recommended, to add specific context to your request. To do this explicitly, you can use the # syntax with some predefined options.

In Theia, it is also possible to implement and provide additional Context Variables as Global Variables or Agent-Specific Variables.

Further information for Visual Studio Code can be found in Add context to your prompts.

Further information for Eclipse Theia can be found in Context Variables.

Prompt Files vs Prompt Fragments

Visual Studio Code and Eclipse Theia both allow users to define reusable prompts for recurring development tasks. Although the feature is similar, there are differences.

Visual Studio Code

In Visual Studio Code, you can create and use Prompt Files to define reusable prompts for recurring development tasks.

Prompt Files are Markdown files with a .prompt.md file extension. They are located either in the .github/prompts folder in the workspace or in the prompts folder in the user profile (for example on Windows, C:\Users\<username>\AppData\Roaming\Code\User\prompts).

In the optional YAML frontmatter header, the prompt behavior can be configured, for example:

• agent header to define the agent that should be used for running the prompt
• tools header to define the list of tools or tool sets that are available for the prompt

You can use variables in the prompt file using the syntax ${variableName}. The following variables can be used:

• Workspace variables - ${workspaceFolder}, ${workspaceFolderBasename}
• Selection variables - ${selection}, ${selectedText}
• File context variables - ${file}, ${fileBasename}, ${fileDirname}, ${fileBasenameNoExtension}
• Input variables - ${input:variableName}, ${input:variableName:placeholder}

Arguments passed in chat via key=value syntax (e.g. _target=robin) are available in the prompt via ${input:variableName} or ${input:variableName:placeholder}.

Tools configured as available in the prompt via the tools frontmatter header can be referenced in the prompt via #tool:<tool-name>.

To use a Prompt File in the Chat view, type / followed by the prompt name. For example, if you created a harley.prompt.md file, you could execute it via the slash command /harley.

Further information can be found in Extending Copilot in Visual Studio Code - Further Customization - Prompt Files.

Eclipse Theia

In Eclipse Theia, you can create and use Prompt Fragments to define reusable prompts for recurring development tasks.

Prompt Fragments are Markdown files with a .prompttemplate file extension. They are located either in the .prompts folder in the workspace or in user-wide local directories configured in the settings (AI Features -> Prompt Templates).

In the optional YAML frontmatter header, prompts can be configured as a Slash Command:

• isCommand header needs to be set to true
• commandName header specifies the name of the command
• commandAgents header can be used to limit the visibility of the command to the specified agents.

You can use any available Context Variable in the prompt.

Command arguments passed via chat can be used in the prompt via Argument placeholders $ARGUMENTS or $1, $2, $3 for arguments by position.

The tools that should be used inside the prompt do not need to be preconfigured in the YAML frontmatter and can be referenced in the prompt via ~<tool-name>.

To use a Prompt Fragment in the Chat view, you can use the special variable #prompt:promptFragmentID, for example @Universal #prompt:harley joke about batgirl. When configured as a Slash Command, type / followed by the prompt name, for example @Universal /harley batgirl.

Further information can be found in Getting Started with Theia AI - Further Customization - Prompt Fragments and Getting Started with Theia AI - Further Customization - Slash Commands.

Custom Agents

Custom Agents are a mechanism that allows users to create specialized assistants for specific tasks in the chat. For example, users can create different personas tailored to development roles and tasks such as planning, research, or specialized workflows.

Custom Agents are similar to Visual Studio Code Chat Participants or programmatically contributed Custom Agents in Eclipse Theia. However, instead of contributing them programmatically, users define and configure them through dedicated agent files.

Visual Studio Code

In Visual Studio Code, Custom Agents are configured in custom agent files. Custom Agent Files are Markdown files with a .agent.md extension. They are located either in the .github/agents folder in the workspace or in the user profile folder (interestingly, also in the prompts folder). There is one dedicated .agent.md file for each Custom Agent.

Similar to Prompt Files, Custom Agents can be configured via an optional YAML frontmatter header. You can, for example:

• select the model that should be used when running the agent prompt via the model header
• select the tools or tool sets that can be used by the custom agent via the tools header
• select the agents that are available as subagents in the custom agent via the agents header
• configure handoffs for orchestrating multi-step workflows via the handoffs header

To use a Custom Agent, select it from the agents dropdown in chat and enter a prompt, for example joke about alfred.

Further information can be found in Extending Copilot in Visual Studio Code - Further Customization - Custom Agents.

While the usage of agents in Visual Studio Code and Eclipse Theia is quite similar, Visual Studio Code has some features that are currently not available in Eclipse Theia:

• You can select an Agent type to control where and how an agent runs: local, background, cloud, or third-party.
• There is a distinction between calling a Subagent, which spawns a child agent within a session to handle a subtask in its own isolated context window, and performing a Hand off, which transfers a session from one agent type to another while carrying over the conversation history.

Further information can be found in Using agents in Visual Studio Code.

Eclipse Theia

In Eclipse Theia, multiple Custom Agents are configured in a single custom agent configuration file. The Custom Agent File is a YAML file named customAgents.yml. It is located either in the .prompts folder in the workspace or in user-wide local directories configured in the settings (AI Features -> Prompt Templates).

Because there is only one file for multiple Custom Agents, there is no frontmatter configuration header. Instead, each Custom Agent configuration has its own attributes. In addition to the obvious fields such as id, name, description, and prompt, you need to specify the model via the defaultLLM field.

You can use any available Context Variable in the prompt.

The tools that should be used inside the prompt do not need to be preconfigured in any way. They can be referenced in the prompt via ~<tool-name>.

You can delegate to another agent by using the delegateToAgent Tool Function.

To use a Custom Agent, you need to use the @ syntax in the chat view, just like for any other agent in Theia, e.g. @Joker joke about alfred.

If you use a specific agent most of the time and do not want to type the @ syntax every time, you can configure a default agent via the preference ai-features.chat.defaultChatAgent, for example to use the Universal agent whenever no agent is explicitly mentioned in the chat:

"ai-features.chat.defaultChatAgent": "Universal"

Further information can be found in Getting Started with Theia AI - Further Customization - Custom Agents and Getting Started with Theia AI - Further Customization - Agent-to-Agent Delegation (function).

Agent orchestration

When talking about AI agents, we now often refer to Agentic AI workflows, where multiple agents collaborate to achieve complex goals. When creating Custom Agents, you need to consider collaboration options, especially if you design your agents for dedicated tasks rather than having one agent do everything. This is important because you should keep the context of your agent or prompt as small as possible while still providing enough information to achieve the desired results. Creating agents for dedicated tasks with a limited scope or context is similar to the encapsulation principle in object-oriented programming, and likewise, you need to consider processing or orchestration patterns.

Apart from a Single Agent that does all the work alone, you currently have two options:

• Delegate Pattern
  Create guided sequential workflows that transition between agents. The agents are called one after the other.
• Coordinator and Worker Pattern
  The main/coordinator agent receives the task, delegates subtasks to subagents, and combines the subagent results into the final result.

You can also combine these patterns to have multiple “main” agents that use worker agents for specific tasks. Each “main” agent can delegate to the next “main” agent once it is done, creating a sequential workflow of main tasks.

While the patterns are generally the same, technically there are differences between Visual Studio Code and Eclipse Theia.

Visual Studio Code

The Delegate Pattern is supported via Handoffs when creating Custom Agents in Visual Studio Code. A handoff is configured in the YAML frontmatter header. The user needs to actively proceed with the handoff by clicking a button in the chat UI. The token usage with a handoff is similar to having a single agent that processes all the tasks itself, as the whole context is passed from one agent to the next.

The Coordinator and Worker Pattern is supported through Subagents. To call a subagent, the built-in agent/runSubagent tool needs to be enabled for the coordinator agent. Using a subagent means spawning a child agent within a session to handle a subtask in its own isolated context window. This reduces the token usage, as subagents are not called with the whole context compared to a Handoff.

Each subagent call is sequential (the coordinator waits for that call to return), but the coordinator can spawn multiple subagent calls in parallel.

Further information can be found in AI Agent Orchestration - Visual Studio Code.

Eclipse Theia

Theia does not provide a feature like Handoffs in Visual Studio Code. Instead, Theia provides the built-in Tool Function delegateToAgent to support Agent-to-Agent Delegation, which is comparable to Subagents. Whether you implement the Delegate Pattern or the Coordinator and Worker Pattern depends on how you use the delegateToAgent tool in the prompt.

Using a subagent means spawning a child agent within a session to handle a subtask in its own isolated context window. Because Theia has no Handoff concept that forwards processing to another agent, but only the concept of subagents, you do not see the same token-usage difference there.

Each subagent call via delegateToAgent is sequential (the coordinator waits for that call to return), but the coordinator can spawn multiple subagent calls in parallel.

Further information can be found in AI Agent Orchestration - Eclipse Theia.

Context Monitoring / Token Usage

In Visual Studio Code, it is possible to monitor context window usage. This helps indicate how much context a conversation uses. Theia does not yet support such context-window monitoring, but this feature has been requested via Context window inspection / analysis command.

In Theia, token usage can be inspected via AI Configuration by switching to the Token Usage tab, at least for LLMs that provide usage metadata for a request. Token usage is accumulated within a session, so you do not get the information per request. Token usage is not persisted and is reset when restarting the application. Visual Studio Code does not support tracking token usage at that level.

Agent Skills

Agent Skills is a simple, open format for giving agents new capabilities and expertise. Basically, a skill is a folder containing a SKILL.md file that includes metadata in the form of a YAML frontmatter header and instructions that tell an agent how to perform a specific task. It can also contain subfolders with scripts, templates, and referenced materials. Because it is an open format, it is supported in various AI tools.

Agent Skills are a fairly new format, and both Visual Studio Code and Eclipse Theia support it, although in Eclipse Theia the feature is still in alpha. There are some differences in where skills are stored and how they are used, which I list in the following sections. If you are interested in examples, have a look at awesome-agent-skills.

Visual Studio Code

• The location of the skills folder for a project in your repository is .github/skills/, .claude/skills/ or .agents/skills/.
• The location for personal skills in the user home is ~/.copilot/skills/, ~/.claude/skills/ or ~/.agents/skills/.
• You can configure additional locations for skills via the chat.agentSkillsLocations setting to share skills across projects or keep them in a central location.
• You can use skills directly in the chat via a slash command. For example, if you created a skill with the name webapp-testing, you can use it directly in the chat via /webapp-testing for the login page.
• Copilot discovers the skills to use automatically by matching the user prompt with the skill description. Only the body of a matching skill will be loaded into the context. Additional resources will only be added if they are referenced in the instructions.
• You can create a new skill manually by creating the required folder and a SKILL.md file in that folder
• You can create a new skill with the help of AI by using the /create-skill slash command in the chat
• You can use the Chat Customizations dialog by clicking the gear icon in the upper-right corner of the Copilot chat window, select the Skills menu item on the left side and select an option to generate a skill via the dropdown on the upper right corner to guide you through the initial creation.

  

  

You can learn more about the use of Agent Skills in Visual Studio Code in Use Agent Skills in VS Code and Extending Copilot in Visual Studio Code - Further Customization - Agent Skills.

Eclipse Theia

Support for Agent Skills in Eclipse Theia is still in alpha and currently has known limitations. For example, in Theia 1.70.0, automatic skill discovery is not working reliably. Automatic execution and tool calls can also fail. These issues are likely to improve in upcoming releases.

• The location of the skills folder for a project in your repository is .prompts/skills/.
• The location for personal skills in the user home is ~/.theia/skills/.
• You can configure additional locations for skills via the ai-features.skills.skillDirectories setting to share skills across projects or keep them in a central location.
• You can use skills directly in the chat as a slash command. For example, if you created a skill with the name webapp-testing, you can use it directly in the chat via /webapp-testing for the login page.
• You can enable agents to load skills on demand by using the `` variable in an agent’s prompt to list all available skills, and use the ~getSkillFileContent function to load a selected skill on demand.
• You can create a new skill manually by creating the required folder and a SKILL.md file in that folder
• You can create a new skill with the help of AI by using the built-in @CreateSkill agent in the chat
• There is a Skills and Slash Commands View available via the AI Configuration via the Skills tab, which provides a convenient overview of the discovered skills and a button to directly open the corresponding SKILL.md file in an editor.

  

You can learn more about the use of Agent Skills in Eclipse Theia via Agent Skills (Alpha) and Getting Started with Theia AI - Further Customization - Agent Skills.

Conclusion

As you can see, the AI capabilities of Visual Studio Code GitHub Copilot and Eclipse Theia AI are very similar. Both ecosystems evolve quickly, and while writing this post, I had to update findings and screenshots several times to keep it current.

At a high level, both platforms support the same core building blocks: tools, MCP integration, custom agents, reusable prompts, and skills. The main differences are in product strategy and developer control:

• Visual Studio Code with GitHub Copilot gives you a polished product with strong built-in workflows and broad adoption.
• Eclipse Theia gives you an open platform you can own and shape deeply for your own product and domain.

From a practical perspective, your choice usually depends less on feature checklists and more on your goals:

• Choose Visual Studio Code GitHub Copilot if you want fast adoption, familiar UX, and minimal platform-level ownership.
• Choose Eclipse Theia if you need full control, deeper integration into your own application, and an open customization model.

It is also worth noting that AI customization now offers multiple overlapping mechanisms for similar outcomes. Deciding whether to use a Custom Agent, a Prompt File/Fragment, or an Agent Skill is not always straightforward and often depends on scope, reuse, and ownership.

If you want to dive deeper into that topic, there is a valuable discussion in the Theia repository: Agent vs PromptTemplate vs Skill. The response by Jonas Helming provides useful guidance on how these mechanisms differ and when each is a good fit.

In short: both platforms are strong, modern foundations for AI-assisted development. If you optimize for ready-to-use productivity, Visual Studio Code is a strong choice. If you optimize for extensibility and product ownership, Eclipse Theia is compelling.