Use GitHub Copilot as an AI Agent Backend (No Extra API Costs)

1. The API Cost Problem for AI Agents

AI agents are not like chatbots. A chatbot has one exchange per user interaction. An agent running a workflow makes dozens of API calls per task: reading the screen, planning the next step, executing an action, verifying the result, handling errors. Each step is a round trip to an LLM.

For browser automation, document processing, or CRM updates, a single session can burn through hundreds of thousands of tokens. At standard Anthropic API pricing, a developer running agents throughout the workday can easily spend $50 to $200 per month just in inference costs - before any other tooling.

For teams, this multiplies. Ten developers each running agents at moderate intensity can push monthly API bills into four figures. That math gets uncomfortable fast, especially for teams that already pay for GitHub Copilot Business or have access to enterprise AI infrastructure.

2. How Proxy and Gateway Approaches Work

The key insight is that an AI agent does not care which LLM it talks to. It cares about getting a valid response in the format it expects. If you can run something in the middle that translates between protocols, the agent works identically regardless of what is on the other end.

A proxy sits between the agent and the LLM provider:

1. Agent sends a request in Anthropic format tolocalhost:PORT
2. Proxy receives the request, translates it to the target provider's format (Copilot, OpenAI, Bedrock, etc.)
3. Proxy forwards to the real API, receives the response, translates it back to Anthropic format
4. Agent receives a response that looks exactly like what it would get from the real Anthropic API

This pattern is not new. LiteLLM has been doing it across dozens of providers for years. What is newer is that AI agents started being built with configurable base URLs, making it trivial to point them at any compatible endpoint without code changes.

3. ANTHROPIC_BASE_URL and Custom Endpoints

The standard way to redirect Anthropic API traffic is theANTHROPIC_BASE_URLenvironment variable. When set, the Anthropic SDK sends all requests to that URL instead ofhttps://api.anthropic.com.

# Point the agent at a local proxy
export ANTHROPIC_BASE_URL=http://localhost:8080

# Or a corporate gateway
export ANTHROPIC_BASE_URL=https://ai-gateway.yourcompany.com

# Or a specific regional endpoint
export ANTHROPIC_BASE_URL=https://bedrock-proxy.us-east-1.example.com

Applications that use the official Anthropic SDK pick this up automatically. No code changes needed. The SDK just sends requests to the configured URL and expects responses in the same format.

For desktop AI agent apps, many now expose this as a UI setting rather than requiring an environment variable. You fill in a base URL field in preferences, and the app handles the rest. This makes the feature accessible to users who are not comfortable with terminal configuration.

4. GitHub Copilot as an AI Agent Backend

GitHub Copilot Business ($19/seat/month) includes access to Claude and GPT-4o through the Copilot API. This capacity is included in your seat license - you are already paying for it whether you use it for agents or not.

A developer on a community forum described exactly this setup: they built a lightweight local proxy in Node.js that accepted requests in Anthropic format, translated them to Copilot API calls using their GitHub token, and returned the response. They pointed their AI agent at it via a custom base URL setting. The agent ran normally. No separate API bill. The proxy code was around 150 lines.

The community response was strong enough that it became an official consideration: AI agent tools that had previously hardcoded the Anthropic endpoint started adding custom base URL settings specifically to support this pattern.

How to set up a Copilot proxy

1. Get your GitHub token. You need a token with Copilot API access. For Copilot Business, this is your standard GitHub personal access token with thecopilot scope.
2. Run a translation proxy. Several open source projects implement this. Search for "copilot to anthropic proxy" on GitHub. Alternatively, LiteLLM supports Copilot as a backend and handles the translation automatically.
3. Configure your agent. Set the base URL to your proxy address (typicallyhttp://localhost:4000for LiteLLM). Set any required API key to your GitHub token or a placeholder, depending on how the proxy handles auth.
4. Verify the connection. Run a simple test task to confirm requests are flowing through the proxy to Copilot. Check the proxy logs to see the traffic.

5. Other Compatible Gateways

GitHub Copilot is one option, but the same pattern applies to anything that speaks Anthropic format (or can translate to it):

6. Setting Up a Custom Endpoint in Desktop AI Agents

How you configure a custom endpoint depends on the agent. There are three common patterns:

ANTHROPIC_BASE_URL=http://localhost:4000 ./your-agent

Fazm, for example, includes a dedicated field for custom API endpoints in its settings panel. You enter the base URL for your proxy or gateway, and all inference calls go through it. The feature was added specifically because users were running the Copilot proxy pattern and wanted a clean way to configure it without environment variables.

Once configured, there is nothing else to change. The agent uses the same tool calls, the same automation logic, and the same interaction patterns - it just routes through your chosen backend instead of the default Anthropic API.

7. Cost Comparison

Here is a rough breakdown for a single developer running an AI desktop agent at moderate intensity: approximately 500 API calls per day across browser automation, document work, and coding tasks.

For most individual developers, the Copilot proxy delivers the best cost-to-effort ratio if you already have a seat. The model quality is solid - Copilot Business gives you access to Claude and GPT-4o, which are the same models you would be using through the direct API.

For teams or regulated environments, Bedrock or a corporate LiteLLM deployment is a more defensible choice. The cost savings are smaller than the Copilot approach, but you get proper audit trails, data residency controls, and enterprise support.

OpenRouter is worth considering if you want flexibility without running your own proxy. The single endpoint approach means you can route cheap tasks to cheaper models and expensive reasoning to frontier models, with no infrastructure to maintain.