Claude Desktop Model Swap: OpenRouter, Foundry, and Local Models

As of April 27, 2026, Anthropic ships:

• Claude Web (claude.ai or claude.com) — browser-based, Claude models only
• Claude Code — integrated into VSCode/cursor/web, Claude models only
• Claude Cowork — collaboration product, Claude models only
• APIs (platform.claude.com) — direct API access, Claude models only

There is no official Claude Desktop application with a settings panel for "swap to OpenRouter" or "use local Ollama." Any guide claiming otherwise is fabricating a feature.

Why this matters: If you want to build or deploy using alternative models while keeping a Claude-like interface or tooling experience, you must go through third-party software or proxy layers. Anthropic does not officially support this; it works, but it's unsupported.

Three reasons this request appears frequently:

1. Cost arbitrage — OpenRouter pricing for some models (especially open-weight) is significantly cheaper than direct API
2. Local control — Self-hosted models never leave your infrastructure; compliance and data residency requirements demand this
3. Experimentation — Testing K2.6, Grok 4.3, or smaller models on your workflow without rewriting code
4. Fallback resilience — Route to backup providers if primary goes down

The Claude ecosystem does not natively support any of these, so the workarounds below are the actual options.

| Path | Tool | Supports OpenRouter | Supports Local Models | Free | Best For |

|------|------|---|---|---|---|

| Proxy-based | Custom reverse proxy / local API wrapper | Yes (manual) | Yes | No | Existing code that calls claude.ai or API |

| Editor-native | Cursor, Aider, Continue, OpenCode | Yes (native) | Yes (native) | Some models free | Active development / coding tasks |

| Direct API | Your own code using SDK | Yes (via SDK routing) | Yes (via API calls) | No | Fine-grained control, cost tracking |

Each requires different setup, offers different affordances. None is "swap a setting in Claude Desktop" because that product does not exist.

---

OpenRouter (openrouter.ai) is a unified API router that sits between your code and 300+ models hosted on different providers. Instead of maintaining API keys and endpoints for OpenAI, Anthropic, Together, Fireworks, and others, you maintain one API key and one base URL.

Key properties:

• Base URL: https://openrouter.ai/api/v1
• API style: OpenAI-compatible (drop-in replacement for OPENAI_API_KEY and OPENAI_API_BASE)
• Models: 300+ including Claude, GPT, K2.6, Llama, Mixtral, etc.
• Pricing: Generally 10–50% cheaper than direct API for the same model (OpenRouter takes a margin, but batching and caching offsets it)
• Rate limits: Enforced per API key; business tier available for higher throughput

Cost example (April 2026 pricing):

| Model | Direct API (input/output per 1M tokens) | OpenRouter (input/output per 1M tokens) | Savings |

|---|---|---|---|

| Claude Opus 4.6 | $5.00 / $25.00 | $6.50 / $32.50 | —30% (OpenRouter markup) |

| K2.6 (via Moonshot) | N/A (direct only) | $0.60 / $1.80 | Accessible via OpenRouter |

| Llama 3.3 70B | N/A (free tier at Together) | $0.70 / $0.70 | Metered pricing |

OpenRouter is cheaper than direct API for open-weight models. For Claude, OpenRouter costs more (they mark up). Use OpenRouter when you want a single API surface across many providers, not necessarily for cost savings on Claude.

Step 1: Get an API key

1. Visit openrouter.ai
2. Click "Sign in" or "Sign up"
3. Go to Settings > API Keys
4. Create a new key; copy it

Step 2: Use it in code

Replace your existing Anthropic SDK calls with OpenAI SDK (which OpenRouter fully supports):

// Before: Direct Claude API
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// After: Via OpenRouter
import OpenAI from "openai";
const client = new OpenAI({
  apiKey: process.env.OPENROUTER_API_KEY,
  baseURL: "https://openrouter.ai/api/v1",
});

// Exact same call shape
const response = await client.messages.create({
  model: "anthropic/claude-opus-4-20250514",
  messages: [{ role: "user", content: "Hello" }],
});

Model names on OpenRouter:

• Claude Opus 4.6: anthropic/claude-opus-4-20250514
• Claude Sonnet 4.6: anthropic/claude-sonnet-4-20250514
• Claude Haiku 4.5: anthropic/claude-haiku-4-5-20251001
• K2.6: moonshot/kimi-k2-6
• Llama 3.3 70B: meta-llama/llama-3.3-70b-instruct
• GPT-4o: openai/gpt-4o

