Cline burned through dollars — why the agent burns money

Cline is designed as an autonomous agent: the user describes a task, the agent formulates a plan, executes steps, checks results, and iterates until completion. This fundamentally distinguishes it from chat assistants like ChatGPT or interactive editors like Cursor. And this very open-loop design explains uncontrolled consumption.

There are three main problems. The first is that each agent step is a separate round-trip to the LLM with full context. Cline sends to the model: a system prompt (several thousand tokens with instructions), the history of all previous messages, the content of all read files, the results of executed commands and tool calls. By the tenth step, the context swells to 100-200K tokens, and each subsequent request sends this entire volume again.

The second problem is loops. If the agent receives an ambiguous instruction or encounters an error that it cannot correctly interpret, it begins to repeat attempts. A typical pattern: "let me try again," "let me double-check," "perhaps I missed something." Each such iteration is 100-200K input + 5-10K output. Over 50 iterations overnight, this turns into 5-10M input + 250-500K output — tens of dollars for a single task.

The third problem is auto-approve tool calls. Cline has a mode in which the agent can execute commands without user confirmation. This is convenient for speed, but creates conditions for non-stop operation: the user clicked "start," went to sleep, and the agent performed 200 iterations overnight, each of which is billed as a full request to Claude Sonnet 4.5.

Real consumption figures (according to public user reports):

• Simple task (create one function from a description): 5-15 steps, ~500K-1M total tokens ≈ $2-4 on Anthropic.
• Medium task (refactoring a module of 3-5 files): 20-40 steps, ~3-5M total tokens ≈ $10-20.
• Complex task (implementing a feature with tests): 50-80 steps, ~10-15M total tokens ≈ $30-50.
• Looped task (agent got stuck in a loop): 100-300 steps, 30-80M total tokens ≈ $80-250.
• Overnight unsupervised run: unpredictable, average user reports — $50-500 per night.

The root cause is the cost of Claude Sonnet 4.5 from Anthropic. $3 per 1M input looks harmless until you start multiplying it by Cline's cyclical nature. For output, Anthropic charges $15 per 1M, and although there are fewer output tokens than input, output also accumulates over long cycles.

JoinGonka Gateway supports both API formats that Cline can use — OpenAI-compatible (/v1/chat/completions) and the native Anthropic Messages API (/v1/messages). Connecting through either of them yields identical economics: $0.001 per 1M tokens regardless of input/output, without hidden markups.

Comparison of typical tasks:

The main psychological effect is that the fear of loops disappears. Cline getting stuck in a loop on JoinGonka costs $0.05 instead of $165, and the worst-case scenario of an unsupervised overnight run is $0.20 instead of $700. This doesn't mean that loops can be ignored (they waste time and can corrupt files), but it moves from the category of "financial disaster" to "normal operating cost."

What's inside JoinGonka — the Qwen3-235B model with MoE architecture and 22 billion active parameters. On code benchmarks, it performs at the level of Claude Sonnet 4.5; on autonomous agent tasks with tool calling, it shows comparable success on the SWE-bench benchmark. More details about the model can be found in the article on Qwen3-235B. If you're interested in the general market context, check out the overview of the cheapest AI API in 2026.

An important detail about tool calling. Cline critically depends on the model's ability to correctly call functions — read_file, write_file, execute_command, browser. Qwen3-235B supports native tool calling through PR #767 in the Gonka repository with a threshold of 0.958 for call detection. In practice, this means that Cline through JoinGonka makes the same tool calls as through Anthropic, without degradation of functionality.

Cline is configured via the API Configuration panel in the VS Code extension itself. The extension supports several provider types, and two options are suitable for JoinGonka: "OpenAI Compatible" and "Anthropic."

Step 1. Get a JoinGonka API key. Open gate.joingonka.ai/register, register, get 10 million free tokens. Create an API key in the Dashboard (jg-xxx format).

Step 2. Open Cline settings. In VS Code, open the Cline panel (icon in the Activity Bar), click the gear icon or the "Settings" menu within the plugin.

