MiMo Code + JoinGonka Gateway: agente Xiaomi em modelos da rede Gonka

Passo 1: instalar o MiMo Code. Métodos oficiais do README do projeto:

# macOS and Linux
curl -fsSL https://mimo.xiaomi.com/install | bash

# Windows (PowerShell)
powershell -ep Bypass -c "irm https://mimo.xiaomi.com/install.ps1 | iex"

# via npm, on any system
npm install -g @mimo-ai/cli

O script instala o binário em ~/.mimocode/bin e adiciona esse diretório ao PATH pelo perfil do shell (a flag --no-modify-path desativa isso). Ele baixa a build do repositório da Xiaomi; se o download não funcionar, instale via npm —é o mesmo release, nos nossos testes os dois caminhos traziam a 0.1.15. Para verificar: mimo --version.

Passo 2: obter a chave. Cadastre-se em gate.joingonka.ai/register, confirme seu endereço e crie uma chave com o prefixo jg- na seção «Chaves de API». Uma única chave e um único saldo valem para todos os modelos da rede.

Passo 3: executar o instalador.

npx @joingonka/setup --tool mimo-code

O instalador vai pedir a chave —ela não é passada como argumento de linha de comando— e gravará os mesmos dois arquivos que o assistente do próprio provedor dentro do MiMo Code, só que já com o catálogo completo e os limites:

• registrará o provedor joingonka na configuração global ~/.config/mimocode/mimocode.jsonc (ou em mimocode.json ou config.json, se o MiMo Code já escrever lá): adaptador @ai-sdk/openai-compatible, endereço do gateway com /v1 e os três modelos da rede com janelas de contexto, tetos de resposta e suporte a ferramentas;
• guardará a chave no armazenamento de chaves próprio do MiMo Code —~/.local/share/mimocode/auth.json com permissões 600. A chave não fica na própria configuração, então você pode mantê-la tranquilamente em dotfiles;
• definirá o modelo padrão —o campo model— como DeepSeek V4 Flash, mas apenas se nenhum estiver selecionado ou se apontar para um modelo que saiu da rede. Não vai sobrescrever a sua escolha, nem mesmo em outra configuração global;
• salvará cópias dos arquivos anteriores, não tocará em provedores, chaves nem comentários de terceiros, e se um arquivo não puder ser lido não o sobrescreverá —vai parar e dizer o que corrigir;
• no final enviará uma requisição real ao gateway e dirá claramente se a chave, o endereço e o modelo foram aceitos.

O instalador leva em conta diretórios não padrão por conta própria: MIMOCODE_HOME, XDG_CONFIG_HOME, XDG_DATA_HOME e MIMOCODE_CONFIG. Outro modelo padrão é definido pela flag --model com as abreviações deepseek, glm ou minimax; para dotfiles e servidores há um modo sem perguntas:

JOINGONKA_API_KEY=jg-your-key npx @joingonka/setup --tool mimo-code --non-interactive

Se o MiMo Code estava em execução, reinicie-o: o novo provedor é carregado na inicialização.

Tudo o que o instalador faz dá para escrever à mão. São dois arquivos, e cada um tem sua função: o config descreve o provedor e os modelos, o auth.json guarda a chave. Quem liga os dois é o identificador do provedor — joingonka precisa bater nos dois arquivos. O config, ~/.config/mimocode/mimocode.jsonc:

{
  "$schema": "https://mimo.xiaomi.com/mimocode/config.json",
  "provider": {
    "joingonka": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "JoinGonka (Gonka)",
      "options": {
        "baseURL": "https://gate.joingonka.ai/v1"
      },
      "models": {
        "deepseek-ai/DeepSeek-V4-Flash-0731": {
          "name": "DeepSeek V4 Flash (Gonka)",
          "tool_call": true,
          "reasoning": true,
          "limit": { "context": 380000, "output": 32768 }
        },
        "zai-org/GLM-5.3-Flash": {
          "name": "GLM 5.3 Flash (Gonka)",
          "tool_call": true,
          "reasoning": true,
          "limit": { "context": 390000, "output": 8192 }
        },
        "MiniMaxAI/MiniMax-M2.7": {
          "name": "MiniMax M2.7 (Gonka)",
          "tool_call": true,
          "limit": { "context": 200000, "output": 8192 }
        }
      }
    }
  },
  "model": "joingonka/deepseek-ai/DeepSeek-V4-Flash-0731"
}