Step 3: Set environment variables

OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxxxxx
OPENROUTER_BASE_URL=https://openrouter.ai/api/v1

Step 4: Monitor usage

1. Go to openrouter.ai/account/billing
2. View real-time usage by model
3. Set spending caps under "Settings > Spending Limit"

Feature parity with native Claude API:

| Feature | OpenRouter | Notes |

|---|---|---|

| Messages API (basic) | ✓ | Full compatibility |

| Streaming | ✓ | Works as expected |

| Tool/function use | ✓ | Works as expected |

| Batch API | ✗ | Not supported; use native API |

| Vision (images) | ✓ | Works as expected |

| Artifacts (in Claude web) | ✗ | OpenRouter is API-only, no UI |

| MCP (Model Context Protocol) | ✗ | Not supported |

| Token counting | ✗ | No count tokens endpoint |

Bottom line: OpenRouter is ideal for code-based usage and backend services. It cannot replicate the Claude web app or Claude Code experience, and it lacks MCP + tool ecosystem integration.

A common pattern is to gate by complexity — use cheaper models for routine tasks, expensive ones for hard problems:

async function answerWithFallback(question: string): Promise {
  // Try cheap model first
  const cheapModel = "meta-llama/llama-3.3-70b-instruct";
  const cheapResponse = await client.messages.create({
    model: cheapModel,
    messages: [{ role: "user", content: question }],
    max_tokens: 200,
  });

  // If output is too short or confidence is low, escalate
  if (cheapResponse.content[0]?.type === "text" && 
      cheapResponse.content[0]?.text.length < 50) {
    const expensiveModel = "anthropic/claude-opus-4-20250514";
    const expensiveResponse = await client.messages.create({
      model: expensiveModel,
      messages: [{ role: "user", content: question }],
      max_tokens: 1000,
    });
    return expensiveResponse.content[0]?.type === "text" ? expensiveResponse.content[0].text : "";
  }

  return cheapResponse.content[0]?.type === "text" ? cheapResponse.content[0].text : "";
}

This approach uses OpenRouter's routing as a fallback mechanism, not as a direct Claude replacement.

---

If you want complete data residency, no API costs, or offline capability, run models locally. Two tools dominate this space as of April 2026:

| Tool | Setup complexity | Model library | API format | Desktop app |

|---|---|---|---|---|

| Ollama | 1 command (brew/apt/windows installer) | 50+ curated | OpenAI-compatible | Web UI only |

| LM Studio | GUI download, drag-drop models | 100+ from HF | OpenAI-compatible | Full desktop app (macOS, Windows, Linux) |

