Cline is burning money — why the agent spends so much

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

There are three main problems. First, each agent step is a separate round-trip to the LLM with full context. Cline sends to the model: the system prompt (several thousand tokens with instructions), the history of all previous messages, the contents 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 cycles. If the agent receives an ambiguous instruction or encounters an error it cannot correctly interpret, it starts repeating attempts. A typical pattern: 'let me try again', 'let me double-check', 'maybe 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 where 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 ran 200 iterations overnight, each of which is charged as a full request to Claude Sonnet 4.6.

Actual consumption figures (based on public user reports):

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

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

JoinGonka Gateway supports both API formats that Cline uses: OpenAI-compatible (/v1/chat/completions) and the native Anthropic Messages API (/v1/messages). Connecting through either provides identical economics: $0.0047 per 1M input tokens and $0.014 per 1M output tokens, with no hidden fees.

Comparison of typical tasks:

The main psychological effect is the removal of the fear of loops. A Cline loop on JoinGonka costs $0.24 instead of $165, and the worst-case scenario with an unsupervised night run is $0.96 instead of $700. This does not mean loops can be ignored (they consume time and can corrupt files), but it shifts the situation from a "financial catastrophe" category to "normal operating cost".

Inside JoinGonka is the Kimi K2.6 model with MoE architecture. On code benchmarks, it holds up to the level of Claude Sonnet 4.6; for autonomous agent tasks with tool calling, it shows comparable success on the SWE-bench benchmark. More about the model in the article about Qwen3-235B. If you are interested in the overall market context, check out the review of the cheapest AI API in 2026.

An important detail about tool calling. Cline critically depends on the model's ability to call functions correctly—read_file, write_file, execute_command, browser. Kimi K2.6 supports native tool calling. In practice, this means Cline via JoinGonka performs the same tool calls as via Anthropic, without any functional degradation.

The easiest way to get the settings is to use the JoinGonka installer — it will display the values to paste into the Cline panel (the extension stores the config in the UI, so the installer shows the values rather than writing a file):

npx @joingonka/setup --tool cline

Without a flag, npx @joingonka/setup will prompt you to select a tool (Claude Code, OpenClaw, or Cline). Then enter the displayed values into the panel manually:

Let's take three real-world usage types of Cline and calculate monthly expenses when switching from Anthropic to JoinGonka Gateway.

Case 1: "Casual user". Launches Cline 2—3 times a week for medium tasks (refactoring, debug, writing tests). Monthly consumption — ~30M total tokens.

• Anthropic: 30M × $0.005 (average input+output) ≈ $150/mo.
• JoinGonka: 30M × $0.0099 ≈ $0.297/mo. Savings — approx. 500x.

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/mo.
• JoinGonka: 200M × $0.0099 = $1.98/mo. Savings — approx. 500x.

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

• Anthropic: 1B × $0.005 = $5000/mo.
• JoinGonka: 1B × $0.0099 = $9.9/mo. Savings — approx. 500x.

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

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

If you use several agentic tools, also check out the articles about 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 at peak loads.

Practical recommendations for loop control. Even on JoinGonka, it is reasonable to keep protection against a runaway agent. Enable in Cline settings the options 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 on manual approval. Loops waste your time — but they no longer waste your money. These limits help quickly identify tasks where Cline cannot find a solution and reformulate the prompt instead of endlessly iterating.

When Cline is better than Cursor / Claude Code and vice versa. Cline is stronger in long-term autonomous tasks where the agent must take initiative — something like "explore the project structure and suggest refactoring". Cursor is stronger in interactive sessions with a fast feedback loop — refactoring while writing code. Claude Code is the middle point: more autonomous than Cursor, but less verbose than Cline. With JoinGonka Gateway, you can keep all three tools connected simultaneously via the same key and choose the one best suited for a specific task — without worrying about three separate billings.