Factory Droid 1.0 scores 65.2% on Terminal-Bench 4

What changed

Factory released Droid 1.0 with programmatic tool calling as its default mode. The core shift moves away from sequential tool invocation. Rather than calling tools one at a time and receiving results back into the model’s context immediately, Droid now allows the model to write a program that executes hundreds of tool calls in a single request.

The base prompt size decreased by 37 percent, from 20,887 tokens to 13,055 tokens. Tool definitions shipped upfront dropped from 11 to just 2, with rarely used tools loading on demand instead. Factory reports that in typical production requests, 98 percent of input tokens come from cached content.

Droid implements programmatic tool calling through a Script tool. The model writes JavaScript code that runs in a sandbox with no file, network, or system access. Independent tool calls run concurrently within the program, and only printed output returns to the model. This approach builds on CodeAct research showing that acting through code outperforms JSON and text-based tool calls.

On Terminal-Bench 4, Droid scored 65.2 percent with Claude Opus 5.5. Factory ran comparative tests from October 23 to 28, 2026, executing 3 trials per task against other harnesses on the same model and tasks. Cursor and OpenCode achieved 62.1 percent, Devin 59.6 percent, and Claude Code 57.6 percent. On GPT-6.1 Sol, Droid reached 57.6 percent at $0.79 per passed task, while Codex scored 54.0 percent and OpenCode 51.0 percent.

Speed improvements also emerged. On Claude Opus 5.5, Droid takes 16 to 26 percent less time per passed task than competing harnesses. Token efficiency improved as well, using 17 percent fewer tokens than Claude Code on the same tasks. The desktop application’s first paint latency dropped from 1,839 milliseconds to 488 milliseconds.

Droid 1.0 ships as a desktop app for macOS and Windows, a terminal UI, and a Node SDK. Paid plans start at $20 per month. The harness works with any supported model, including user API keys, and can automatically select a cost-efficient model mix through Factory Router.

Why it matters

Programmatic tool calling fundamentally changes how agents handle complex, multi-step workflows. When tool results remain inside a program as variables rather than cycling back to the model, the context stays cleaner and the agent operates with less noise. Deterministic code execution allows workflows to run consistently without the risk that a model might skip steps or handle edge cases incorrectly.

Consider the operational implications. A linear cleanup task involving 151 issues required 312 total tool calls. Using direct tool calling with estimates of 3 to 10 calls per request, the task would need approximately 36 requests and consume around 3.1 million input tokens. The Script-based approach required 2 requests and roughly 61,000 tokens. A CI sweep checking 5,384 jobs across 547 runs typically would demand 59 to 187 direct requests but completed in 2 requests with programmatic tool calling. Less than 0.1 percent of tool results reached the model’s context.

This matters because it stacks cost and reliability advantages across long-horizon tasks. For teams running coding agents over hundreds of turns, fewer model requests mean lower expenses and faster execution. Cleaner context windows reduce the chance of model errors compounding across steps. Deterministic code prevents the agent from accidentally dropping planned steps due to model behavior.

The model-independent design addresses a broader economic concern. Rather than locking teams into one vendor’s harness optimized for a single model, Droid enables engineers to choose whichever frontier model offers the best value at any given moment. Factory uses an internal Agent Factory process where agents study benchmark failures and propose changes tested across every model family. Engineers review evidence before merging changes. This approach ensures improvements generalize across models rather than fitting quirks of a single model.

Cost differences compound at scale. Droid costs up to 24 percent less than competing harnesses on Claude Opus 5.5. Script mode cuts Droid’s cost by 15 percent on Claude Opus 5.5 compared to direct tool calling. These savings concentrate in the 12.5 percent of scripts making six or more tool calls, making efficiency gains particularly valuable for complex tasks.

What to test

Before adopting Factory Droid 1.0, verify key claims independently.

Terminal-Bench 4 scores are self-reported by Factory using its own testing methodology. Run trials on your codebase and models to confirm whether the 65.2 percent figure on Claude Opus 5.5 applies to your specific use cases.

Cost comparisons depend on task mix and current model pricing. The $4.73 per passed task on Claude Opus 5.5 and 15 percent cost reduction in Script mode were measured in Factory’s own sessions. Your costs will vary based on whether your tasks spawn many concurrent tool calls suitable for parallel execution. Recalculate against current API rates rather than relying on published figures.

Test bounded autonomy settings in your workflows. Droid triggers a nudge when identical tool calls repeat 3 times and stops the loop at 6 identical calls. Verify this safety feature does not interfere with legitimate retry logic or error-recovery patterns in your tasks.

The 98 percent cache hit rate on production requests assumes stable tool definitions. If your tooling changes frequently, cache efficiency will decline. Test cache performance with your expected tool evolution.

Sandbox security remains important for sensitive workflows. Factory states the JavaScript sandbox has no file, network, or system access, but verify this isolation model matches your threat requirements before processing sensitive code or data.

Token usage should be compared against your baseline harness. The 17 percent token savings versus Claude Code depend on prompt tuning specific to task types. Measure token consumption on representative workloads from your environment.

Note that performance varies by model. On GPT-6.1 Sol, Codex still takes 10 percent less time per passed task than Droid, suggesting the harness tuning favors Claude models. If your team uses primarily OpenAI models, this trade-off deserves careful evaluation.

The conclusion

Factory Droid 1.0 represents a meaningful structural shift in how coding agents handle tool use at scale. Programmatic tool calling is not a new concept, but making it the default and tuning a harness across multiple models rather than one gives it practical value. The 65.2 percent Terminal-Bench 4 score with Claude Opus 5.5 is solid, and the cost and token savings are quantified clearly enough to test independently.

The main limitation appears with GPT-6.1 Sol. Codex outperforms Droid by 10 percent on speed with that model, suggesting the harness tuning is stronger for Claude than for OpenAI’s current frontier model. This matters if your team standardizes on Sol or relies on multi-model deployment strategies.

The model-independent design offers genuine value to teams avoiding vendor lock-in or exploiting price competition between models. Factory’s internal Agent Factory process sounds promising, but remains opaque. You have only Factory’s word on what changes it recommends and tests.

Independent benchmarks on Terminal-Bench 4 or other coding agent harness comparisons would strengthen confidence in the reported gains. Monitor whether Script mode’s efficiency advantages persist as frontier models improve at reasoning over code. If models become better at planning, the cost benefit of deterministic programs may decrease.

For teams running long-horizon coding tasks and focused on cost efficiency, Droid 1.0 warrants testing, especially if you can measure performance on your actual workloads and models.

Related reading

• Nanbeige4.3-33B scores 80.9 on Terminal-Bench
• Agensh: Decentralized multi-agent harness for 1,024 agents
• Sterling finance research agent outperforms Claude Fable 5.1