Reason Agent 1.1: A New Coding Agent Harness with Batch Tool Calling and 22% Lower CostsArticle · digest for October 20
Minimalist assembly of graphite and white blocks with parallel batch-processing pathways
Article3 sections≈ 4 min

Reason Agent 1.1: A New Coding Agent Harness with Batch Tool Calling and 22% Lower Costs

When an autonomous coding agent tackles a task in a large codebase, its workflow usually feels like a slow walkie-talkie conversation: find a file -> wait for response -> read the file -> wait -> run a test -> wait for error logs. Every single step appends another message to the conversation history, bloating the context to hundreds of thousands of tokens.

The result is a double hit: eye-watering API bills and "tool-selection fatigue," where the model starts losing track of its own earlier steps.

The team at Reason Machines tackled this at the architectural level with Reason Agent 1.1. On Artificial Analysis's independent Coding Agent Index, Reason Agent 1.1 paired with a standard GPT-6 Astra model scored 65.1 vs. 62.5 for the default Codex setup—while cutting average token spend per task by 22%.

Let's look at how the harness pulls that off.

The Core Weapon: Code as a Tool (Batch Tool Calling)

Instead of firing off dozens of single network tool calls, the model switches into codemode. It writes a compact JavaScript or Python script that runs the entire batch of operations locally in a single inference round: locating files, reading the relevant lines, running tests, and returning only the filtered signal to the context window.

We've already seen where unchecked token burn in agentic development leads, and batching tool calls turns out to be the cleanest cure.

Harness Configuration with Prefix Caching

Here is a working reason.config.json that enables static context caching and loop protection:

{
  "harnessVersion": "1.1",
  "engine": {
    "provider": "openai",
    "model": "gpt-6-astra",
    "promptCaching": {
      "enabled": true,
      "cacheStaticPrefix": true,
      "minTtlSeconds": 300
    }
  },
  "execution": {
    "mode": "code_batch",
    "runtime": "node20-isolated",
    "maxBatchSteps": 12,
    "timeoutMs": 45000
  },
  "guardrails": {
    "loopWatchdog": {
      "maxConsecutiveErrors": 3,
      "onThreshold": "escalate_strategy"
    }
  }
}

Example Batch Operation Inside the Runtime

And here is what an agent-generated script looks like when it locates components, reads them, and runs the test suite in one shot:

import { workspace, tester } from "@reason/agent-runtime";

export default async function batchOperation() {
  // 1. Fast glob search for target components
  const targetFiles = await workspace.glob("src/components/**/*.{tsx,ts}");
  
  // 2. Batch read without polluting conversation history
  const fileContents = await Promise.all(
    targetFiles.map(async (file) => ({
      path: file,
      content: await workspace.readFile(file)
    }))
  );

  // 3. Run tests and return only failing assertions
  const testResults = await tester.runSuite("npm test -- --bail");

  return {
    scannedCount: targetFiles.length,
    failingTests: testResults.failures.map(f => ({ file: f.file, error: f.message })),
    recommendationTarget: fileContents.filter(f => f.content.includes("useUserProfile"))
  };
}
A Watchdog Against Infinite Loops

The Loop Watchdog module tracks repeated build or test failures. If the agent trips over the exact same error three times in a row, the harness forces a strategy escalation instead of burning tokens in circles.

Reason Agent 1.1 proves an important point: you don't always need to wait for the next generation of foundation models to make coding agents smarter and cheaper—cleaning up the tool execution harness gets you there right now.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 2