Coding Agents and IDEs

Overview

Coding agents are AI‑driven assistants that can turn natural‑language prompts, comments, or partial snippets into fully‑formed, context‑aware code and can be run via a terminal, embedded directly inside an IDE or editor. They can also perform tasks such as autocompleting a line, generating whole functions, writing unit tests, debugging and running code—all by querying a large language model (LLM) behind the scenes. ARC’s hosted LLMs are compatible with many modern IDEs and AI coding agents that support OpenAI-compatible APIs. There are many IDEs available, and their AI integration features evolve frequently. ARC focuses on providing guidance specific to connecting to ARC resources. In general, connecting an IDE-based AI assistant (coding agent) to ARC’s LLM service follows this process:

  1. Install and enable the IDE’s AI or LLM integration plugin (extension)

  2. Obtain an ARC API key from https://llm-api.arc.vt.edu

  3. Configure the AI assistant (coding agent) to use an OpenAI-compatible endpoint

  • API URL: https://llm-api.arc.vt.edu/api/v1/chat/completions

  • Provide your private ARC API key

  • Select the appropriate ARC-hosted model (e.g., Kimi-K2.6, gpt-oss-120b)

  • Configure model capabilities (tool calling, vision, thinking) if supported

  • Set token limits as appropriate (e.g., 65536 input / 65536 output)

You can use some of the most widely used coding agents with ARC’s hosted LLMs through pointing them to ARC’s API endpoint. In this page, we provide instructions to connect OpenCode, Claude Code, Github Copilot, and IntelliJ IDEA to ARC’s LLMs.

Caution

Be very careful letting AI agents run commands on their own if you are connecting to ARC. We do not approve commands that are potentially destructive, could access data owned by other users, or could otherwise be harmful to our systems.

OpenCode

OpenCode is an open source agent that helps you write code in your terminal, IDE, or desktop. You can use OpenCode on your local machine and then connect to ARC LLMs with the following workflow.

First, you have to download OpenCode on your local machine. This example is using curl to download OpenCode in your terminal:

# Download and install in user space
curl -fsSL https://opencode.ai/install | bash

# Reload bashrc (or bash_profile for macOS) so that PATH includes the local opencode path
source ~/.bashrc

Second, you need to create a opencode.jsonc file. Please run the following command in your terminal to create a file with the required contents:

mkdir -p "$HOME/.config/opencode"
cat <<'EOF' > "$HOME/.config/opencode/opencode.jsonc"
{
  "$schema": "https://opencode.ai/config.json",
  "disabled_providers": [],
  "provider": {
    "ARC": {
      "name": "ARC",
      "npm": "@ai-sdk/openai-compatible",
      "models": {
        "gpt-oss-120b": {
          "name": "gpt-oss-120b"
        },
        "Kimi-K2.6": {
          "name": "Kimi K2.6"
        },
        "MiniMax-M2.7": {
          "name": "MiniMax-M2.7"
        },
      },
      "options": {
        "baseURL": "https://llm-api.arc.vt.edu/api/v1",
        "apiKey": "sk-XXXXXXXXXXXXXXXXXX",
      }
    }
  },
  "model": "ARC/gpt-oss-120b",
}
EOF

You will have to edit this file to replace the apiKey with your personal API Key and specify which model you would like to use.

Once you have downloaded OpenCode and create/edited the .jsonc file, you can run OpenCode with the following:

opencode

OpenCode Desktop

You can download the OpenCode Desktop application and connect this to ARC’s LLMs with the following steps.

Download application from https://opencode.ai/download Open up the application and navigate to Settings -> Providers -> Custom provider

You will then edit the Custom provider with the following, replacing the API key with your own API key:

Provider ID: arc
Display Name: ARC
Base URL: https://llm-api.arc.vt.edu/api/v1
API key: sk-XXXXXXXXXXXXXXXXXX
models: gpt-oss-120b, Kimi-K2.6, MiniMax-M2.7

Claude Code

Claude Code is an AI-powered coding assistant that can read your codebase, edit files, run commands, fix bugs, and automate development tasks. Both the Terminal CLI and VS Code extension versions can be used to connect to ARC’s LLMs. You can run the CLI agent inside VS Code’s integrated terminal, first you need to install it as follow:

  • macOS / Linux / WSL:

