How to set up a desktop AI agent on your own machine, route its model calls through a local proxy, and stop paying $20/month for chatbots that only talk.

There is a meaningful gap between AI tools that describe what to do and AI tools that do it. ChatGPT, Claude, Gemini, Perplexity — these are chat boxes. You ask, they answer in words, and you are still the one opening PowerPoint, dragging files around, summarizing the webpage by hand. The actual work hasn't moved.

The newer category — agentic desktop apps — closes that gap. Anthropic shipped Claude Cowork. The open-source community shipped Open Cowork, which does the same thing without locking you to one vendor. Pair it with Lynkr, a local Anthropic-compatible proxy, and you get a complete AI agent stack running on your own machine with no monthly subscription.

This article explains what Open Cowork is, what Lynkr is, why they pair well together, and how to set up the integration end to end.

Part I — What Is Open Cowork?

Open Cowork is an open-source desktop AI agent application for Windows and macOS. The project lives at github.com/OpenCoworkAI/open-cowork and ships as a one-click Electron installer — no terminal commands, no Python setup, no manual dependency wrangling. You download, install, and it opens as a normal desktop app.

The shape of the app is unusual compared to a chat tool. It is structured around three primary surfaces:

• A chat window where you describe what you want
• A workspace folder on your filesystem that the agent can read from and write to
• A trace panel that shows the agent's reasoning and every tool it executes in real time

What makes it different from a chat tool is that the AI doesn't just respond. It executes. It generates real files, opens your browser, reads pages, and interacts with other applications on your computer.

Core capabilities

Document generation through the Skills system. Open Cowork ships with built-in workflows for producing PPTX, DOCX, XLSX, and PDF files. You ask for a 10-slide pitch deck and you get a real PowerPoint file with editable text, a chosen color scheme, and structured content. Not a markdown summary. Not a description of what the slides should contain. An actual file you can open in Keynote or PowerPoint.

MCP (Model Context Protocol) integration. Open Cowork connects to external services through MCP connectors — browser automation, Notion, custom internal apps. Once a connector is configured, the AI can drive those services as part of its workflow. Open a webpage, extract structured data, push it into a Notion database.

GUI automation (computer use). The app supports controlling other desktop applications by reading the screen and operating the mouse and keyboard. The recommended model for this surface is Gemini-3-Pro per their documentation, but any vision-capable model works.

Sandbox isolation via WSL2 and Lima. Every command the agent executes runs inside a virtual machine — WSL2 on Windows, Lima on macOS. The host filesystem is protected. Even if the AI is told to run something destructive, it physically cannot reach the parts of your computer you didn't authorize.

Remote control through Feishu and Slack. You can send tasks to Open Cowork from your phone via Slack messages or Feishu (the Chinese equivalent). The agent executes them on your desktop machine and reports back through the same channel.

Multimodal input. Drag images, PDFs, and other files directly into the chat input. The agent can read them as part of the conversation.

How it compares to Claude Cowork

Claude Cowork is Anthropic's first-party desktop agent app. Open Cowork is the community's open-source implementation of the same idea. The functional capabilities overlap substantially:

The biggest practical difference is model flexibility. Claude Cowork only works with Claude, which means you pay Anthropic for every call. Open Cowork lets you plug in any provider, including a local model running on Ollama — which is where Lynkr comes in.

Configuration model

Open Cowork is configured through three primary mechanisms:

.env file in the project root. The Anthropic SDK respects standard environment variables: ANTHROPIC_AUTH_TOKEN, ANTHROPIC_BASE_URL, CLAUDE_MODEL. This is the simplest way to wire up a custom backend.

In-app Settings panel. The GUI has a full API Configuration page with provider presets (Anthropic, OpenAI, OpenRouter, Gemini, Ollama) and a custom-provider option with editable base URL, selectable protocol (anthropic / openai / gemini), and a free-text API key field.

Workspace folder selection. On first launch, you pick a folder on your filesystem that the agent will read from and write to. Everything happens inside that folder. The Lima or WSL2 VM mounts this folder so the agent can operate on it without ever touching the rest of your disk.

