Knowledge Base Sections ▾
For Beginners
For Investors
- Where does GNK token value come from
- Gonka vs Competitors: Render, Akash, io.net
- The Libermans: from biophysics to decentralized AI
- GNK Tokenomics
- Risks and Prospects of Gonka: Objective Analysis
- Gonka vs Render Network: Detailed Comparison
- Gonka vs Akash: AI Inference vs Containers
- Gonka vs io.net: Inference vs GPU Marketplace
- Gonka vs Bittensor: A Detailed Comparison of Two Approaches to AI
- Gonka vs Flux: Two Approaches to Useful Mining
- Governance in Gonka: How a Decentralized Network is Managed
Technical
Analytics
Tools
- Cursor + Gonka AI - cheap LLM for coding
- Claude Code + Gonka AI - LLM for the terminal
- OpenClaw + Gonka AI - affordable AI agents
- OpenCode + Gonka AI - free AI for code
- Continue.dev + Gonka AI - AI for VS Code/JetBrains
- Cline + Gonka AI - AI agent in VS Code
- Aider + Gonka AI - pair programming with AI
- LangChain + Gonka AI - AI applications for pennies
- n8n + Gonka AI - automation with cheap AI
- Open WebUI + Gonka AI - your own ChatGPT
- LibreChat + Gonka AI — open-source ChatGPT
- Hermes Agent + Gonka AI — Autonomous Agent for Pennies
- Kilo Code + Gonka AI — AI-Agent in VS Code
- Roo Code + Gonka AI — Autonomous AI Agent in VS Code
- LlamaIndex + Gonka AI — RAG applications for pennies
- PydanticAI + Gonka — typed AI agents for pennies
- Vercel AI SDK + Gonka AI — AI applications in TypeScript for pennies
- TanStack AI + Gonka — AI applications in TypeScript for pennies
- API quick start — curl, Python, TypeScript
- JoinGonka Gateway — a full overview
- Management Keys — SaaS on Gonka
- Cheapest AI API: Provider Comparison 2026
- Cursor Pro request limit reached — real breakdown and cheap alternative
- Claude Code cheaper alternative — bill breakdown and switch
- Cline burned through dollars — why the agent burns money
- OpenClaw too expensive — why the agent burns tokens and how to save
- OpenRouter cheaper alternative — comparison vs JoinGonka Gateway
Tools
Kilo Code + Gonka AI — AI-Agent in VS Code
Kilo Code is an open-source AI agent extension for VS Code that autonomously writes and edits code, runs terminal commands, and reads and fixes dozens of files at once. The project combines the strengths of Cline and Roo Code and is evolving as a unified agent platform: in addition to the IDE extension, there are options for JetBrains and CLI. The key feature is modes (agents): Code (writes code), Plan (also known as Architect — plans architecture without edits), Debug (finds the causes of errors), and Ask (answers project-related questions). You can also create your own modes.
The problem is the same as with any agent — token consumption. Kilo Code sends file context, command output, and step history to the model; a single task can easily consume 10-100M tokens. At Anthropic prices ($3-15 per 1M), this amounts to $30-1500 per session — impractical for everyday use.
JoinGonka Gateway reduces the cost hundreds and thousands of times: the same session costs $0.01-1.00. Since Kilo Code is open-source and supports any OpenAI-compatible endpoint (as well as Anthropic-format with a custom base URL), connecting our gateway is a matter of a single setting. This transforms Kilo Code from an expensive demonstration into an everyday tool.
Step 1: Install Kilo Code and Get Your Key
Install Kilo Code: In VS Code, open Extensions (Ctrl+Shift+X), search for "Kilo Code" and click Install. After installation, the Kilo Code icon will appear in the sidebar. The extension is also available on Open VSX for builds without the Marketplace.
JoinGonka API key: If you don't have an account yet — register at gate.joingonka.ai/register, get 10M free tokens and create a key with the jg- prefix in Dashboard → API Keys. The same key works for both OpenAI-format (/v1) and Anthropic-format (/v1/messages) — the balance is shared.
Step 2: Configure Kilo Code (OpenAI Compatible)
Open the Kilo Code panel and go to the provider settings via the gear icon.
Method A — OpenAI Compatible (recommended). In the modern version of the extension, open Settings (gear icon) → Providers tab → Custom provider button at the bottom and fill in the dialog:
- Provider ID: any identifier, e.g.,
joingonka. - Display name: e.g.,
JoinGonka Gonka. - Base URL:
https://gate.joingonka.ai/v1 - API key:
jg-your-key - Models: add
Qwen/Qwen3-235B-A22B-Instruct-2507-FP8. Kilo automatically pulls the list of models from the/v1/modelsendpoint — you can select a model from the list instead of entering it manually.
Click Submit — the models will appear in the picker. In the old interface (VSCode Legacy), the path is shorter: API Provider → OpenAI Compatible, then the Base URL, API Key, and Model fields with the same values.
Method B — Anthropic-format. Our gateway also responds to the Anthropic API. Select API Provider → Anthropic, paste the key jg-your-key, check "Use custom base URL" and specify https://gate.joingonka.ai (without /v1 — Kilo will add /v1/messages itself).
Models and their output limits (all three are available right now):
| Model | Context | Max. output |
|---|---|---|
| Qwen/Qwen3-235B-A22B-Instruct-2507-FP8 (default) | 128K | 8192 |
| moonshotai/Kimi-K2.6 | 128K | 3072 |
| MiniMaxAI/MiniMax-M2.7 | 128K | 4096 |
In the custom provider dialog, for each model you can set Max Output Tokens and Context Window — set the values from the table for the selected model.
Verification: In the Kilo Code chat in Code mode, type "Create a hello.py file with a hello world function." The agent should offer a diff for approval and create the file. By default, Kilo Code requests confirmation before each action — this can be relaxed by allowing auto-execution for trusted operations.
Comparison of Agentic Session Costs
Kilo Code is an agentic tool: it doesn't just respond, but performs tasks entirely — reads files, writes code, runs tests, fixes bugs. Each step is an API call, and tokens accumulate quickly. Let's compare the cost of typical sessions via Anthropic Claude and via our gateway to the Gonka network:
| Task | Tokens | Anthropic Claude | JoinGonka Gonka |
|---|---|---|---|
| Simple bug fix | ~5M | $15 — $75 | $0.005 |
| New feature (2–3 files) | ~20M | $60 — $300 | $0.02 |
| Module refactoring | ~50M | $150 — $750 | $0.05 |
| Full development session (4h) | ~100M | $300 — $1,500 | $0.10 |
Through JoinGonka Gateway, input costs ~$0.0005 per 1M tokens, output is about three times more expensive — this is hundreds and thousands of times cheaper than Anthropic and OpenAI. Kilo Code becomes an everyday tool: you can run it for every ticket, every bug, and every feature, without worrying about the bill. At Anthropic prices, every run has to be carefully considered.
Model parameters: The default Qwen3-235B has a 128K token context window and a maximum response length of 8192 tokens. Kilo Code can request more, but the gateway will limit the output to the model's upper limit (Qwen — 8192, Kimi K2.6 — 3072, MiniMax-M2.7 — 4096). For long generations, the agent breaks the work into steps.
Modes and tool calling
The strong point of Kilo Code is its modes (called modes in the old extension, agents in the new one), which can be switched via a dropdown, the /agents command, or the hotkey Ctrl+.:
- Plan / Architect — discuss and design solutions without touching files. Convenient to run via the cheap Qwen3-235B: planning consumes a lot of context, and on our gateway, it costs pennies.
- Code — default mode: writes and edits code, applies diffs, runs commands.
- Debug — purposefully searches for the cause of a bug using logs and stack traces.
- Ask — answers questions about the codebase without making changes.
A separate Orchestrator mode in recent versions is considered deprecated: agents with full access to tools can now launch subagents themselves, without a dedicated orchestrator. User-defined modes for your scenarios are also supported.
Tool calling: Our gateway passes through native OpenAI function calling and Anthropic tool_use, and the selected models (Qwen3-235B, Kimi K2.6, MiniMax-M2.7) support tool invocation. This means that Kilo Code's agentic loop — file reading, editing, command execution, codebase indexing — works reliably on our models, without brittle parsing of text responses.