1. Go to tensorx.ai, sign up, and add $5 worth of credits on the account. Generate an API key and store it in a password manager.

2. Open a terminal on your computer and install OpenCode with curl -fsSL https://opencode.ai/install | bash. If you are on Windows, use Windows Subsystem for Linux to do this.

3. In your terminal, create a persistent environment variable called TENSORX_API_KEY with your API key as the value. Here’s how to do it on MacOS. On WSL/Linux it’s the same except you store the variable in ~/.bash_profile instead of in ~/.zprofile. If your API key was sk-abcdefghijkl1234567890, the entry would look like this:

export TENSORX_API_KEY=sk-abcdefghijkl1234567890

After saving the file, restart the terminal and test that the environment variable is registered, like so:

echo $TENSORX_API_KEY

It should output your key. If it doesn’t, troubleshoot the environment variable creation by asking an LLM in the browser for help.

4. Create and open an OpenCode configuration file called ~/.config/opencode/opencode.jsonc by running these commands:

mkdir -p ~/.config/opencode
touch ~/.config/opencode/opencode.jsonc
open ~/.config/opencode/opencode.jsonc

5. Populate the file with the following content. It is a minimal configuration that sets up OpenCode with one model from TensorX (GLM 5.2), just to get you off the ground. NB: if you are reading this at a future time when TensorX is no longer serving GLM 5.2, you will need to change the config to include a different model. An LLM in the browser will be able to help you with this.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "tensorix": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Tensorix",
      "options": {
        "baseURL": "https://api.tensorix.ai/v1",
        "apiKey": "{env:TENSORX_API_KEY}",
        "setCacheKey": true
      },
      "models": {
        "z-ai/glm-5.2": {
          "name": "GLM-5.2",
          "reasoning": true,
          "attachment": true,
          "options": {
            "reasoning_effort": "max"
          },
          "cost": {
            "input": 1.5,
            "output": 4.5,
            "cache_read": 0.38
          }
        }
      }
    }
  },
  "agent": {
    "build": { "disable": true },
    "plan": { "disable": true },
    "glm5.2": {
      "description": "GLM 5.2",
      "model": "tensorix/z-ai/glm-5.2",
      "mode": "primary"
    }
  }
}

Save the file and return to the terminal.

6. Start OpenCode with the command opencode. You should be good to go.

GLM 5.2 is powerful enough to safely manipulate OpenCode’s configuration file by itself, so from here on you can just ask for what you want in plain language. For example, if you want to add another, more powerful model and be able to switch between them with the TAB key, just ask it something like:

Please add `moonshotai/kimi-k3` from TensorX to my OpenCode config 
and create an agent entry for it.

There is a lot you can tweak in OpenCode – too much to cover here – but I hope to mention my favourite tweaks in future posts.

If you are new to agentic systems, one of the first things you will want to do is start populating your AGENTS.md file, the general instructions that are passed to the model each time you start a new conversation. Just create a file by that name in the ~/.config/opencode/ folder and start adding stuff. Search online or ask an LLM for ideas on what to put in there. BTW if you are coming from another agentic system and have an AGENTS.md/CLAUDE.md file already, just copy it to the ~/.config/opencode/ folder and OpenCode will pick it up.

An alternative way of using agents is to mix and match the components that make up an agentic system, namely, 1) the harness, 2) the model, and 3) the inference provision. In apps such as Claude Code and Codex, these elements are bundled, provided by the same company, and closed source. But you can break free from this mold and build a stack that does largely the same job for less money and with better privacy.

Here is what I currently use:

• Harness: OpenCode
• Inference provider: TensorX
• Model: Whichever open-source model leads the charts and suits the task.

Why OpenCode? Because it lets me plug in any model from any provider without sacrificing features. The user experience is practically identical to that of Claude Code and Codex, but I get much more flexibility from being able to choose whichever model and inference provider I want. There are other open-source apps of the same type, such as Aider and Crush, but OpenCode has a much larger user base and is more actively maintained.

Why TensorX? Because it offers the latest and best open source LLMs under privacy terms that are as good as they get in the industry. All inference on TensorX is GDPR-compliant, involves Zero Data Retention, and takes place in data centers on EU territory (Ireland and Finland). There are many providers that offer similarly good ranges of open source models (e.g., Ollama Cloud, Fireworks AI) and there are a few other European companies that offer similarly good privacy (e.g., Scaleway, Infercom), but I have not found another company that has both.

Why open-source models? Because they have become very good, they cost a fraction of proprietary models, and they are available from privacy-conscious inference providers such as TensorX. To be sure, proprietary flagship models are always going to be slightly better than the best open source models, but at the moment the intelligence gap is marginal, and it is a difference you can probably only feel if you are working on an extremely complex task. In fact, even the best open source models (such as Kimi K3) are now overkill for most tasks, and I currently do most of my work with slightly less capable models like GLM 5.2 and Deepseek V4 Flash.

The price difference is huge; here are some example API prices (per million tokens out):

• Claude Fable 5: $ 50
• GPT 5.6 Sol: $ 45
• Kimi K3: $ 15
• GLM 5.2: $ 4.50
• Deepseek V4 Flash: $ 0.30

The fact that the best open source models are Chinese-produced has no bearing on privacy, because models cannot call home (and we would easily spot it if they did). Model production and inference are two completely different processes, and once an open source model is released, it is untethered from the company that produced it. Almost all of the privacy risk in LLM use is concentrated in the inference provider, because it can, in principle, see and store the communication between you and the model. It is the company that serves you the model that you should be worried about, not the model itself.

For maximum privacy you can of course skip the inference provider altogether and run an open source model locally, on your own infrastructure. With a framework like Ollama you can use local models in OpenCode just like you can any other model. The main challenge is hardware: unless you have a very beefy computer, you will be limited to models that are a lot less powerful than what a provider like TensorX can serve you. I happen to have access to a reasonably large GPU server (48GB VRAM), so I do use local models for some LLM jobs. However, for agentic coding tasks I have found the larger, cloud-based models substantially more performant. There is also a security dimension to this; weaker models are more vulnerable to prompt injection and such, so if you are going to have a model fetch things from the web (which you generally do in an agentic setting), a bigger model will generally be safer.

Setting up the OpenCode + TensorX stack does require some firing of terminal commands and editing of config files, so if you are very uncomfortable on the command line, this solution may not be for you. But if you don’t mind a little bit of tinkering, it is worth trying out. I will describe the basic setup procedure in a separate post.