# Connect GitHub Copilot

URL: https://getvando.com/docs/connect-an-ai/github-copilot

Connect GitHub Copilot to the Vando app on your phone, so it gets a secret only after you tap Give, and keys stay out of your .env files and chats.

Copilot’s agent in VS Code, the Copilot CLI and the cloud agent. Last checked 2026-11-10, against GitHub Copilot’s own documentation (the links at the end). If a step doesn’t match what you see, [tell us](https://getvando.com/support). For Claude Code, [Connect an AI](https://getvando.com/docs/connect-an-ai) is the same road.

## The steps every tool shares

**1.** Install `vando` in your own terminal (not through your AI tool):

```bash
npm i -g @getvando/cli --registry=https://registry.npmjs.org --@getvando:registry=https://registry.npmjs.org
```

No npm on this computer? The one-line installer gets the same signed vando:

```bash
curl -fsSL https://getvando.com/install.sh | sh
```

**2.** Connect it to your phone. It shows a code that works once, for 10 minutes; open Vando on your phone, then **Connect an AI**, enter the code and tap **Connect**. Run `vando connect` again to finish. Do this in your own terminal: it writes the connection’s key on this computer, and many sandboxes block that.

```bash
vando connect
```

**3.** Save a secret once. Without a terminal it opens a one-time page in your own browser; you paste the value there and it goes to your phone, locked so only the phone can open it. Tap Save on the phone. Or add it in the Vando app.

```bash
vando add STRIPE_KEY
```

**4.** Your tool runs a command with it. Your phone shows what is asked and for how long; you give it or deny it there, and the value goes into that one program’s environment, as the variable `STRIPE_KEY`.

```bash
vando run --secret STRIPE_KEY -- node send.js
```

A `.env` line can name a secret instead of holding it, and `vando run` fills it in when the program starts:

```text
STRIPE_KEY=vando://Work/acme/dev/STRIPE_KEY
```

**5.** Tell your tool how to ask: put this note in its instructions file (the file is named below):

```md
## Secrets (Vando)
- Never open, print, copy or edit `.env*` files or secret values, and never put a secret in chat.
- Run anything that needs a secret as `vando run --secret NAME -- <command>` (repeat `--secret` for more than one).
- Exit 75 means it is waiting for the owner's phone: say "Approve NAME on your phone, then I'll run it again", do other work, then run the same command again. After two waits, stop and tell the owner to open Vando on their phone (the request is in the Inbox).
- Exit 77 means the owner said no or the access ended: don't retry; ask the owner.
- Output that shows `[vando:NAME]` had a secret hidden; that is expected.
- Don't use `vando get` or `vando env --reveal`: they print values where you can read them. `vando env` (names only) is fine.
- Never enter a connect code yourself.
```

## What differs for GitHub Copilot

### The instructions file

Put the note from step 5 in `AGENTS.md` in the repository root: VS Code, the Copilot CLI and the cloud agent all read it (or `.github/copilot-instructions.md` for Copilot only).

**Every project:** `~/.copilot/copilot-instructions.md` is read by VS Code’s Copilot agent and the Copilot CLI; applicable files are combined, with no precedence rule. The note to put there: [Use Vando in every project](https://getvando.com/docs/connect-an-ai/every-project).

### Approvals and the sandbox

In VS Code the terminal approval setting is `chat.tools.terminal.autoApprove`. To skip VS Code’s prompt for `vando run` (your phone still asks):

```json
"chat.tools.terminal.autoApprove": { "/^vando run\\b/": true }
```

Copilot checks each part of a compound command, so the program after `--` must be approved too. In the Copilot CLI the flag is `--allow-tool='shell(vando run)'`; the CLI’s docs show only `git` examples, so check the form with `copilot` first. Neither sandbox is on by default. If you turn on VS Code’s agent sandbox, add Vando’s server (the address `vando` names in its blocked message) to `chat.agent.sandbox.network.allowedDomains`. If you turn on the Copilot CLI sandbox on a Mac, the keychain is off unless `sandbox.userPolicy.seatbelt.keychainAccess` is `true`. Run `vando connect` in your own terminal either way.

### MCP tools (optional)

Most work goes through `vando run`, which keeps secrets out of the chat. Add the tools only when GitHub Copilot must read a value itself; a value a tool returns stays in the conversation ([the tools](https://getvando.com/docs/reference/mcp)). Add the server to the Copilot CLI: `copilot mcp add vando -- vando mcp` (writes `~/.copilot/mcp-config.json`); VS Code’s Copilot agent reads the same file or a `.mcp.json` in the workspace root:

```json
{ "mcpServers": { "vando": { "type": "local", "command": "vando", "args": ["mcp"], "tools": ["*"] } } }
```

VS Code’s older “Local” agent reads `.vscode/mcp.json` instead, with `servers` as the top-level key and `"type": "stdio"`. MCP servers started by the Copilot CLI inherit only `PATH`.

### Cloud and remote sessions

The Copilot cloud agent (formerly the coding agent) runs in its own environment with a firewall that is on by default. You can install `vando` in `.github/workflows/copilot-setup-steps.yml` and allow Vando’s server under the repository’s Copilot settings, Internet access, Custom allowlist (setup steps aren’t behind the firewall). The agent works unattended and each session starts clean, so a connect would need someone to read the code from the live session log. Cloud MCP tools run without asking, so the phone is the only gate. Don’t move a Vando connection key into the agent’s secrets. Use Vando with VS Code or the Copilot CLI on a computer you sit at.

### If something goes wrong

- In VS Code the agent may not load your shell profile, so an nvm- or volta-installed `vando` can be missing from `PATH`; use the full path in the MCP `command`.
- VS Code picks its own terminal timeout, so a phone wait may return early with partial output; the rules note’s “exit 75: run it again” covers that.
- If `vando` ever prompts for input, VS Code’s agent may hang (auto-reply to prompts is off by default).
- The CLI’s shell timeout and how it captures a long wait aren’t documented.
- Run `vando doctor` in your own terminal: it says what is wrong and the command that fixes it.
- If a `vando` command stops, relay what it says; the line ends with a link to [the errors reference](https://getvando.com/docs/reference/errors).

## Sources

What this page is written from:

- [VS Code: custom instructions](https://code.visualstudio.com/docs/copilot/customization/custom-instructions)
- [VS Code: MCP configuration](https://code.visualstudio.com/docs/agents/reference/mcp-configuration)
- [VS Code: approvals](https://code.visualstudio.com/docs/agents/run/approvals)
- [Copilot CLI: MCP servers](https://docs.github.com/en/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers)
- [Copilot CLI: allowing tools](https://docs.github.com/en/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools)
- [Copilot cloud agent: customize the environment](https://docs.github.com/en/copilot/how-tos/copilot-on-github/customize-copilot/customize-cloud-agent/customize-the-agent-environment)
