How to build a cheap autonomous coding agent with kRouter

Cline, Cursor Composer, and Aider are great. They are also overkill if you just want a script that reads a file, calls an LLM, applies the patch, and commits.

You can build a usable coding agent in 50 lines of TypeScript, route it through kRouter, and run it on free providers for under $5/month.

The skeleton

import OpenAI from "openai";
import { readFile, writeFile } from "fs/promises";
import { execSync } from "child_process";
 
const client = new OpenAI({
  baseURL: "http://localhost:20128/v1",
  apiKey: "sk-krouter-local",
});
 
async function agent(file: string, instruction: string) {
  const original = await readFile(file, "utf-8");
 
  const response = await client.chat.completions.create({
    model: "kr/claude-sonnet-4.5",
    messages: [
      {
        role: "system",
        content:
          "You are a code editor. Return ONLY the complete new file content. No prose, no markdown fences.",
      },
      {
        role: "user",
        content: `File: ${file}\n\n${original}\n\nInstruction: ${instruction}`,
      },
    ],
  });
 
  const updated = response.choices[0].message.content!;
  await writeFile(file, updated);
  execSync(`git add ${file} && git commit -m "agent: ${instruction}"`);
  console.log(`✓ Updated ${file}`);
}
 
agent(process.argv[2], process.argv[3]);

That is it. Save as agent.ts. Run it:

npx tsx agent.ts src/utils.ts "add JSDoc to every exported function"

Why this works

The trick is that kRouter handles everything that would normally be complicated:

1. Auth. The agent uses one API key (sk-krouter-local). kRouter handles the OAuth refresh for Kiro, the API key rotation for GLM, etc.
2. Fallback. When Kiro rate-limits, kRouter silently switches to GLM. Your script does not need retry logic.
3. Format translation. Your script speaks OpenAI format. kRouter translates to whatever the underlying provider speaks.
4. RTK compression. Your script sends the raw file content. kRouter compresses it before billing time.

Making it agentic

Add a loop and a tool definition:

const tools = [
  {
    type: "function",
    function: {
      name: "read_file",
      description: "Read a file from the workspace",
      parameters: {
        type: "object",
        properties: { path: { type: "string" } },
        required: ["path"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "write_file",
      description: "Write a file to the workspace",
      parameters: {
        type: "object",
        properties: {
          path: { type: "string" },
          content: { type: "string" },
        },
        required: ["path", "content"],
      },
    },
  },
];
 
const messages = [{ role: "user", content: "Add a logout button to the navbar" }];
 
while (true) {
  const res = await client.chat.completions.create({
    model: "kr/claude-sonnet-4.5",
    tools,
    messages,
  });
 
  const msg = res.choices[0].message;
  messages.push(msg);
 
  if (!msg.tool_calls) break;
 
  for (const call of msg.tool_calls) {
    const args = JSON.parse(call.function.arguments);
    let result = "";
    if (call.function.name === "read_file") {
      result = await readFile(args.path, "utf-8");
    } else if (call.function.name === "write_file") {
      await writeFile(args.path, args.content);
      result = "written";
    }
    messages.push({
      role: "tool",
      tool_call_id: call.id,
      content: result,
    });
  }
}

That is a working agentic loop. About 80 lines total.

Monthly cost

Routed through kRouter with this combo:

1. kr/claude-sonnet-4.5    # Free
2. glm/glm-5.1             # $0.60/M
3. oc/<auto>               # Free safety net

A daily agent run for 30 days costs $3-5.

Compare to running a hosted SaaS agent platform for the same workload: $50-150.

Why kRouter is the missing piece for DIY agents

Most "build your own agent" tutorials skip the hard parts: auth rotation, rate-limit retries, format translation, and token cost control. They assume you have one API key and unlimited budget.

kRouter fills every gap:

• Auth rotation. Kiro uses OAuth with refresh tokens. GLM uses API keys. Qwen uses DashScope tokens. Your 50-line agent does not care -- it sends sk-krouter-local and kRouter handles the credential lifecycle for every provider behind the scenes.
• Automatic retry with backoff. When a provider returns 429, kRouter does not just retry blindly. The Zenith Score Engine marks the provider unhealthy, falls to the next tier, and returns to the original once it recovers. Your agent loop never sees the 429.
• RTK compression on tool outputs. Agentic loops are token-heavy because every tool call round-trip includes the full conversation history. RTK compresses tool outputs (file contents, command results) by 20-40% before they hit the billing meter. On a 10-iteration agent loop touching 8 files, that saves real money.
• Format translation across 9 formats. Your agent speaks OpenAI format. kRouter translates to Claude Messages API, Gemini, Vertex, Kiro's AWS CodeWhisperer format, Antigravity, Ollama, and the Responses API. One agent, every provider.

Scaling up: multi-file agent with streaming

The skeleton above works for single-file edits. For real-world agents that touch multiple files, add streaming so you see progress in real time:

const stream = await client.chat.completions.create({
  model: "kr/claude-sonnet-4.5",
  tools,
  messages,
  stream: true,
});
 
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta;
  if (delta?.content) process.stdout.write(delta.content);
  if (delta?.tool_calls) {
    // Handle streaming tool calls
  }
}

kRouter handles the SSE translation regardless of which provider serves the request. Kiro's AWS event-stream format, Gemini's chunked JSON, and Anthropic's SSE all get normalized into OpenAI-compatible data: {...} lines.

What you give up

Cline and Cursor Composer give you UI, diff review, command approval, and dozens of refined details. A 50-line agent gives you raw power but you babysit it.

For background automation (nightly code cleanups, weekly dependency upgrades, CI-driven refactors), the 50-line agent is great.

For interactive coding, use Cline through kRouter. Same backend, better UX.

The real advantage

The commercial agent platforms (Devin, Factory, Codegen) charge $50-500/month. They add orchestration, memory, and approval flows on top of the same LLM calls you are making.

With kRouter, you get the expensive part -- multi-provider routing, token compression, and auto-fallback -- for free. The orchestration layer is your 50-80 lines of TypeScript. The total cost is whatever your cheapest provider charges, minus RTK savings.

For a solo developer running a nightly cleanup agent: $3-5/month instead of $200+.

npm install -g @sifxprime/krouter
krouter -t

Full provider catalog at /providers. Combo strategies at /compare.