A chave, ~/.local/share/mimocode/auth.json com permissões 600:

{
  "joingonka": { "type": "api", "key": "jg-your-key" }
}

O modelo padrão é gravado como provider/model-id; o provedor é separado pela primeira barra, por isso identificadores da rede com barra própria são escritos como estão.

Onde mais a chave pode ficar. O README do MiMo Code também mostra a variante com a chave direto no config — options.apiKey. Funciona, mas aí a chave fica fácil de commitar junto com os dotfiles, e uma chave antiga esquecida ali vai sobrescrever a nova do auth.json — por isso o instalador remove o options.apiKey do bloco dele. No .mimocode/mimocode.jsonc do projeto, menos ainda: não coloque a chave ali.

Qual arquivo manda. Os globais config.json, mimocode.json e mimocode.jsonc o MiMo Code mescla nessa ordem, cada um sobrescreve o anterior. O resultado é impresso por mimo debug config, e os caminhos do config e das chaves no seu sistema, por mimo debug paths.

Você pode configurar seu próprio provedor sem arquivos, usando o assistente integrado. Na primeira execução no diretório do projeto, o MiMo Code pergunta se você confia na pasta (Yes, I trust this folder): o agente obterá permissão para ler, editar e executar arquivos nela. Em seguida, o comando /connect abre a lista Select provider: no topo, o acesso à plataforma Xiaomi MiMo, Codex e importação do Claude Code; abaixo, o catálogo de provedores; e ao final, + Custom provider. O assistente faz seis perguntas:

Em nosso teste, o assistente registrou o bloco do provedor com um modelo sem limites e dois campos que o instalador não possui: env com o nome da variável JOINGONKA_API_KEY, onde o MiMo Code também procurará pela chave, e options.setCacheKey: true. Isso funciona com o gateway, mas a configuração deve ser completada: sem limit, o comando mimo models joingonka mostrará uma janela de 1M de tokens. A maneira mais fácil é executar o instalador uma vez após o assistente — ele adicionará o catálogo completo com limites ao mesmo bloco.

Seleção de modelo. A seleção permanente é o campo model na configuração. Na interface, o modelo é alterado pelo comando /models, e para uma execução única, pelo flag -m. Quais modelos o MiMo Code enxerga no provedor e com qual janela trabalha é mostrado por mimo models joingonka — junto com o limite no qual o agente começará a comprimir o histórico:

joingonka/deepseek-ai/DeepSeek-V4-Flash-0731 — window 380K, compacts at 342K
joingonka/MiniMaxAI/MiniMax-M2.7 — window 200K, compacts at 180K
joingonka/zai-org/GLM-5.3-Flash — window 390K, compacts at 351K

O preço para todos os modelos da rede é o mesmo, então a escolha depende do comportamento. Foi assim que eles se saíram em nosso teste mimo run em uma tarefa — ler um arquivo e encontrar um erro:

Por que o DeepSeek V4 Flash foi escolhido como padrão, está explicado na análise do modelo.

Primeiro, confirme que o MiMo Code enxerga o provedor e a chave:

mimo models joingonka
mimo providers list

O primeiro comando lista os três modelos da rede com suas janelas, como no exemplo acima; o segundo imprime o caminho do armazenamento de chaves e a linha joingonka api. Depois, uma execução avulsa. Coloque no diretório do projeto um arquivo calc.py com um erro evidente — por exemplo, a área de um retângulo em que os lados são somados em vez de multiplicados — e peça para encontrá-lo:

mimo run "Read the file calc.py in the current project directory and tell me in one sentence whether it has a bug."

