Agentic coding on your Mac, powered by TT-QuietBox® 2

Coding agents, the kind that read your files, write code and run commands on their own, are everywhere. Stack Overflow’s April 2026 pulse survey found that 59% of developers use AI agents at work, up from 31% in 2025, and 37% use them daily, up from 14%. Most of those agents talk to a model in someone else’s data center. Open models and open coding harnesses have evolved enough that using them locally is possible today.

TT-QuietBox 2 is a liquid-cooled workstation with four Blackhole chips and 128 GB of GDDR6. It can fit a relatively large model and leave room for a large context window, which is exactly what a coding agent needs.

I put Qwen3.8-27B on my QuietBox 2, sat down at my Mac, pointed OpenCode at the box across the network, and typed make me a tetris clone. A minute later, I had a working game. The prompt, the reasoning and the code never left my network.

This post shows how to set that up yourself. It covers serving the model, connecting a coding agent from your Mac, and checking the connection. For reference, the details live in the model's repository.

What you need

• A QuietBox 2 on the same network as your Mac
• A Mac with a terminal
• About ten minutes, plus the time it takes to download the model

Step 1: Serve the model on the QuietBox 2

On the QuietBox 2, one command pulls the model and its weights, then serves it:

tt serve mando2222/qwen3.8-27b-dflash2-p300x2-q4kv

That bundle holds Qwen3.8-27B with 8-bit weights and a 4-bit KV cache, sharded across the four chips so their memory pools together. The server speaks the OpenAI API, so anything built for that API can talk to it with a settings change and no code change. That covers most coding agents, chat front ends and scripts.

Note the QuietBox's address and the port tt serve reports. On the QuietBox, hostname -I prints the address. From here on I'll write it as QB2_IP:PORT.

Step 2: Install the tools on your Mac

Two installs. tt is Tenstorrent's command line tool, and its launch command is the part you need on the Mac. OpenCode is the coding agent.

uv tool install tenstorrent

For OpenCode, use the install guide.

Step 3: Connect them

tt launch opencode --url http://QB2_IP:PORT/v1 --force

tt asks the server what it is serving, shows you the change it wants to make to OpenCode's config, and waits for a yes. Then it writes a tenstorrent provider into ~/.config/opencode/opencode.json and starts OpenCode. If you ever want it gone, tt launch disconnect opencode removes what tt wrote.

The --force is there because tt can't see the QuietBox's capabilities from across the network. It looks the model up in its own catalog, finds no tool-calling support listed, and refuses to connect a coding agent. The model does support tool calling, and the QuietBox serves it that way. Until tt can ask the server directly, --force tells it you know what you're doing.

You should see something like this:

warning: opencode needs a model served with a vLLM tool-call parser, and the support list publishes none for Qwen3.8-27B. Continuing because --force was given.

tt launch opencode — connected
model             Qwen/Qwen3.8-27B (Qwen3.8-27B)
endpoint          http://QB2_IP:PORT/v1
tool-call parser  —
config            ~/.config/opencode/opencode.json (provider.tenstorrent)

Step 4: Check the connection before you trust it

Before any agent work, I send a prompt that tests only the connection:

opencode run -m tenstorrent/Qwen/Qwen3.8-27B \
  "Reply with exactly QB2_OK. Do not use any tools."

I like this test because it fails in a useful way. If QB2_OK comes back, your network, your model ID and your response handling are all correct.

If anything else comes back, the problem is upstream of any agent behavior. Stop debugging the config and go look at the server.

Step 5: Ask for something real

From a project directory:

opencode

My standard first prompt for any new coding model is:

make me a tetris clone

I like Tetris as a test because it looks easy but isn't. There are seven tetromino shapes. Rotation has to work, including wall kicks when a piece turns against the edge of the board. Collision detection has to be right in four directions. Clearing a line has to pull everything above it down. Scoring follows a known formula. If any one of those is subtly wrong, the game falls apart the moment you play it. I used to use Snake, but modern models pass it without trying.

What came back, just a little more than a minute later, was a single index.html. I never asked the agent to test its work, and it tested its work anyway: a piece lands at the bottom, a full row clears, rotation changes the shape, a wall stops a piece. All four passed.