curl -fsSL https://claude.ai/install.sh | bash

  • Windows (PowerShell):

irm https://claude.ai/install.ps1 | iex

Then you may connect your local Claude Code agent to ARC’s LLMs through the Open WebUI proxy by running the following:

export ANTHROPIC_BASE_URL="https://llm-api.arc.vt.edu/api/"
export ANTHROPIC_API_KEY="YOUR_OPEN_WEBUI_API_KEY"
claude --model Kimi-K2.6

This is an example using Claude Code with ARC’s Kimi-K2.6 model.

Checklist for Privacy:

  • Use an API Key: This is the safest way to ensure your code is never used for training.

  • Check your .zshrc: Ensure your ANTHROPIC_API_KEY is set correctly.

  • Add a .claudeignore file: Similar to .gitignore, you can create this file in your project root to tell Claude to never read specific files (like secrets.json or .env).

  • Run /permissions: Type this inside Claude Code to see exactly what the agent is allowed to do and see on your disk.

GitHub Copilot

GitHub Copilot Chat](https://github.com/microsoft/vscode-copilot-chat) is a companion extension for VS Code that provides conversational AI assistance. You can also ask coding-related questions, such as how best to code something, how to fix a bug, or how someone else’s code works. It adapts to your unique needs allowing you to customize chat responses with custom instructions, and utilize agent mode for AI-powered, seamlessly integrated peer programming sessions.

You may use your https://llm-api.arc.vt.edu API key to connect GitHub Copilot Chat for VS Code with ARC’s hosted LLMs.

The following instructions are based on VS code’s GitHub Copilot instructions to use an OpenAI-compatible model.

Note

Configuring a custom OpenAI-compatible model is currently only available in VS Code Insiders as of release 1.104.

First, install the GitHub Copilot Chat extension for VS Code.

The custom OpenAI provider enables you use any OpenAI-compatible API endpoint and configure the models for use in chat.

To configure a custom OpenAI endpoint and model:

  1. Run the Chat: Manage Language Models command from the Command Palette.

  2. Select the gear icon next to the OpenAI Compatible provider.

  1. Select Manage API Key to set your unique API key for https://llm-api.arc.vt.edu.

  2. Select Configure Models > Add New Model and follow the prompts to add the details for your model:

    • Unique identifier for the model: Kimi-K2.5, MiniMax-M2.7, or gpt-oss-120b

    • Display name for the model in the language model picker

    • Full API endpoint URL: https://llm-api.arc.vt.edu/api/v1/chat/completions

    • Select the model capabilities, such as tool calling, vision, thinking

    • Maximum input and output token limits: e.g 65536 input tokens and 65536 output tokens

Alternatively, you can manually add your custom model configuration in the github.copilot.chat.customOAIModels setting. For example:

{
   "github.copilot.chat.customOAIModels": {
       "gpt-oss-120b": {
           "name": "gpt-oss-120b",
           "url": "https://llm-api.arc.vt.edu/api/v1/chat/completions",
           "toolCalling": true,
           "vision": false,
           "thinking": true,
           "maxInputTokens": 65536,
           "maxOutputTokens": 65536,
           "requiresAPIKey": true
       }
   },
   "security.workspace.trust.untrustedFiles": "open"
}

Agent

GitHub Copilot’s Chat agent provides an intuitive way for developers to interact directly with a LLM right inside their coding environment. Instead of manually writing or refactoring code, users can simply describe in natural language what they want such as generating new functions, optimizing existing code, adding documentation, or translating logic into another language, and Copilot will respond with context-aware suggestions tailored to the current project. By understanding the surrounding codebase, dependencies, and even comments, the Chat agent acts like an intelligent coding partner, streamlining development workflows and enabling rapid prototyping, learning, and iteration without ever leaving the editor.

IntelliJ IDEA

  1. Make sure IntelliJ is up to date (v.2025.3.2 or newer) and activate the native AI Plugin

  2. Set the AI assistant plugin as follows

  1. Activate the AI chat interface and enter your prompts