Crush + JoinGonka Gateway: Charm agent on Gonka network models

Step 1: install Crush. Official methods from the project README:

# Homebrew
brew install charmbracelet/tap/crush

# npm
npm install -g @charmland/crush

# Arch Linux
yay -S crush-bin

# Windows
winget install charmbracelet.crush

# Go
go install github.com/charmbracelet/crush@latest

The same README covers package repositories for Debian, Ubuntu, Fedora and RHEL, Nix and Scoop, and ready-made binaries are available on the releases page. To verify, run crush --version and you'll get a line like crush version v0.96.1.

Step 2: get a key. Sign up at gate.joingonka.ai/register, confirm your address, and create a key with the jg- prefix in the "API Keys" section. A single key and a single balance work for all models on the network.

Step 3: run the installer.

npx @joingonka/setup --tool crush

The installer will ask for your key — it isn't passed as a command-line argument so it doesn't end up in your shell history — and will do four things:

• write the joingonka provider into ~/.config/crush/crush.json: type openai-compat, the gateway address, the key as a literal, and three network models with context windows, response caps and prices per million tokens, which it pulls live from the gateway at install time — Crush uses these to calculate session cost. The file will be set to permissions 600;
• assign models: DeepSeek V4 Flash to the large slot, MiniMax M2.7 to small, and GLM-5.3 Flash will stay in the list for manual selection. It only does this if the large slot is empty or points to one of our models that has left the network; someone else's choice stays put, and the output will include a hint on how to switch;
• check that the choice takes effect: the model from the Crush interface is stored in a state file, and that file overrides the config — see the section on large and small;
• make a backup, leave the other providers and settings untouched, and finish with a live request to the gateway to immediately verify the key, address and model.

To set a different model, use the --model flag with the shorthand deepseek, glm or minimax; an explicitly specified model is always written. The installer handles non-standard directories the same way Crush itself does: CRUSH_GLOBAL_CONFIG for the config, CRUSH_GLOBAL_DATA for the state file, plus XDG_CONFIG_HOME and XDG_DATA_HOME. For servers and scripts there's a non-interactive mode, where the key is taken from an environment variable:

JOINGONKA_API_KEY=jg-your-key npx @joingonka/setup --tool crush --model glm --non-interactive

Crush's primary format is now crushrc, but the installer writes crush.json: all versions understand it. If you already have a crushrc, Crush will merge both files, crushrc wins on key conflicts, and the installer itself leaves it alone.

Everything the installer does can be written by hand. Here's a working ~/.config/crush/crush.json — this is the file we ran through the gateway:

{
  "$schema": "https://charm.land/crush.json",
  "providers": {
    "joingonka": {
      "name": "JoinGonka (Gonka)",
      "type": "openai-compat",
      "base_url": "https://gate.joingonka.ai/v1",
      "api_key": "jg-your-key",
      "models": [
        { "id": "deepseek-ai/DeepSeek-V4-Flash-0731", "name": "DeepSeek V4 Flash (Gonka)",
          "context_window": 380000, "default_max_tokens": 32768,
          "can_reason": true, "supports_attachments": false },
        { "id": "MiniMaxAI/MiniMax-M2.7", "name": "MiniMax M2.7 (Gonka)",
          "context_window": 200000, "default_max_tokens": 8192,
          "can_reason": false, "supports_attachments": false },
        { "id": "zai-org/GLM-5.3-Flash", "name": "GLM-5.3 Flash (Gonka)",
          "context_window": 390000, "default_max_tokens": 8192,
          "can_reason": true, "supports_attachments": false }
      ]
    }
  },
  "models": {
    "large": { "provider": "joingonka", "model": "deepseek-ai/DeepSeek-V4-Flash-0731" },
    "small": { "provider": "joingonka", "model": "MiniMaxAI/MiniMax-M2.7" }
  }
}

Crush accepts only strict JSON: a comment or a trailing comma and it won't start. The pricing fields (cost_per_1m_in, cost_per_1m_out, and the two cache fields) are only needed for the cost counter: the installer fills in the gateway's live price there, and without them Crush still works and shows zero — only an editor with the schema from $schema will flag them as required.

The same provider in crushrc format — that's plain Bash with Crush's built-in commands. The file ~/.config/crush/crushrc:

provider add joingonka \
  --name "JoinGonka (Gonka)" \
  --type openai-compat \
  --base-url "https://gate.joingonka.ai/v1" \
  --api-key "${JOINGONKA_API_KEY:?set JOINGONKA_API_KEY}"

model add joingonka/deepseek-ai/DeepSeek-V4-Flash-0731 \
  --name "DeepSeek V4 Flash (Gonka)" \
  --context-window 380000 --default-max-tokens 32768 --can-reason true

model add joingonka/MiniMaxAI/MiniMax-M2.7 \
  --name "MiniMax M2.7 (Gonka)" \
  --context-window 200000 --default-max-tokens 8192

model add joingonka/zai-org/GLM-5.3-Flash \
  --name "GLM-5.3 Flash (Gonka)" \
  --context-window 390000 --default-max-tokens 8192 --can-reason true

model large joingonka/deepseek-ai/DeepSeek-V4-Flash-0731
model small joingonka/MiniMaxAI/MiniMax-M2.7

Here a model is named in the provider/model-id form: the provider name comes before the first slash, and after it comes the network identifier exactly as is. The ${JOINGONKA_API_KEY:?…} form keeps the key out of the file, but without an exported variable Crush won't start — better an error at startup than requests with an empty key.

In Crush, you don't choose a single model for everything; you choose for two slots:

