For a while my daily driver AI lived in someone else’s datacenter. I ran opencode on Claude, then on ChatGPT, and I paid for the privilege. That ended the day I put a 27B model on a 5090 in my house.

The Claude years

Claude Max and opencode were a good pairing, and I ran my daily development through it for a while. Then one night it just stopped working. Every request came back a 401 and nothing on my side was wrong, because Anthropic had quietly blocked third-party clients like opencode from riding on consumer subscriptions. No deprecation notice, no migration path, and the thread about it in Anthropic’s claude-code repo was closed the same day. It is still up if you want to watch the room react.

Frankly, that was Claude telling the open source tool ecosystem to fuck itself.

I canceled that night. I have been a software engineer for 20 years, so they could have had a decade more of my payments, but not now. I was not going to argue with a revenue team about where I was allowed to point my own CLI, and I am not coming back to a company that rug pulls like that.

The ChatGPT detour

I tested the alternatives and OpenAI was the easiest landing. I moved to ChatGPT Pro, the 20x usage tier, which ran $217.75 a month with tax. opencode worked fine against the OpenAI API and the models were good, but I spent every afternoon watching a usage dashboard. Tokens are a meter, and I was the guy watching the meter run. When the 5090 took over the workflow I dropped back to Plus, and the 20x meter had served its purpose.

To be clear, the price was not even the real problem. My code, my prompts, my working habits, all of it was flowing to a company I do not control, and they can log it, train on it, or hand it to whoever shows up with a subpoena. I was renting my brain, and the landlord could change the terms any month.

The box

The answer was hardware. I built a dedicated box and did not spend money on the parts that do not matter. The CPU and RAM were an old desktop that was collecting dust, a Ryzen 5 4500 with 16GB, and it exists only to feed the GPU, which is the whole job. The 5090 does the actual work and is the only part that cost real money. It runs Debian 13, vLLM in Docker, with the model cache on a dedicated /data volume.

I call the box astrid, which is also what the assistant living on it is named. It sits on my LAN, and everything else reaches it through Tailscale.

The model is gittensor-model-hub/Qwen3.8-27B-NVFP4-RTX5090, an NVFP4 checkpoint built specifically for the 5090. With an FP8 KV cache and 95% of the GPU reserved it still leaves room for a 131072 token context, and MTP speculative decoding with three draft tokens pushes the warm sequential decode rate to 284.7 tokens a second, with the first token landing in about 185 milliseconds and four concurrent requests holding 700 plus in aggregate. That is fast enough that I stopped noticing where the model was running.

The whole server is one compose file.

services:
  qwen-astrid:
    image: vllm/vllm-openai:nightly
    container_name: qwen-astrid
    restart: unless-stopped
    ipc: host
    ports:
      - "8000:8000"
    volumes:
      - /data/models/vllm/qwen-astrid/cache:/root/.cache
    environment:
      MAX_JOBS: "2"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    command:
      - gittensor-model-hub/Qwen3.8-27B-NVFP4-RTX5090
      - --served-model-name
      - qwen-astrid
      - --quantization
      - modelopt
      - --language-model-only
      - --kv-cache-dtype
      - fp8
      - --gpu-memory-utilization
      - "0.95"
      - --max-model-len
      - "131072"
      - --max-num-seqs
      - "2"
      - --max-num-batched-tokens
      - "8192"
      - --enable-chunked-prefill
      - --enable-prefix-caching
      - --reasoning-parser
      - qwen3
      - --enable-auto-tool-choice
      - --tool-call-parser
      - qwen3_coder
      - --speculative-config
      - '{"method":"mtp","num_speculative_tokens":3}'

On the opencode side, everything is the OpenAI-compatible endpoint, so nothing about my workflow changed. Same CLI, same agents, same tools, and the provider block below is the only config I added.

"provider": {
  "astrid5090": {
    "npm": "@ai-sdk/openai-compatible",
    "name": "Astrid RTX 5090",
    "options": {
      "baseURL": "http://astrid:8000/v1",
      "apiKey": "local",
      "temperature": 1.0,
      "topP": 0.95,
      "topK": 20,
      "timeout": false,
      "headerTimeout": false,
      "chunkTimeout": 3600000
    },
    "models": {
      "qwen-astrid": {
        "name": "Astrid",
        "reasoning": true,
        "interleaved": { "field": "reasoning" },
        "options": { "reasoningEffort": "medium" },
        "limit": { "context": 131072, "output": 32000 }
      }
    }
  }
}

Everything points at the same endpoint: opencode on my work machines, the Go server that runs my house, and the Open WebUI that fronts my voice assistant on my 3090 box. One model, one machine, zero API keys.

Why you should pull the same cord

The two biggest labs in the business have both shown you what they do when a customer gets inconvenient. Anthropic pulled the plug on the third-party client I depended on for my whole workflow, and OpenAI has a habit of changing terms, capping usage, and moving the goalposts on what a subscription actually buys you. They will screw over the individual when it helps them, because the individual is not where the money is.

Your prompts have secrets in them. API keys, internal architecture, the things you type at 1am when you are tired and loose with your tongue. All of it was going into a warehouse I could not audit and could not object to. Now the network boundary is my LAN, so if I leak a secret, it leaks in my house.

The datacenter argument is the same story from the other side. When I paid $217.75 a month I was paying for their grid, their cooling, their uptime, and their margin. My box’s measured peak draw is 372 watts at 57 degrees, so even running at that ceiling around the clock it is about 3,300 kilowatt hours a year, which makes a personal assistant on one consumer GPU a rounding error next to the subscription.

Do the math on the subscription. $217.75 a month is $2,613 a year. The box is a one-time cost and the only recurring bill is the electricity, so after that it is free, forever, at 284.7 tokens a second. I am not watching a meter anymore. I am not getting a usage email. I am not reading a changelog to find out what my subscription no longer includes.

And the gatekeeping goes away with the company. A local model does not refuse you because a policy team in another timezone had a bad week, and it does not decide which questions you are allowed to ask. It does the job, and that is the whole product.

The sovereignty part is the one that keeps me there. As long as the box is plugged in, the assistant exists. There is no server that can go away, no model that gets pulled, no license that expires. And since I am the only customer, outages do not exist on this setup. No slowness, no scaling issues, no throttling. The model is a file on a disk in my house, and when a better small model ships, the upgrade is a download, not a support ticket. The box does not get dumber over time. If anything it gets smarter, and every improvement stays where it is. You can be completely off the grid and still have something that is permanently this smart.

The frontier labs can keep the frontier. The useful part of this for a working developer is the piece that fits on one GPU, speaks the OpenAI protocol, and runs on a machine you can touch. Point your tools at it.