Both expose an OpenAI-compatible API endpoint (typically http://localhost:8000/v1 or http://localhost:1234/v1), meaning your code doesn't know the difference. You swap one environment variable and everything works.

Install Ollama:

# macOS
brew install ollama

# Ubuntu/Debian
curl -fsSL https://ollama.ai/install.sh | sh

# Windows
Download from https://ollama.ai/download

Run a model:

ollama run llama2

This downloads and starts serving Llama 2 7B on http://localhost:11434.

API usage:

const client = new OpenAI({
  apiKey: "ollama", // dummy key; Ollama doesn't require auth
  baseURL: "http://localhost:11434/api",
});

const response = await client.messages.create({
  model: "llama2",
  messages: [{ role: "user", content: "What is 2+2?" }],
});

Available models (curated selection):

ollama list

Or browse the library: https://ollama.ai/library. Notable options for April 2026:

• llama2 (7B, 13B, 70B) — Meta's open model
• mistral (7B) — Small, fast reasoning
• neural-chat (7B) — Instruction-following
• orca-mini (3B) — Smallest usable model
• dolphin-mixtral (8x7B) — MoE, high quality
• qwen2 (7B, 72B) — Chinese-optimized
• k2-preview (if available) — Kimi K2.6 open-weight variant (confirm availability)

Hardware requirements:

• 7B model: 8GB GPU VRAM or 16GB system RAM (slow)
• 13B model: 16GB GPU VRAM or 32GB system RAM
• 70B model: 48GB GPU VRAM (RTX 6000 or better)
• GPU: NVIDIA (CUDA) or Apple Silicon (Metal) — CPU is 50–100x slower

If you prefer a desktop app with a UI instead of CLI:

Install:

1. Download from https://lmstudio.ai
2. Install for macOS, Windows, or Linux
3. Launch the app

Add models:

1. Go to "Library" (left sidebar)
2. Search for a model (e.g., "mistral")
3. Click "Download"
4. Wait for completion (can be 10GB+)

Start the server:

1. Go to "Local Server" (left sidebar)
2. Select a downloaded model from dropdown
3. Click "Start Server"
4. Server runs on http://localhost:1234/v1 by default

API usage:

Same as Ollama, just change the base URL:

const client = new OpenAI({
  apiKey: "local",
  baseURL: "http://localhost:1234/v1",
});

LM Studio advantages over Ollama:

• Desktop GUI for model management
• Live stats (tokens/sec, GPU utilization)
• Built-in chat interface (playground)
• No terminal required
• Persistent settings (Ollama resets on restart)

Trade-off: LM Studio is less scriptable; Ollama is better for production/headless servers.

If your code runs on a different machine (e.g., production server calling a local dev model), expose the local server:

Ollama remote access:

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Then use the remote URL from other machines:

const client = new OpenAI({
  apiKey: "ollama",
  baseURL: "http://192.168.1.100:11434/api", // replace with your IP
});

Security warning: This exposes your local model to the network without authentication. Use a firewall or VPN in production.

---

Microsoft Azure AI Foundry is Microsoft's managed AI platform for enterprises. As of April 2026, Anthropic has a partnership allowing Claude models to be deployed via Azure:

• Deployment model: Serverless (you don't manage infrastructure)
• Billing: Via Microsoft Azure; can be included in enterprise agreements
• Models available: Claude Opus 4.6, Claude Sonnet 4.6, Claude Haiku 4.5
• Use case: Organizations with Azure cloud lock-in or compliance requirements (e.g., FedRAMP, HIPAA)

Advantages of Azure Foundry over direct Anthropic API:

• Compliance: FedRAMP and other certifications included
• Regional deployment: Models can run in your region (EU, US gov, etc.)
• Managed integration: Works with Azure Cognitive Search, Azure Documents, etc.
• Billing consolidation: Single Azure invoice for all cloud services

Disadvantages:

• Pricing: Typically higher than direct API (Microsoft margin)
• Feature lag: May lag behind native Claude API (new features appear on Anthropic API first)
• Complexity: Requires Azure account, networking setup, authentication

Step 1: Get an Azure subscription

1. Go to portal.azure.com
2. Create an account (free trial available)
3. Create or select a resource group

Step 2: Deploy a Claude model

1. Search for "AI Foundry" or "Azure AI"
2. Click "Create"
3. Select model: Claude Opus 4.6 (or Sonnet/Haiku)
4. Configure region, pricing tier
5. Deploy

Step 3: Get API credentials

After deployment:

1. Go to "Keys and Endpoint" in the Azure resource
2. Copy the API key and endpoint URL
3. Endpoint will look like: https://your-resource.openai.azure.com/

Step 4: Use in code

Azure uses a different authentication method than the direct API. Use the Azure SDK:

import { AzureOpenAI } from "openai";

const client = new AzureOpenAI({
  apiKey: process.env.AZURE_OPENAI_API_KEY,
  apiVersion: "2024-02-15-preview",
  baseURL: process.env.AZURE_OPENAI_ENDPOINT,
});

const response = await client.messages.create({
  model: "claude-opus-4", // Azure naming differs from Anthropic
  messages: [{ role: "user", content: "Hello" }],
});

Environment variables:

AZURE_OPENAI_API_KEY=xxxxxxxxxxxxxxxxxxxxx
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/

Cost comparison (April 2026 estimated):

| Provider | Claude Opus 4.6 Input (per 1M tokens) | Output (per 1M tokens) |

|---|---|---|

| Direct API | $5.00 | $25.00 |

| OpenRouter | $6.50 | $32.50 |

| Azure Foundry | $7.00–$10.00 | $35.00–$50.00 |

Azure is not cost-competitive for pure Claude usage. Use it if you have other Azure services or compliance requirements.

| Feature | Azure | Native API | Notes |

|---|---|---|---|

| Messages API | ✓ | ✓ | Full compatibility |

| Vision (images) | ✓ | ✓ | Works as expected |

| Tool use | ✓ | ✓ | Works as expected |

| Batch API | ✗ | ✓ | Not available on Azure yet |

| Artifacts | ✗ | ✗ | API-only feature anyway |

| MCP | ✗ | ✗ | Not supported on any API |

| Regional deployment | ✓ | ✗ | Azure advantage |

| Custom models (fine-tuning) | ✗ | ✗ | Not available (yet) |

Bottom line on Azure: Use it only if your organization is already on Azure or has specific compliance requirements. Otherwise, pay less with direct API or OpenRouter.

---

| Provider | Best for | Cost (Claude Opus) | Setup time | Offline capable | Supports other models |

|---|---|---|---|---|---|

| Direct Anthropic API | Baseline Claude users | Lowest ($5/$25) | 5 min | No | No (Claude only) |

| OpenRouter | Multi-model experimentation, K2.6 access | Higher ($6.50/$32.50) | 5 min | No | Yes (300+) |

| Ollama | Complete data residency, offline work | Free (one-time hardware cost) | 15 min | Yes | Yes (50+) |

| LM Studio | Desktop-first workflows | Free (one-time hardware cost) | 10 min (GUI) | Yes | Yes (100+) |

| Azure Foundry | Azure-locked organizations, compliance | Highest ($7–$10/$35–$50) | 20 min + account setup | No | No (Claude + Azure partners) |

Use this to pick your approach:

1. Do you need to stay on Claude models only? → Direct Anthropic API (cheapest, simplest)
2. Do you want to experiment with K2.6, Grok, or other models? → OpenRouter (one API key for all)
3. Do you have strict data residency or compliance requirements? → Ollama or LM Studio (local, offline)
4. Is your organization already on Azure? → Azure Foundry (single invoice, but pricier)
5. Do you want to avoid API costs entirely? → Ollama + local GPU (high upfront, zero per-token cost)

In production, you often want fallback logic:

import OpenAI from "openai";

const clients = {
  primary: new OpenAI({
    apiKey: process.env.OPENROUTER_API_KEY,
    baseURL: "https://openrouter.ai/api/v1",
  }),
  fallback: new OpenAI({
    apiKey: process.env.OLLAMA_API_KEY || "local",
    baseURL: process.env.OLLAMA_BASE_URL || "http://localhost:11434/api",
  }),
};

async function askWithFallback(question: string): Promise {
  try {
    const response = await clients.primary.messages.create({
      model: "anthropic/claude-opus-4-20250514",
      messages: [{ role: "user", content: question }],
      max_tokens: 500,
    });
    console.log("Primary (OpenRouter) succeeded");
    return response.content[0]?.type === "text" ? response.content[0].text : "";
  } catch (error) {
    console.warn("Primary failed, trying fallback (Ollama)", error);
    const response = await clients.fallback.messages.create({
      model: "llama2",
      messages: [{ role: "user", content: question }],
      max_tokens: 500,
    });
    return response.content[0]?.type === "text" ? response.content[0].text : "";
  }
}

This ensures your service degrades gracefully if OpenRouter is down — it falls back to your local Ollama instance.

---

Sources

1. Anthropic Company Overview — Anthropic.com/company; confirms partnerships with Amazon Bedrock, Google Vertex AI, and Microsoft Foundry (April 2026)
2. OpenRouter Documentation — openrouter.ai/docs; confirms 300+ models, OpenAI compatibility, Claude Desktop integration mention (April 2026)
3. Ollama Official — ollama.ai; model library and API specification (April 2026)
4. LM Studio Official — lmstudio.ai; desktop app features and local API (April 2026)
5. Azure AI Foundry — microsoft.com/azure/ai; Claude model availability on Azure (April 2026)
6. Claude Products — claude.ai/product; clarifies Web, Code, and Cowork as only consumer products (April 2026)
7. YouTube Roundup — youtube.com/watch?v=Q8DoGJ0VuEI; Source for Story 3 topic (April 2026)

---

Final Honesty Statement

What does NOT exist:

• A "Claude Desktop" application with a settings panel for "swap to OpenRouter"
• Official Anthropic support for alternative model providers in their UI products
• A seamless one-click feature to use local models inside Claude Code

What DOES exist and works:

• OpenRouter as a proxy API that accepts the same code signatures as Claude API but routes to 300+ models
• Ollama and LM Studio as self-hosted model servers with OpenAI-compatible endpoints
• Azure Foundry for enterprise Claude access via Microsoft (with regional compliance benefits)
• Tools like Cursor, Aider, and Continue that natively support OpenRouter and local models
• Custom proxy or routing logic you can build to swap providers on demand

If you want true model swapping without modifying code, use Cursor (which has native provider switching) or Aider (which supports provider flags). If you want to keep using Claude Code or the web app, you will need to route through one of the proxy solutions above — and accept that you lose features like artifacts and MCP integration in the trade-off.