GitHub Copilot is GitHub's AI coding assistant. It provides access to Copilot models for your GitHub account and plan. Genesis can use Copilot as a model provider in two different ways.

Two ways to use Copilot in Genesis

Built-in provider (github-copilot)

Use the native device-login flow to obtain a GitHub token, then exchange it for
Copilot API tokens when Genesis runs. This is the **default** and simplest path
because it does not require VS Code.

Run the login command

    ```bash
    genesis models auth login-github-copilot
    ```

    You will be prompted to visit a URL and enter a one-time code. Keep the
    terminal open until it completes.

Set a default model

    ```bash
    genesis models set github-copilot/claude-opus-4.7
    ```

    Or in config:

    ```json5
    {
      agents: {
        defaults: { model: { primary: "github-copilot/claude-opus-4.7" } },
      },
    }
    ```

Copilot Proxy plugin (copilot-proxy)

Use the **Copilot Proxy** VS Code extension as a local bridge. Genesis talks to
the proxy's `/v1` endpoint and uses the model list you configure there.

<div class="callout note">
Choose this when you already run Copilot Proxy in VS Code or need to route
through it. You must enable the plugin and keep the VS Code extension running.
</div>

Optional flags

# Skip confirmation
genesis models auth login-github-copilot --yes

# Login and set the default model in one step
genesis models auth login --provider github-copilot --method device --set-default

Interactive TTY required

The device-login flow requires an interactive TTY. Run it directly in a
terminal, not in a non-interactive script or CI pipeline.

Model availability depends on your plan

Copilot model availability depends on your GitHub plan. If a model is
rejected, try another ID (for example `github-copilot/gpt-4.1`).

Transport selection

Claude model IDs use the Anthropic Messages transport automatically. GPT,
o-series, and Gemini models keep the OpenAI Responses transport. Genesis
selects the correct transport based on the model ref.

Request compatibility

Genesis sends Copilot IDE-style request headers on Copilot transports,
including built-in compaction, tool-result, and image follow-up turns. It
does not enable provider-level Responses continuation for Copilot unless
that behavior has been verified against Copilot's API.

Environment variable resolution order

Genesis resolves Copilot auth from environment variables in the following
priority order:

| Priority | Variable              | Notes                            |
| -------- | --------------------- | -------------------------------- |
| 1        | `COPILOT_GITHUB_TOKEN` | Highest priority, Copilot-specific |
| 2        | `GH_TOKEN`            | GitHub CLI token (fallback)      |
| 3        | `GITHUB_TOKEN`        | Standard GitHub token (lowest)   |

When multiple variables are set, Genesis uses the highest-priority one.
The device-login flow (`genesis models auth login-github-copilot`) stores
its token in the auth profile store and takes precedence over all environment
variables.

Token storage

The login stores a GitHub token in the auth profile store and exchanges it
for a Copilot API token when Genesis runs. You do not need to manage the
token manually.

Memory search embeddings

GitHub Copilot can also serve as an embedding provider for memory search. If you have a Copilot subscription and have logged in, Genesis can use it for embeddings without a separate API key.

Auto-detection

When memorySearch.provider is "auto" (the default), GitHub Copilot is tried at priority 15 -- after local embeddings but before OpenAI and other paid providers. If a GitHub token is available, Genesis discovers available embedding models from the Copilot API and picks the best one automatically.

Explicit config

{
  agents: {
    defaults: {
      memorySearch: {
        provider: "github-copilot",
        // Optional: override the auto-discovered model
        model: "text-embedding-3-small",
      },
    },
  },
}

How it works

1. Genesis resolves your GitHub token (from env vars or auth profile).
2. Exchanges it for a short-lived Copilot API token.
3. Queries the Copilot /models endpoint to discover available embedding models.
4. Picks the best model (prefers text-embedding-3-small).
5. Sends embedding requests to the Copilot /embeddings endpoint.

Model availability depends on your GitHub plan. If no embedding models are available, Genesis skips Copilot and tries the next provider.

Related

• Model selection Choosing providers, model refs, and failover behavior.

• OAuth and auth Auth details and credential reuse rules.