# Connect your IDE Send chat and agent requests from GitHub Copilot Chat, JetBrains AI Assistant or Continue through the ATLAS gateway. ATLAS audits and budgets the requests, and limits them to the models your space or project offers. You don't need Admin rights. ## Supported tools | Tool | Where | | ------------------------------------------------------------------------------------------------- | ------------------------ | | [GitHub Copilot Chat](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#use-atlas-models-in-github-copilot-chat-in-vs-code) | VS Code | | [GitHub Copilot Chat](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#use-atlas-models-in-github-copilot-chat-in-jetbrains-ides) and Copilot CLI | JetBrains IDEs, terminal | | [JetBrains AI Assistant](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#use-atlas-models-in-jetbrains-ai-assistant) | JetBrains IDEs | | [Continue](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#use-atlas-models-in-continue) | VS Code, JetBrains IDEs | If a tool isn't listed, see [What does not work](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#what-does-not-work). ## Before you begin - You need an ATLAS API key with an acting context (a space or project). See [Create and manage your API keys](https://docs.atlas.ilionx.dev/guides/user/api-keys-create-and-manage.md). - You need at least one model in that acting context. For agent mode, choose a model that supports tool calling and is not a reasoning model. Some reasoning models reject tool calls on the Chat Completions API. - You need your ATLAS address. Replace `https://` with it throughout. - Wherever a snippet shows `` or ``, replace it with your ATLAS API key or a model id such as `openai/gpt-4.1`. Keep the rest of the line as it is. - Check the key and a model from a terminal first, using the [connection settings and test requests](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-openai-and-anthropic-clients.md#connection-settings). Every set-up on this page uses the base URL `https:///gateway/openai/v1` and your ATLAS API key. Use model ids in the form `provider-slug/model-slug`, exactly as the `/models` request lists them. Where a tool offers a choice, choose the **Chat Completions** API type. ## Use ATLAS models in GitHub Copilot Chat in VS Code VS Code connects ATLAS as a **Custom Endpoint** provider. Copilot's chat client is the only supported entry point. The models come from ATLAS, not from your Copilot licence. 1. In the Chat view, open the model picker and select **Manage Language Models**, or run **Chat: Manage Language Models** from the Command Palette. 2. Select **Add Models**, then **Custom Endpoint**. 3. Enter a group name such as `ATLAS` and paste your ATLAS API key when prompted. 4. Select the API type **Chat Completions**. 5. In the `chatLanguageModels.json` file that opens, describe your ATLAS models and save: ```json [ { "name": "ATLAS", "vendor": "customendpoint", "apiKey": "${input:atlasApiKey}", "apiType": "chat-completions", "models": [ { "id": "", "name": "ATLAS ", "url": "https:///gateway/openai/v1/chat/completions", "toolCalling": true, "vision": false, "maxInputTokens": 128000, "maxOutputTokens": 4096 } ] } ] ``` Use the full chat URL including `/chat/completions`. Set `toolCalling` to `true` only for models that support it. VS Code hides models without it in agent mode. 6. Select the ATLAS model in the model picker and send a message in **Ask** mode, then switch to **Agent** mode. If the model doesn't appear, restart VS Code. In Copilot Business or Enterprise, a GitHub organisation owner must turn on the **Bring Your Own Language Model Key in VS Code** policy on GitHub.com. Inline suggestions, next edit suggestions, semantic search and anything based on embeddings always use the GitHub Copilot service and never reach ATLAS. Background tasks such as chat titles and commit messages use a Copilot model. To use an ATLAS model instead, point the `chat.utilityModel` and `chat.utilitySmallModel` settings at it. Vendor documentation: [VS Code, AI language models](https://code.visualstudio.com/docs/copilot/customization/language-models). ## Use ATLAS models in GitHub Copilot Chat in JetBrains IDEs The GitHub Copilot plugin supports a custom OpenAI-compatible provider. You need a recent plugin version and a Copilot licence. 1. Open Copilot Chat and, in the model picker, select **Manage Models**. 2. Add a custom provider that is OpenAI-compatible. 3. Enter the **Base URL** `https:///gateway/openai/v1` and your ATLAS API key. 4. Add the model ids exactly as `/models` lists them, and set the maximum input and output tokens. 5. Turn on the models and pick one in the chat model picker. 6. Send a message in **Ask** mode, then switch to **Agent** mode. Field names may differ between plugin versions. Use a model that works on Chat Completions. To use Copilot CLI with ATLAS, set these variables in a terminal and run `copilot`. The model must support tool calling and streaming. Replace `` and `` as described in [Before you begin](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-your-ide.md#before-you-begin). ```bash export COPILOT_PROVIDER_BASE_URL=https:///gateway/openai/v1 export COPILOT_PROVIDER_TYPE=openai export COPILOT_PROVIDER_API_KEY= export COPILOT_MODEL= ``` As in VS Code, inline suggestions, next edit suggestions and embedding-based features stay on the GitHub Copilot service. Vendor documentation: [GitHub Copilot plugin](https://plugins.jetbrains.com/plugin/17718-github-copilot), [Bring your own key](https://docs.github.com/en/copilot/concepts/models/bring-your-own-key) and [BYOK in Copilot CLI](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/use-byok-models). ## Use ATLAS models in JetBrains AI Assistant 1. Open **Settings | Tools | AI Assistant | Providers & API keys**. 2. Under **Third-party AI providers**, select **OpenAI-compatible**. 3. Enter the **URL** `https:///gateway/openai/v1` and your ATLAS API key as the **API Key**. 4. Turn on **Tool calling** if your model supports it. 5. Select **Test Connection**, then **Apply**. 6. In **Models Assignment**, assign ATLAS models such as `openai/gpt-4.1` to **Core features** and **Instant helpers**. 7. Open **AI Chat**, choose the ATLAS model and send a message. Then try agent mode. Third-party chat providers don't power code completion or next edit suggestions. Completion through a custom provider needs a fill-in-the-middle endpoint, which ATLAS doesn't offer. Vendor documentation: [JetBrains, Use custom models](https://www.jetbrains.com/help/ai-assistant/use-custom-models.html). ## Use ATLAS models in Continue Continue runs in VS Code and JetBrains IDEs. 1. Install the Continue extension or plugin. 2. Open the Continue `config.yaml` from the Continue panel settings. 3. Add an ATLAS model: ```yaml name: ATLAS version: 1.0.0 schema: v1 models: - name: ATLAS provider: openai model: apiBase: https:///gateway/openai/v1 apiKey: useResponsesApi: false roles: - chat - edit - apply capabilities: - tool_use ``` `useResponsesApi: false` keeps Continue on Chat Completions. Agent mode needs `tool_use`, so keep it only for models that support tool calling. 4. Select the ATLAS model in the Continue panel, send a message in **Chat**, then switch to **Agent**. Don't add the `autocomplete` role. It needs a fill-in-the-middle endpoint, which ATLAS doesn't offer. The `embed` role can work if an embedding-capable model (not Anthropic) is configured in ATLAS. Vendor documentation: [Continue, OpenAI provider](https://docs.continue.dev/customize/model-providers/top-level/openai). **Result:** the ATLAS models appear in your IDE's model picker, and each chat or agent request shows in **My usage** under your key's acting context. ## What ATLAS sees ATLAS audits and budgets only the requests sent to your ATLAS models. It can't see anything a tool keeps on its vendor's service. For more information, see [Gateway concepts](https://docs.atlas.ilionx.dev/concepts/gateway.md). ## What does not work - **Claude Code** works through a separate endpoint. See [Connect Claude Code and opencode](https://docs.atlas.ilionx.dev/guides/user/api-keys-connect-your-tools.md). - **OpenAI Codex CLI** isn't covered here. It needs the Responses API rather than Chat Completions. - **Gemini CLI** needs Google's native Gemini API, which the gateway doesn't offer. - **Autocomplete in any tool** needs a legacy completions endpoint, which the gateway doesn't offer. - **GitHub Copilot's own models as an ATLAS provider** aren't possible. Ask an Admin to add models of the same families through an OpenAI, Azure OpenAI or Anthropic provider instead. ## Troubleshooting Errors from your IDE are gateway errors. See the [troubleshooting table](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-openai-and-anthropic-clients.md#troubleshooting). Two points are specific to IDEs: - If the tool lists no models, add the model id manually after you confirm it with the `/models` request. - If agent mode fails with a provider `400` about function tools, switch to a model that supports tool calling and is not a reasoning model. ## Related - [Connect an OpenAI- or Anthropic-compatible client](https://docs.atlas.ilionx.dev/guides/user/gateway-connect-openai-and-anthropic-clients.md) - [Connect Claude Code and opencode](https://docs.atlas.ilionx.dev/guides/user/api-keys-connect-your-tools.md) - [Create and manage your API keys](https://docs.atlas.ilionx.dev/guides/user/api-keys-create-and-manage.md) - [Gateway reference](https://docs.atlas.ilionx.dev/reference/gateway.md)