Then I played it. It played like Tetris. I could make it my own from here.

The long way: write the config yourself

tt launch writes a minimal config. This is the file I wrote by hand, and it shows every setting tt leaves out. Put it at ~/.config/opencode/opencode.jsonc, and change the two values in capitals:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "qb2/qwen-qb2",
  "provider": {
    "qb2": {
      "name": "YOUR_NODE_NAME",
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://QB2_IP:PORT/v1"
      },
      "models": {
        "qwen-qb2": {
          "id": "Qwen/Qwen3.8-27B",
          "name": "Qwen3.8-27B",
          "tool_call": true,
          "reasoning": true,
          "interleaved": { "field": "reasoning" },
          "limit": { "context": 262144, "output": 16384 }
        }
      }
    }
  }
}

• qb2 and qwen-qb2 are names you choose. You type them on the command line.
• id has to match what the server reports. Check it with curl -fsS http://QB2_IP:PORT/v1/models. This is the value that goes over the wire, and a mismatch produces an error that doesn't point at the cause.
• baseURL keeps its /v1. The @ai-sdk/openai-compatible package expects the OpenAI route layout under it.
• tool_call is what lets the agent create files and run commands. Leave it on.
• reasoning and interleaved tell OpenCode where the model's thinking arrives in the response stream. That is where the "Thought: 338ms" lines in the output come from.
• limit should match the server's context and output limits.

This example assumes no authentication on the endpoint, which is fine on a network you control. Lock it down before you expose it anywhere else.

Let your agent do the wiring

tt launch already knows OpenCode, Qwen Code, Pi, Aider and Hermes: swap the name after launch. For anything else, your favorite agent can handle it. Give it the server and the port, and ask it to figure out the rest:

There is an OpenAI-compatible server at http://QB2_IP:PORT/v1.
Find out which model it serves, then configure <tool> to use it.

That works for OpenCode, Qwen Code and Hermes, and for just about anything else that speaks the OpenAI API. It works for the Emacs setup you haven't touched since 2019, for the Discord bot your friends keep asking you to write, and for a forty-year-old text adventure that has been waiting for a player. The one condition is tool calling: an agent that runs commands needs a model that can request them, and this one can.

What this test does and doesn't show

Tetris is a small, self-contained problem with a clear spec. A 27B model at 8 bits handles that well. I'd expect it to struggle more on a large codebase, where it has to infer the rules from context.

A single agent is also the least interesting use of a QuietBox 2, in my opinion. The same server can batch up to eight agents at once, and that is where it earns its keep on aggregate tokens per second.

Models have been able to write Tetris for years. What’s new is where the work happened. The prompt, the reasoning and the generated code all stayed on my network, and I can run that loop a thousand times for the price of the electricity.

Where to go next

• Point the same server at a bigger project and see where it starts to slip. I don't know where the limit is, and I suspect nobody does yet.
• Run several agents against the one server.
• Swap in another model or another agent. Nothing above is specific to Qwen3.8 or OpenCode. Trialing models with the same prompt is a good way to find your favorite.
• If you build a config for a different model, publish it to tt-model-manager.

Credit

I want to be clear that much of the work behind this model's speed and quality was done by other people. It is all open source, so I could take their work and combine it with mine.

• The model is Qwen3.8-27B from the Qwen team. Its layers alternate Gated DeltaNet, from Songlin Yang, Jan Kautz and Ali Hatamizadeh, with full attention.
• Running that hybrid on Blackhole is the qwen36 demo in tt-metal. Aniruddha Tupe did the bring-up, and Izajasz Wrosz, Miguel Tairum and others have made it faster since.
• The speculative decoding is DFlash2, a drafter from Inco AI that builds on DFlash by Jian Chen, Yesheng Liang and Zhijian Liu. Hyunggi Chang packaged it for the QuietBox 2, and my bundle is derived from his.

Getting here took three days, and most of that was testing. A small change at this level can have large side effects, so I changed one variable at a time. Plenty of results looked promising in a smoke test and failed under a real workload.

With a reliable coding agent running locally, my next project is whatever I want it to be. I can have an idea at the dinner table and wake up to a prototype in the morning.