The third network model, the reasoning-focused GLM-5.3 Flash, is chosen for complex logic, keeping in mind that its response limit is 8192 and part of that is used for reasoning — see details in the model overview. For a single run, the model is specified by its full name: crush run -m joingonka/zai-org/GLM-5.3-Flash "…". All available names can be listed via crush models joingonka.

State file. The model selected in the interface via ctrl+l is not saved by Crush in crush.json, but in a machine-specific state file: ~/.local/share/crush/crush.json, or on Windows — %LOCALAPPDATA%\crush\crush.json. This file takes precedence over both the user config and crushrc: Crush reads them in order: /etc/crush/crush.json → ~/.config/crush/crush.json → ~/.config/crush/crushrc → state file, with each subsequent one overriding the previous. Higher priority is given only to project-specific settings — crush.json or crushrc in the project directory. The command crush dirs will show where the files are located on your machine.

In our run, we opened the model selection menu — the “JoinGonka (Gonka)” provider appears there marked as “✓ Configured” — and selected MiniMax M2.7. Crush replied with “Large model changed to MiniMax M2.7 (Gonka)” and wrote to the state file:

{"models":{"large":{"model":"MiniMaxAI/MiniMax-M2.7","provider":"joingonka","max_tokens":8192}}, …}

Now this model overrides what is written in crush.json. The installer recognizes this situation and behaves differently:

• without --model it does not touch the state file — that is your working selection — but explicitly warns which model Crush will actually start with: Heads-up: Crush will still start with joingonka/MiniMaxAI/MiniMax-M2.7, not joingonka/deepseek-ai/DeepSeek-V4-Flash-0731. It will do the same if GLM-5.3 Flash or another provider's model is selected in the interface;
• with an explicit --model it modifies exactly one entry in the state file — models.large — after saving a backup, and reports the change. Otherwise, the flag would have no effect silently. After such a run, our Crush instance opened using the model specified in the flag.

First, make sure Crush can see the provider:

crush models joingonka

You should get three lines back:

joingonka/MiniMaxAI/MiniMax-M2.7
joingonka/deepseek-ai/DeepSeek-V4-Flash-0731
joingonka/zai-org/GLM-5.3-Flash

Next, do a one-off run without the interface. Drop a file with an obvious bug into your project directory and ask it to find the bug:

crush run -q "Read calc.py and tell me in one sentence whether it has a bug."

The agent should call the file-reading tool on its own and give a substantive answer, including the line number. In our run, all three models on the network found the bug, and the task took 20-40 seconds. The -q flag hides the waiting indicator. In crush run mode, all tool calls are approved automatically, so run it in your own project. In the regular interface (the crush command), the active model is visible in the status line: ◇ DeepSeek V4 Flash (Gonka) via JoinGonka (Gonka). Crush stores sessions and the log in the project's .crush directory, isolated from git by its own .gitignore; the log is printed by crush logs. On the gateway side, the request is visible in the dashboard: the "Usage" section, broken down by "By model" and "By key".

If something goes wrong, the diagnosis is usually readable straight from the message:

An agent spends tokens differently than a chat: for every phrase you send, Crush adds a system prompt and descriptions of its tools, and a task usually takes several turns. In our test run, each request to the model carried about 11,500 input tokens, and the task of "reading a file and finding an error" took two to three requests and 23,000–35,000 tokens, almost entirely input. Therefore, the price per token is the deciding factor here.

Via the JoinGonka Gateway, tokens cost $0.0069 per million on input and $0.021 per million on output—the price is the same for all network models and is fetched on this page from a live source.

The estimates in the right column are based on prices as of September 2026. For comparison—how you can pay for models in Crush:

The cost counter in the Crush interface calculates using price fields from the config. It captures the gateway price at the moment of installation, and the dollar price on the network fluctuates with the GNK exchange rate, so the counter is an approximation. Precise consumption and balance are available in the dashboard, under the "Usage" and "Billing" sections. Why DeepSeek V4 Flash is set to the large slot by default is explained in detail in the model review.

Permissions. By default, the Crush interface asks for permission before calling a tool. The --yolo flag turns off all prompts at once, while individually trusted tools are listed in the config:

# crushrc
permissions allow view ls grep

# crush.json
"permissions": { "allowed_tools": ["view", "ls", "grep"] }

Recall that crush run approves everything on its own. This is a property of Crush and does not depend on the model provider.

Request timeout. Crush aborts a request if no fragment of the response arrives from the model for a long time: in version 0.96.1 that's two minutes of silence (the documentation says 60 seconds, but in the code and in our test it's two minutes). The keep-alive pings the gateway uses to hold the connection do not reset this counter — we verified this on a local test bench. Meanwhile, during peak hours the gateway waits up to 150 seconds for the first token from the network, so the margin is worth raising:

# crushrc
option request-timeout 300

# crush.json
"options": { "request_timeout": 300 }

Commit signatures. Commits and pull requests created by Crush get the line Assisted-by: Crush:<model> and the note "Generated with Crush" by default. If you don't want that:

# crushrc
option attribution-trailer-style none
option attribution-generated-with false

# crush.json
"options": { "attribution": { "trailer_style": "none", "generated_with": false } }

Metrics. Crush sends pseudonymous usage statistics to the developers — metadata only, no prompts or responses. It's disabled with the variable CRUSH_DISABLE_METRICS=1 or DO_NOT_TRACK=1. The gateway, for its part, does not store the contents of prompts or responses — only usage aggregates remain in the statistics.

The config is code. Crush executes both crushrc and crush.json with the privileges of your shell: $(…) in a key field will run on load, and a project-level crushrc will fire as soon as you open Crush in that directory. Don't run the agent in someone else's repository without reading its configs.