Na saída vão aparecer o agente e o modelo (> build · deepseek-ai/DeepSeek-V4-Flash-0731), a chamada da ferramenta (→ Read calc.py) e uma resposta objetiva, apontando a expressão errada. A flag --format json transforma a saída em um fluxo de eventos em que cada passo tem seu contador de tokens, e -m joingonka/<model-id> dispara a execução com outro modelo. No nosso teste, o ciclo «requisição → chamada de ferramenta → resultado → resposta» foi concluído pelos três modelos da rede.

A terceira verificação é do lado do gateway: no painel, em «Uso», a requisição vai aparecer no detalhamento «Por modelos», e no bloco «Por chaves» o horário da última requisição será atualizado.

Se algo der errado, o diagnóstico normalmente se lê direto na mensagem:

A ferramenta de agente gasta tokens de forma diferente de um chat: a cada frase sua, o MiMo Code adiciona um prompt de sistema, descrições de ferramentas e contexto de serviço do agente, e a tarefa ocupa vários passos. Em nossa execução, cada solicitação ao modelo consumiu 22-25 mil tokens de entrada, e a tarefa de "ler o arquivo e encontrar o erro" de dois passos custou aproximadamente 45-50 mil tokens — quase tudo é entrada. Portanto, o preço por token aqui é o que decide.

Através do JoinGonka Gateway, os tokens custam $0.0069 por milhão na entrada e $0.021 por milhão na saída — o preço é igual para todos os modelos da rede e é obtido nesta página de uma fonte em tempo real.

As estimativas na coluna da direita são baseadas nos preços de setembro de 2026. Para comparar — como se pode pagar por modelos no MiMo Code:

Sua própria estimativa de custo no MiMo Code para os modelos do gateway é igual a zero — nos registros deles não há o campo cost, e nos eventos --format json consta "cost": 0. O consumo real e o saldo estão no painel, nas seções "Uso" e "Faturamento".

Permissões. Na interface, o MiMo Code pede confirmação para ações de risco, mas no mimo run não há ninguém para perguntar — ele mesmo rejeita solicitações de acesso fora do projeto. Para ambientes descartáveis de confiança, existe a flag --dangerously-skip-permissions (ou a variável MIMOCODE_DANGEROUSLY_SKIP_PERMISSIONS=1): isso permite tudo o que não for proibido por uma regra explícita, apenas dentro de um container ou sandbox. Na interface, um modo semelhante é ativado durante a sessão via /skip-permissions.

Agentes. Por padrão, build funciona com o conjunto completo de ferramentas, plan apenas lê e analisa, e compose gerencia o processo desde a especificação até o código verificado; alternam-se com a tecla Tab.

Contexto longo. Ao atingir o limite da janela, o MiMo Code reconstrói o contexto a partir do último ponto de verificação, memória do projeto e mensagens recentes; o limite é calculado com base em limit.context. Pode-se comprimir antes usando o comando /context-limit, separadamente para cada modelo.

O que depende da conta Xiaomi. A entrada de voz (/voice) reconhece a fala usando o modelo da plataforma MiMo e está disponível após o login. O código, comandos e subagentes funcionam através do provedor conectado — em nosso teste, sem necessidade de login.

Imagens. Os modelos da rede são textuais: em /modalities deixe apenas texto para eles, e para capturas de tela, configure um segundo provedor com um modelo capaz de visão.

MiMo Code e OpenCode são parentes com configurações diferentes. Cada um possui seus próprios diretórios e arquivos, portanto a configuração de um não é transferida para o outro:

Versão. O projeto é atualizado frequentemente; para reprodutibilidade, fixe a versão: npm install -g @mimo-ai/[email protected] ou curl -fsSL https://mimo.xiaomi.com/install | bash -s — --version 0.1.15.

Existem agentes dos próprios laboratórios para as famílias atendidas pela rede: o MiniMax Code funciona no modelo do seu fornecedor MiniMax M2.7, e tanto a DeepSeek quanto a Z.ai (autores do GLM) possuem seus próprios agentes. Todos se conectam ao mesmo gateway com uma única chave.