Part II — What Is Lynkr?

Lynkr is a Node.js proxy that exposes a unified Anthropic-compatible API surface at /v1/messages while internally routing each request to whichever provider and model is most appropriate.

The core capabilities relevant to this integration:

• Anthropic and OpenAI API compatibility. Lynkr accepts requests in either format on the same port. Tools using the Anthropic SDK and tools using the OpenAI SDK can hit the same instance.
• Complexity-based routing. Lynkr analyzes each incoming request, scores it for complexity, and routes simple requests to a local Ollama model and complex requests to Claude Opus or Sonnet.
• Per-request model override. Clients can specify an exact model and Lynkr will honor it, otherwise it picks based on the configured tier.
• Token budget enforcement. Lynkr tracks cumulative spend per project and can throttle or downshift when budgets are exceeded.
• Telemetry dashboard. Every request is logged with provider, latency, tokens, and cost. The dashboard at http://localhost:8081/dashboard shows live throughput, request volume by provider, and cumulative spend.

For Open Cowork specifically, three of these matter most: complexity routing (most agent calls are short summarization or tool-result handling, which local Ollama handles fine), telemetry (see exactly how much each session costs), and API compatibility (Open Cowork's Anthropic SDK calls flow through Lynkr without any code change).

Part III — Why Pair Them?

A typical Open Cowork session involves dozens of model calls per task. The agent plans, then makes a tool call, then summarizes the tool result, then plans the next step, then makes another tool call, and so on. Each round trip is a separate API call. A single "organize my downloads folder" task can fire fifteen to twenty model calls before finishing.

If every one of those calls hits Claude Opus, you are looking at roughly $0.10-$0.30 per task. A working session of fifty tasks runs $5-$15. Continuous daily use is hundreds of dollars per month. For most people, this defeats the entire point of using a "free" open-source app.

Most of those calls don't need a frontier model. Summarizing a tool result is a 200-token job. Picking the next file to read is a 100-token job. Deciding whether to continue or stop is a 50-token job. These are exactly the kinds of tasks where a local model running on Ollama produces identical-quality output at zero cost.

Routing Open Cowork's calls through Lynkr changes the economics:

• Trivial agent calls (tool result handling, status checks, simple reasoning) → local Ollama → $0
• Document generation and planning → cloud Sonnet → ~$0.05 per call
• GUI automation and computer use → cloud Opus or Gemini-3-Pro → $0.30 per call

In practice this comes out to a 10-20x reduction in cost per session with no loss of fidelity on the operations that actually need a capable model.

The second benefit is privacy. The calls routed to local Ollama never leave your machine. Files you reference, prompts you write, and intermediate reasoning all stay on your laptop. For users working with sensitive data, internal company information, or anything under compliance constraints, this is the difference between Open Cowork being usable and being a non-starter.

The third benefit is model choice. Lynkr can route different request shapes to different providers — a Gemini call for vision tasks, a Sonnet call for planning, a local Qwen call for short summarization. Open Cowork sees one base URL and one model name. Lynkr does the dispatch.

Part IV — Setup Guide

Prerequisites

Pull a coding-aware model into Ollama for the simple-tier routing:

ollama pull qwen2.5-coder:7b
# optional: a larger model for moderate-complexity calls
ollama pull minimax-m2.5:cloud

Step 1 — Start Lynkr

From your Lynkr installation directory:

node bin/cli.js start --port 8081

Lynkr starts, auto-discovers your local Ollama instance, and is ready to accept requests at http://localhost:8081. Verify it's running:

curl http://localhost:8081/health
# {"status":"ok"}

Open the dashboard at http://localhost:8081/dashboard in your browser and leave it visible — you'll use it later to confirm routing is working.

Step 2 — Clone and install Open Cowork

git clone https://github.com/OpenCoworkAI/open-cowork.git
cd open-cowork
npm install

The install takes about five minutes. It downloads the bundled Node binaries, builds the WSL agent (Windows) or Lima agent (macOS), bundles the MCP servers, and rebuilds better-sqlite3 against Electron's ABI. Don't be alarmed by the number of packages — Electron apps are heavy.

Step 3 — Configure the Lynkr backend

Create .env in the Open Cowork root:

# Any non-empty string. Lynkr doesn't validate the key for local providers.
ANTHROPIC_AUTH_TOKEN=local

# Point the Anthropic SDK at Lynkr instead of api.anthropic.com.
ANTHROPIC_BASE_URL=http://localhost:8081

# The model name Open Cowork sends. Lynkr's router may override this
# based on request complexity — leaving it as a cloud model name is fine.
CLAUDE_MODEL=claude-sonnet-4-6

That's the entire integration. Open Cowork uses the Anthropic SDK under the hood, the SDK respects ANTHROPIC_BASE_URL, and every call now flows through Lynkr before reaching any actual provider.

Step 4 — Launch Open Cowork

npm run dev

The first launch takes 60-90 seconds because vite is starting, the sandbox agents are being built, and Electron is opening for the first time. When the desktop window appears, you'll be prompted to pick a workspace folder. Create one:

mkdir ~/cowork-workspace

Point Open Cowork at ~/cowork-workspace. This is now the only directory the agent can read from and write to.

Step 5 — Verify the integration

Before sending your first message, make sure the Lynkr dashboard is open in another window. Then in Open Cowork, send a simple test prompt:

Read any text file in my workspace and tell me what's inside.

Watch the Lynkr dashboard. You should see:

• Request count incrementing in real time
• A mix of providers in the breakdown (likely ollama for the simple turns, anthropic for the planning turns)
• Latency distribution showing local Ollama calls completing in 1-3s and cloud calls in 5-15s

If nothing shows up on the dashboard, Open Cowork is hitting Anthropic directly — the SDK in their agent runtime bypassed our env var. This is uncommon but possible. The fix is a one-line change to where the SDK client is constructed in their codebase to honor ANTHROPIC_BASE_URL.

Step 6 — Try a real task

Drop a file into your workspace folder and send a task that exercises the full agent loop:

Organize the files in this folder by type. Move images into an "images" subfolder, documents into "docs", and code into "code". Tell me what you moved.

You'll see the trace panel on the right populate with each tool call: list_files, read_file, move_file, and so on. Every one of those tool result summaries fires a model call. Most of them should route to local Ollama via Lynkr. The high-level plan and final summary may route to Sonnet.

Part V — Advanced Configuration

Routing tiers tuned for an agent loop

The default Lynkr complexity scoring works well for chat workloads, but agent loops have a different shape. The bulk of calls are tool-result handling and planning between tool calls, both of which are short. You probably want to lower the threshold that pushes calls to Sonnet:

{
  "routing": {
    "tiers": {
      "SIMPLE": {
        "provider": "ollama",
        "model": "qwen2.5-coder:7b"
      },
      "MODERATE": {
        "provider": "anthropic",
        "model": "claude-sonnet-4-6"
      },
      "COMPLEX": {
        "provider": "anthropic",
        "model": "claude-opus-4-7"
      }
    },
    "complexity": {
      "thresholds": {
        "simple": 25,
        "complex": 60
      }
    }
  }
}

Lower thresholds mean more calls go to Ollama. Tune until you see a routing mix of roughly 70% local, 25% Sonnet, 5% Opus on the dashboard.

Vision-capable routing for GUI tasks

Open Cowork's computer-use feature needs a model that can read screenshots. Local Ollama coding models don't support vision. Configure Lynkr to detect image content in requests and route them to Gemini-3-Pro or Claude Sonnet:

{
  "routing": {
    "vision": {
      "provider": "google",
      "model": "gemini-3.1-pro-preview"
    }
  }
}

This keeps cost low on text-only calls while routing the heavy GUI-interpretation calls to a model that can actually see the screen.

Per-session budget caps

If you want to prevent any single Open Cowork session from going over a spend ceiling, set a budget env var:

LYNKR_BUDGET_USD=2.00

Lynkr will refuse new requests once the limit is hit, preventing a runaway loop on a malformed prompt from burning through a hundred dollars overnight.

Multiple workspaces, same backend

If you want different Open Cowork workspaces (work, personal, side project) to use different routing policies, run multiple Lynkr instances on different ports and point each Open Cowork install at the right one. The Lynkr CLI supports --config <path> to load a workspace-specific routing config.

Part VI — Troubleshooting

"I sent a message but nothing showed up on the Lynkr dashboard"

The Open Cowork agent runtime (the pi-coding-agent library it depends on) is not your standard Anthropic SDK usage. It may construct its HTTP client in a way that ignores ANTHROPIC_BASE_URL. To check, look at network traffic during a session — if requests are going to api.anthropic.com instead of localhost:8081, the env var is being bypassed.

The fix is small but requires a code change. Find where the Anthropic client is instantiated in Open Cowork's source (likely under src/main/claude/ based on the file structure) and confirm it reads process.env.ANTHROPIC_BASE_URL when constructing the client. If it doesn't, add it.

"The agent says it can't read my PDF"

Three likely causes, in order of probability:

1. Lynkr routed the request to a local Ollama model that doesn't support PDF content blocks. PDF support is a Claude-specific feature. If your routing tier sent the request to Qwen or MiniMax, the PDF was silently dropped. Force a Claude route by setting CLAUDE_MODEL=claude-sonnet-4-6 more aggressively or saying "use Sonnet" in your prompt.

2. The Lima sandbox doesn't have a PDF parser installed. If you put the PDF in your workspace and asked the agent to read it via filesystem tools, it tried cat report.pdf, got binary garbage, then tried pdftotext and got "command not found." Install poppler-utils inside the Lima VM:
   

   limactl shell default
   sudo apt-get install -y poppler-utils

1. The PDF was dragged into chat but exceeded the multimodal API size limits. Anthropic caps PDFs at 32MB and about 100 pages. Move the file into your workspace folder instead and reference it by name.

"Streaming cuts off mid-response"

Usually means Lynkr routed to a model with a smaller context window than the conversation needed. The fix is either to use a model with more context (Opus or Sonnet) for that session, or to start a new conversation so the history compresses.

"Lima won't start"

On macOS, Lima needs to bootstrap once before Open Cowork can use it:

limactl start default

After that initial start, Open Cowork manages it automatically.

Part VII — When This Stack Pays Off

Open Cowork plus Lynkr makes sense when you fit roughly this profile:

You do enough AI-driven work that subscription costs feel like a real expense. You want files generated, not files described. You work with information that should stay on your machine. You don't want to bet your workflow on one vendor's pricing or feature roadmap. And you have a laptop capable enough to run a local model — anything M-series or a recent Intel chip with 16GB+ of RAM will do fine.

If you fit two or more of those, the math works. The setup is a one-time investment of maybe two hours. After that, the agent runs itself, the proxy handles routing transparently, and you stop seeing line items for AI tools on your monthly statement.

If you don't fit that profile — if you only use AI occasionally, if cost isn't a concern, if you don't care about privacy — then a managed product like Claude Cowork is genuinely simpler. There's no shame in paying for convenience. But for the people who do fit, this stack is one of the few open-source combinations where the open-source version is better than the commercial alternative, not just cheaper.

Conclusion

Open Cowork closes the gap between AI tools that talk and AI tools that work. It generates real files, drives your browser, connects to other apps, and runs everything inside a sandbox so it can't break your machine.

Lynkr makes Open Cowork affordable. By routing the boring 70% of calls to a local model and reserving the cloud models for the calls that actually need them, the per-session cost drops from dollars to cents.

The integration is two lines of .env configuration. The whole stack runs on your own machine. There's no subscription, no telemetry going to a vendor, no monthly bill.

If you've been waiting for the open-source AI agent ecosystem to grow up, this is it.

Open Cowork: github.com/OpenCoworkAI/open-cowork

Lynkr: https://github.com/Fast-Editor/Lynkr

Ollama: ollama.com

If you set this up and run into something I didn't cover here, drop a note in the comments. I'm collecting failure modes for a follow-up post.