Step 3a. Connect via OpenAI Compatible. In the API Provider dropdown, select OpenAI Compatible. Fill in the fields:

• Base URL: https://gate.joingonka.ai/v1
• API Key: your jg-xxx key
• Model ID: Qwen/Qwen3-235B-A22B-Instruct-2507-FP8

Step 3b. Alternative — via Anthropic. In API Provider, select Anthropic. Fill in:

• Anthropic Base URL: https://gate.joingonka.ai (without /v1)
• API Key: your jg-xxx key
• Model: leave default (claude-sonnet-4-5) — Gateway maps to Qwen3-235B automatically

Save settings and click "Test connection" — it should pass in 1-3 seconds.

Step 4. Loop protection. Even on JoinGonka, it's worth enabling reasonable limits — loops waste your time. In Cline's settings, set Max Requests Per Task to 30-50 for regular tasks and keep Auto-approve off until you're confident in the agent's stability for your task types.

Step 5. Verification. Give Cline a small task — for example, "read this file and explain what it does." If the agent successfully read the file (meaning tool calling works) and provided a meaningful response — the setup is complete. In the JoinGonka Dashboard, you'll see a receipt of used tokens in real time.

If you want to use other AI tools in parallel — the same JoinGonka key works with Cursor, Claude Code, Aider, Continue.dev. All of them are billed from a single balance.

Let's take three real usage scenarios for Cline and calculate the monthly costs when switching from Anthropic to JoinGonka Gateway.

Case 1: "Casual User." Runs Cline 2-3 times a week on medium tasks (refactoring, debugging, writing tests). Monthly consumption — ~30M total tokens.

• Anthropic: 30M × $0.005 (averaged input+output) ≈ $150/month.
• JoinGonka: 30M × $0.001 = $0.03/month. Savings — 5000 times.

Case 2: "Active User, full-time with Cline." Uses Cline daily for several hours on large tasks. Monthly consumption — ~200M total tokens (including rare loops).

• Anthropic: 200M × $0.005 ≈ $1000/month.
• JoinGonka: 200M × $0.001 = $0.20/month. Savings — 5000 times.

Case 3: "Team of 5, each with Cline." Active sessions for several developers plus several large autonomous runs per week. Monthly consumption — ~1B total tokens.

• Anthropic: 1B × $0.005 = $5000/month.
• JoinGonka: 1B × $0.001 = $1.00/month. Savings — 5000 times.

The main psychological shift when switching to JoinGonka is that Cline turns from an "expensive dangerous toy" into a "cheap working tool." You can safely experiment with autonomous modes, leave the agent to work on complex tasks without worrying about overnight bills. One looped run now costs $0.20, not $200.

On an annual horizon, a full-time user saves about $12000. A team of 5 saves about $60000. This is a budget for an additional developer, for servers, for marketing — real money freed up out of nowhere simply by changing the inference provider.

If you use multiple agentic tools — also check out the articles on OpenClaw and the general API quickstart: the same JoinGonka key works everywhere, and the total monthly bill for a team rarely exceeds a few dollars even under peak loads.

Practical recommendations for controlling loops. Even on JoinGonka, it's wise to have protection against a runaway agent. In Cline's settings, enable Max Requests Per Task (30-50 for regular tasks), Auto-approve only for safe operations (read_file, search_files), and always leave write_file and execute_command for manual approval. Loops waste your time — money is no longer wasted. These boundaries help quickly identify tasks where Cline cannot reach a solution and rephrase the prompt instead of endless iteration.

When Cline is better than Cursor / Claude Code and vice versa. Cline is stronger in long autonomous tasks where the agent needs to show initiative — something like "explore the project structure and suggest refactoring." Cursor is stronger in interactive sessions with a fast feedback loop — refactoring as you write code. Claude Code is a midpoint: more autonomous than Cursor, but less verbose than Cline. With JoinGonka Gateway, you can keep all three tools connected simultaneously with the same key, and choose the one that best suits a specific task — without worrying about three separate billings.