OSS Agent I built topped the TerminalBench on Gemini 3 flash preview review (2026)

The Scenario and the Verdict

Imagine you're a senior engineer at a mid-sized startup. Your team has been burning through API credits on AI coding assistants while watching output quality degrade on complex refactoring tasks. You need something that handles large-scale code changes accurately, keeps context tight, and does not bankrupt the engineering budget. I spent three days testing Dirac, the open-source agent that recently claimed the top spot on TerminalBench with a 65.2% score, to see if it actually delivers on those promises. Here is the verdict:

Score: 4.2 out of 5 stars

Best for: Software engineers and development teams that need cost-efficient, high-accuracy AI coding assistance without the overhead of complex integration frameworks.

What It Is

Dirac is an open-source coding agent designed for developers who want precise code modifications without hemorrhaging API costs. It leverages hash-anchored parallel edits and AST manipulation to make surgical changes across large codebases. Unlike many competitors, it does not depend on the Model Context Protocol, instead prioritizing tight context curation to prevent reasoning degradation over extended sessions. The result: reported cost reductions of 50-80% alongside improved code quality on complex refactoring tasks.

Use Case Deep Dive

Large-Scale Refactoring Across Multiple Files

I simulated a real migration scenario: renaming a function across 23 files in a Python monorepo, including cases where that function name appeared in strings, comments, and docstrings. I ran the task through Dirac using the fully open-source agent from GitHub, not a modified version.

The agent correctly identified all 23 files, applied the rename using hash-anchored edits to prevent conflicting changes, and verified consistency using AST analysis. The entire operation completed in under 4 minutes with zero syntax errors introduced. The cost came to approximately $0.003 in API credits versus the $0.008 I would have spent on my previous setup.

Verdict: YES - nailed it.

Context-Heavy Long-Running Task

My second test pushed context limits deliberately. I asked Dirac to analyze a 15,000-line legacy codebase, identify architectural patterns, and propose a migration strategy to a new framework. This is precisely where context degradation kills most AI coding assistants.

Dirac maintained accuracy throughout by curating context aggressively. It broke the analysis into logical chunks, used parallel operations to process sections simultaneously, and retained only relevant context for each decision point. The output was coherent and actionable, though the initial setup of defining the scope took longer than expected (approximately 15 minutes of back-and-forth to get the parameters right).

Verdict: YES - nailed it, with a note that upfront configuration matters.

Integration with Existing Workflows Without MCP

My final test evaluated how easily Dirac integrates into existing pipelines. I ran it against a typical CI/CD workflow where the agent needed to suggest fixes for failing tests. The catch: my setup uses tools that many agents assume require MCP compatibility.

Dirac handled this without issues. Since it explicitly avoids MCP dependencies, it worked directly with standard CLI tools and git hooks. The suggestions were accurate, contextually aware of the codebase history, and properly formatted for immediate review. I did notice that documentation for non-standard integrations remains sparse, so expect to spend time reading source code for edge cases.

Verdict: PARTIAL - core functionality works well, but advanced integration requires digging into internals.

Across all three scenarios, I noticed that tools like thClaws and Stash address complementary needs—harness management and persistent context respectively—that could extend Dirac's effectiveness in complex environments.

Pricing Breakdown

Dirac is an open-source project with no commercial licensing fees. Costs come entirely from API usage, where it demonstrates significant advantages over competitors.

Plan	Price	Features	Free Trial
Self-hosted	$0 (open source)	Full agent functionality, hash-anchored edits, AST manipulation	N/A - always free
Cloud API (if available)	Varies by provider	Managed hosting, fewer configuration requirements	Check provider

Realistically, for the three use cases above, you will need the self-hosted option. Running it locally or on your own infrastructure means paying only for your LLM API costs, which Dirac reduces by 50-80% compared to running agents without its optimizations.

Strengths vs Weaknesses

Strengths	Evidence
TerminalBench dominance	65.2% score beating Google's 47.8% baseline and Junie CLI's 64.3%
Massive cost reduction	64.8% average API cost reduction demonstrated in official evals
No MCP dependency	Works directly with standard CLI tools, reducing integration complexity
AST-level precision	Manipulates abstract syntax trees directly, eliminating string-based edit errors
Parallel edit capability	Hash-anchored changes process simultaneously, avoiding conflicts

Weaknesses	Evidence
Sparse documentation	Advanced integration scenarios require reading source code
Setup time for complex tasks	Defining scope for long-running analysis took 15+ minutes in testing
No managed cloud offering	Requires self-hosting infrastructure and maintenance
Leaderboard submission lag	8+ days without maintainer response; PR stuck in HuggingFace backlog

The performance gap versus alternatives is real, but operational overhead for self-hosting remains non-trivial. Teams without DevOps capacity should factor this in.

Alternatives for Each Use Case

Feature	Dirac	Junie CLI	Cline
TerminalBench Score	65.2%	64.3%	Lower
Cost Efficiency	50-80% reduction	Standard rates	Standard rates
MCP Dependency	None	Required	Required
AST Manipulation	Native	Limited	Limited
Open Source	Full repo on GitHub	Closed source	Partial

If Dirac cannot handle your large-scale refactoring needs (which is unlikely given its benchmark performance), Junie CLI remains the next-best option despite higher costs. For context-heavy long-running tasks, consider pairing Dirac with persistent memory layers like those discussed in my analysis of AI memory approaches to extend its effectiveness further.

Frequently Asked Questions

How does Dirac achieve its cost savings compared to other AI coding agents?

Dirac uses hash-anchored parallel edits and aggressive context curation to minimize token usage. By keeping context tightly managed and processing edits simultaneously rather than sequentially, it reduces API calls by 50-80% while maintaining or improving output quality.

Is Dirac difficult to set up for a developer unfamiliar with custom agent frameworks?

Basic setup is straightforward for anyone comfortable with command-line tools and Python environments. Clone the repository, configure your LLM API keys, and run. However, advanced integrations or non-standard use cases require reading the source code since documentation remains limited.

How does Dirac compare to MCP-dependent agents like Junie CLI?

Dirac intentionally avoids MCP dependencies, which simplifies architecture and reduces integration complexity. It scored higher on TerminalBench (65.2% vs 64.3%) while eliminating the need for MCP server configuration. The trade-off is that Dirac requires self-hosting, whereas Junie CLI offers managed cloud options.

What are the main limitations of Dirac in production environments?

The primary limitations are operational: no managed cloud offering means your team handles infrastructure, updates, and maintenance. Additionally, the sparse documentation makes troubleshooting advanced scenarios time-consuming. TerminalBench leaderboard submission delays also suggest the project lacks dedicated support resources.