> ## Content Index
> Fetch the complete content index at: https://theseguysknow.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# Best AI Coding Harnesses 2026: TGK Top 10 and Tier List
- URL: https://theseguysknow.io/best-ai-coding-harnesses/
- Published: 2026-10-05T11:34:46.000Z
- Updated: 2026-10-05T11:34:46.000Z
- Description: DeepSeek Harness won our TGK discussion, while Hermes divided the room. Here are our Top 10, the full 18-tool tier list and what the benchmarks show.
- Author: Larson Bryce
- Tags: AI & Tech, AI Tools & Models, #how we know

People started sharing personal AI harness tier lists in our TGK chat, and Hermes somehow ended up being both S+ and “slop” in the same conversation. If you thought programmers would be more reasonable about their software than football fans are about their clubs, you would have enjoyed that discussion.

## Quick Answer

DeepSeek Harness is our current winner, largely because the people using it in our group value its flexibility with different models and the control it gives them over how the agent works. Hermes follows for persistent work and memory, while Factory Droid and Devin also placed highly in the members' personal lists.

An AI harness is the software that lets a model work with your files, terminal, tools and project history. Two harnesses can use the same model and still behave differently, which is why choosing Claude, GPT or DeepSeek only answers part of the question.

The ranking below reflects our group's experience and editorial judgment. Published tests give us useful checks on those preferences, including plenty of results where someone other than our favourite wins.

## TGK Top 10

We care most about whether an agent finishes useful work, understands corrections and recovers when something fails. Model flexibility, memory, tools and interface matter because they affect that experience, while the cost includes the time you spend rescuing or repairing the result.

| Rank | Harness          | Why it makes our Top 10                                                                         |
| ---- | ---------------- | ----------------------------------------------------------------------------------------------- |
| 1    | DeepSeek Harness | Our chat's winner for model flexibility and control over the agent                              |
| 2    | Hermes           | A favourite for persistent memory and work across sessions, despite complaints about complexity |
| 3    | Factory Droid    | Strong support for a packaged coding and delegation workflow                                    |
| 4    | Devin            | A highly rated option for clearly defined delegated tasks                                       |
| 5    | Oh My Pi         | Specialist tools and flexibility that appeal to our more technical users                        |
| 6    | Pi Agent         | A leaner setup with encouraging results in several published comparisons                        |
| 7    | Prime Agent      | An interesting way to organise long tasks, context and delegated work                           |
| 8    | Grok Build       | The most striking report in our chat of long runs without intervention                          |
| 9    | Codex            | Useful controls for building and reviewing, with mixed opinions about speed                     |
| 10   | Cursor Agent     | Convenient inside the editor, even for members who aren't in love with its agent                |

DeepSeek takes first place because it won people over in use, and that experience deserves to lead our own ranking. The positions below it combine the personal lists with the reasons raised in the conversation and the research; nobody in the group submitted this exact order as a unanimous vote.

## Our combined tier list for now

The full list includes all 18 tools discussed in the original rankings. We've combined the personal placements with the follow-up arguments, so a strongly defended tool can move away from the lowest grade somebody gave it. These are our current preferences, with disagreement kept visible wherever it matters.

| Tier                | Harness          | What sits behind the placement                                                  |
| ------------------- | ---------------- | ------------------------------------------------------------------------------- |
| S+                  | DeepSeek Harness | The winner of the TGK conversation                                              |
| S                   | Hermes           | Strong personal support, alongside complaints about feature overload            |
| S                   | Factory Droid    | Consistently high placements across the shared lists                            |
| S                   | Devin            | The same A-to-S support as Droid                                                |
| S, limited feedback | CodeWhale        | An S placement from one member, with less explanation than the other favourites |
| A                   | Oh My Pi         | A strong fit for users who want more specialised tools                          |
| A                   | Pi Agent         | A lean, adaptable option with useful benchmark support                          |
| A                   | Prime Agent      | High personal placement and an approach to long tasks worth investigating       |
| B                   | Grok Build       | Personal grades ranged from C to A, with unusually strong praise for autonomy   |
| B                   | Codex            | Mixed B/C placements, balanced by praise for its app and controls               |
| B                   | Cursor Agent     | Useful enough to keep using, with reservations about agent performance          |
| B                   | Claude Code      | A-to-C disagreement; criticism of its style doesn't erase its strengths         |
| C, disputed         | Command Code     | Low initial grades challenged by members who put it closer to A/B               |
| C                   | OpenCode         | Modest enthusiasm in our chat, with stronger supporters elsewhere               |
| D                   | ZCode            | The personal lists ranged from C to F                                           |
| D                   | Kimi Code        | A lower personal placement that shouldn't be confused with a model ranking      |
| E                   | Qwen Code        | D/F placements and little positive discussion to justify moving it up yet       |
| E, disputed         | Antigravity      | Low placements met by an emphatic defence from another member                   |

CodeWhale's S stays visible because it was someone's experience, although we haven't included it in the Top 10 shortlist without a fuller explanation of what earned that grade. Command Code gets more room because its defender gave a specific reason, while Antigravity remains the clearest example of people having completely different experiences with the same product family.

## What an AI harness does

One member asked the question that made the rest of the conversation easier to follow:

> “I still don't understand what a good harness is. To me every harness is exact same thing, the only difference is the models.”

The model produces the reasoning and proposed actions, while the harness decides how it receives instructions, what information it sees and which tools it can use. In a coding environment, that includes reading files, applying edits, running commands and tests, managing the conversation and deciding when the agent needs your permission.

Imagine asking an agent to fix a login form. It has to find the relevant files, understand the failure, make a change and check whether the form now works without breaking something else. If its harness feeds back a useful error message and lets it edit the right section cleanly, the model has a reasonable chance of correcting the problem. If the useful information is buried in output or an earlier requirement disappears during compression, the same model may spend the next half-hour fixing the wrong thing.

Someone in the group explained this through a mechanic's toolbox: a huge collection sounds helpful until finding the right tool becomes half the job. A smaller, well-chosen set can make the work easier, while a specialist may need equipment that everyone else would happily leave in the cupboard.

That is why [our AI model ranking](https://theseguysknow.io/best-ai-models/) can't simply be reused as a ranking of coding products. A model's capabilities still matter, but the surrounding software can help it use those capabilities or make the work unnecessarily awkward.

## Why DeepSeek Harness is our pick

The enthusiasm was strong enough that someone eventually asked, “What's up with everyone ranking DeepSeek harness the highest? Is it actually that good?” The answer from its supporters centred on how well it could work with different models, including ones from other companies, and how much room it gave them to change the setup.

That makes the name slightly misleading for a newcomer. Praising DeepSeek Harness doesn't mean the group has decided DeepSeek's own model is better than every Claude or OpenAI model; its [provider documentation includes Anthropic, OpenAI and compatible custom APIs](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/user/guide/providers.md?ref=theseguysknow.io). You can be impressed by Opus or Astra inside DSH without seeing any contradiction.

Its [architecture is built around replaceable plugins](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/architecture.md?ref=theseguysknow.io), including the model adapter, tool registry, session log and agent loop. In plain English, much of the machinery that governs the agent can be changed without rebuilding the whole product. That explains why it interests people who have already tried the obvious coding assistants and want more say in how their next one behaves.

The practical attraction is being able to keep an environment you like while changing models or adjusting the parts that get in your way. For the technically confident users in our discussion, that freedom is a substantial part of what makes a harness good.

There are still reasons to be selective about recommending it. The [official project remains a developer preview](https://github.com/deepseek-ai/deepseek-harness?ref=theseguysknow.io), so breaking changes and setup work belong in the decision. If you're happy with your current tool and don't want to spend time configuring another one, our enthusiasm doesn't create a problem you need to solve.

DeepSeek remains our number one after looking at the benchmarks, even though those benchmarks don't give it a clean sweep. They help explain which combinations deserve testing and where our favourite can be beaten.

## What the benchmarks say

The most useful comparison keeps the model and task fixed, then changes the harness. Even then, versions, reasoning settings, provider routing and the available tools can affect the result, so the setup needs to travel with the percentage.

[Terminal-Bench](https://www.tbench.ai/?ref=theseguysknow.io) tests agents working in a terminal environment, while [SWE-bench Pro](https://labs.scale.com/leaderboard/swe%5Fbench%5Fpro?ref=theseguysknow.io) focuses on resolving repository issues. A leaderboard using one fixed harness is largely comparing models; a leaderboard mixing harnesses and models is comparing complete combinations. [CursorBench](https://cursor.com/cursorbench?ref=theseguysknow.io) helps assess model configurations on tasks drawn from Cursor sessions, but its scores don't establish whether Cursor beats every competing coding app.

### Composio tested work across apps

Composio [ran eight harnesses with DeepSeek V4 Flash](https://composio.dev/content/best-agent-harness-deepseek-v4-flash?ref=theseguysknow.io) on 30 workflows involving services such as Sheets, Calendar and GitHub, checking the resulting app state.

| Harness     | Passed tasks         | Reported success rate |
| ----------- | -------------------- | --------------------- |
| Pi Agent    | 20 of 30             | 66.7%                 |
| Prime Agent | 15 of 24 scored runs | 62.5%                 |
| Oh My Pi    | 17 of 30             | 56.7%                 |
| Claude Code | 16 of 30             | 53.3%                 |
| Codex       | 16 of 30             | 53.3%                 |
| DeepAgents  | 16 of 30             | 53.3%                 |
| Hermes      | 15 of 30             | 50.0%                 |
| OpenCode    | 14 of 30             | 46.7%                 |

Pi posted the highest rate, although [its reasoning settings and provider routing differed](https://composio.dev/content/pi-vs-omp?ref=theseguysknow.io); six Prime runs were unscored. Composio identified Oh My Pi as having the highest comparable pass rate.

Those are useful results for app workflows, rather than a direct measurement of repository coding. DeepSeek Harness wasn't part of this eight-tool test, so the table cannot establish that Pi beat DSH.

### FrontierHarness compared coding and terminal tasks

[Runta's FrontierHarness evaluation](https://runta.com/blog/introducing-frontierharness-eval/?ref=theseguysknow.io) used Kimi K3 across 12 configurations and 30 tasks drawn from Terminal-Bench and DeepSWE. These are selected results from its September release.

| Configuration             | Success rate | Reported median cost per pass |
| ------------------------- | ------------ | ----------------------------- |
| Codex                     | 66.7%        | $3.47                         |
| DeepSeek Harness Creator  | 63.3%        | $3.28                         |
| Claude Code               | 63.3%        | $18.34                        |
| Pi                        | 60.0%        | $2.43                         |
| DeepSeek Harness Standard | 60.0%        | $3.46                         |
| DeepSeek Harness Minimal  | 56.7%        | $4.72                         |

Codex led on completion, while DSH Creator matched Claude Code's pass rate at a much lower reported cost. DSH Minimal was fastest by median runtime, illustrating how changing the configuration can change what the same harness is good at.

This was Runta's evaluation through a shared third-party gateway, with one attempt per task and configuration. It compares those setups with Kimi K3, which leaves room for a different result with Claude or GPT.

### A broader Terminal-Bench comparison gave another result

The [Maka project's nine-harness evaluation](https://github.com/apache/maka/blob/main/docs/eval/terminal-bench-2.1-deepseek-v4-flash-nine-arm.md?ref=theseguysknow.io) used DeepSeek V4 Flash across all 89 Terminal-Bench 2.1 tasks.

| Harness          | Passed tasks | Success rate |
| ---------------- | ------------ | ------------ |
| Codex            | 73 of 89     | 82.0%        |
| Maka             | 69 of 89     | 77.5%        |
| Pi               | 66 of 89     | 74.2%        |
| DeepSeek Harness | 65 of 89     | 73.0%        |
| ZCode            | 63 of 89     | 70.8%        |
| Reasonix         | 60 of 89     | 67.4%        |
| OpenCode         | 58 of 89     | 65.2%        |
| Kimi Code        | 53 of 89     | 59.6%        |
| Claude Code      | 49 of 89     | 55.1%        |

DSH ran after the original cohort, with affected tasks rerun following infrastructure repairs. The report therefore treats this as a descriptive comparison, and the numbers belong to its selected final attempts.

Codex and Pi deserve credit here, while ZCode's result is a useful challenge to its low personal placements in our group.

### Changing the model can change the winner

An [October preprint examining model and harness combinations](https://arxiv.org/abs/2610.00917?ref=theseguysknow.io) compared 66 configurations across three benchmarks. On its subset of 63 Terminal-Bench 4 tasks that didn't require H100 GPUs, the selected results looked like this:

| Harness          | Claude Opus 5 | GPT-6 Astra |
| ---------------- | ------------- | ----------- |
| OpenHands        | 57.1%         | 49.2%       |
| DeepSeek Harness | 34.9%         | 52.4%       |
| Pi               | 30.2%         | 60.3%       |
| Claude Code      | 49.2%         | Not tested  |
| Codex            | Not tested    | 55.6%       |

Pi did well with Astra and much worse with Opus on these tasks, while OpenHands showed the reverse pattern. The [released results](https://github.com/liyix/finding-the-right-fit?ref=theseguysknow.io) also put Claude Code first among the tested Claude configurations on the other two benchmarks.

A [separate study using 80 private tasks](https://arxiv.org/abs/2609.11987?ref=theseguysknow.io) found no statistically resolved average advantage between the native harnesses and the alternative it tested, which is another reason to avoid promising a dramatic gain every time someone changes tools.

Taken together, these tests give us reasons to try different combinations without pretending one benchmark can settle everyone's workflow. Our preference for DeepSeek survives that comparison because it includes the control and working experience our members value; someone prioritising a particular measured task may reasonably choose a different winner.

## Why Hermes divides the group

“Hermes gets the boost cause I use it more” was one of the most honest comments in the discussion. Knowing a tool well can improve what you get from it, although familiarity can also make you more forgiving of things a newcomer finds annoying.

[Hermes puts persistent memory and reusable skills at the centre of its design](https://github.com/nousresearch/hermes-agent?ref=theseguysknow.io), which suits someone who wants an assistant to carry useful knowledge across sessions. The enthusiasm for its [desktop app](https://hermes-agent.nousresearch.com/docs/user-guide/desktop?ref=theseguysknow.io) also makes sense: it uses the same core configuration, sessions, skills and memory, but presents the work differently from the CLI.

The objections were equally specific, with one member finding the amount of functionality overwhelming and others questioning what happens after long conversations get compressed. Hermes's [context documentation describes summarising older material](https://hermes-agent.nousresearch.com/docs/developer-guide/context-compression-and-caching?ref=theseguysknow.io), keeping recent content and allowing earlier information to be retrieved. That helps manage a growing conversation, but a summary can still omit a detail you later need.

A [May issue involving compression and Telegram session handling](https://github.com/NousResearch/hermes-agent/issues/20470?ref=theseguysknow.io) documented a loop caused by stale session state and is now closed. It gives the concern a concrete example without justifying a claim that the current product is generally broken.

Hermes stays near the top because its supporters are getting something useful from that persistent workflow. The people who call it overloaded aren't obliged to enjoy it, and “Hermes is slop” becomes a much more interesting criticism when the person explains which part keeps wasting their time.

## Pi and Oh My Pi suit different kinds of work

Pi's appeal is that its [core stays comparatively small and extensible](https://github.com/earendil-works/pi?ref=theseguysknow.io). You choose your model and add extensions, skills or templates as needed, rather than starting with every possible capability already present. Planning and subagents aren't built into that core, although extensions can supply them.

There is also a responsibility that matters before recommending Pi to everyone: it has no built-in permission system and runs with the rights of its process. Someone who needs a restricted environment has to provide that isolation themselves, so a comfortable setup for an experienced developer can be an unnecessarily awkward first choice for a beginner.

Oh My Pi builds a more substantial toolkit around that starting point. Its [repository documents code execution, semantic code tools, debugger access and subagents](https://github.com/can1357/oh-my-pi?ref=theseguysknow.io), giving it a clearer purpose for people who need to inspect a running program or make precise changes across a project.

One member's work involved kernels, gambling models and trading workflows, which is quite a different day from asking an agent to make a landing page. Their preference for OMP makes sense in that setting, and it would be silly to dismiss those tools as clutter simply because another developer doesn't need them.

We put OMP above Pi in our personal shortlist because that specialist use mattered in the conversation. Pi's stronger showing in some published tests remains a good reason for someone else to reverse the order, especially if they want fewer moving parts.

## Factory Droid and Devin make delegation more appealing

Factory Droid and Devin both landed between A and S in the personal lists, which gives them a stronger base of support in the group than some of the louder arguments might suggest. Their attraction is easier to explain when you already have a defined piece of development work to hand over.

Factory's [terminal workflow includes persistent sessions and missions, resumable work and access to transcripts and tool calls](https://factory.com/product/cli?ref=theseguysknow.io). Those capabilities matter when an agent runs for a while and you want to return to a result you can inspect, rather than reconstructing its actions from a cheerful final message.

[Devin can write and run code, use a browser and let you inspect or take over its environment](https://docs.devin.ai/get-started/devin-intro?ref=theseguysknow.io). Its documentation recommends clear completion criteria and straightforward verification, which is how we'd begin too: a bounded bug, a migration or a ticket whose acceptance conditions you can check.

That makes both products easier to recommend when the job is already understood. If you're still deciding what the product should do, handing over a vague assignment won't remove those decisions; you will need to make them as the work develops.

## Why Prime Agent made the list

Prime Agent received an A in the group and earns space here because its [approach to context and delegated work differs from a conventional chat loop](https://www.primeintellect.ai/blog/prime-agent?ref=theseguysknow.io). It uses a persistent Python environment through which the model can work with information, tools and other agents, giving long tasks somewhere to keep useful state.

That interests us because repeatedly summarising a giant conversation isn't the only possible way to organise the work. Being able to inspect and operate on stored information programmatically could help on tasks that involve a lot of material, although the benefit still depends on whether the model uses that structure well.

Its own report includes a particularly revealing failure: while playing Factorio, the agent discovered a way to spawn resources instead of earning them, then used its refinement process to improve the cheating. A system can become better at pursuing the measured objective while getting further away from what the person intended.

That is a more useful reason to keep Prime in the conversation than calling it self-improving and leaving the phrase unexplained. We like the direction, but the checks around a task still need to distinguish successful work from finding a convenient loophole.

## Codex and Claude Code still have a place

The complaints about Codex were familiar: one member found it slow, while others liked its app, side chats and customisation. Another considered it substantially better than Claude Code, which is why a low-ish position in our group's list shouldn't be read as a dismissal.

OpenAI's [documented engineering workflow](https://developers.openai.com/blog/mastering-codex-remote-for-engineering?ref=theseguysknow.io) includes side chats, worktrees, steering and review. Those controls are useful when you want to ask a question, change direction or inspect a patch while the broader task continues, and they help explain why somebody might keep choosing Codex despite frustration with its pace.

We also have [TGK's own experience building an app with Codex as a non-developer](https://theseguysknow.io/building-an-app-with-codex-non-developer/), which involved real progress alongside browser checks, corrections and decisions about what the app should become. A capable assistant still needs someone who knows what they are trying to make and can recognise when the result has missed it.

Claude Code attracted a sharper comment: “Claude Code is only up there if you haven't used any other harness.” The complaints behind that line concerned “Claudese,” verbose communication and system prompting that the member found annoying to work around.

Those are valid reasons to prefer another environment, but the claim about everyone else's experience goes too far. Anthropic provides [settings and project instructions](https://code.claude.com/docs/en/settings?ref=theseguysknow.io) that allow customisation, and the comparative results earlier in this article include configurations where Claude Code performs strongly.

Developer Fabio Akita's [account of using Oh My Pi and OpenCode](https://akitaonrails.com/en/2026/05/25/first-impressions-using-oh-my-pi-and-opencode/?ref=theseguysknow.io) favoured Claude Code and OpenCode for ordinary coding, almost the opposite of some opinions in our chat. He also found different tools catching different issues during code review, which makes more sense than expecting one favourite to expose every mistake.

Codex remains in our Top 10 and Claude Code in B because we can recognise their usefulness without sharing the assumption that the two biggest names must automatically occupy the first two places.

## Why people keep using Cursor while complaining about it

One member had been spending more time in Cursor and still rated its agent in C, a combination that only seems contradictory if you assume frequency of use means complete satisfaction. A familiar editor can make a product worth keeping even when you regularly disagree with what its agent does.

Cursor makes our Top 10 because working with files, edits and reviews in the same place can reduce the effort around a task. That convenience won't matter equally to someone who spends most of their day in a terminal, which helps explain why it sits lower in this particular group than its popularity might suggest.

The bigger promise of an agent that works independently still needs checking. A [February post on Cursor's forum](https://forum.cursor.com/t/share-your-experience-with-long-running-agents/151697/11?ref=theseguysknow.io) described stopping a CSS-to-Tailwind migration after about 30 hours as the agent kept improving its own tooling. The user had requested a large one-shot migration and also praised its persistence, so the account is more nuanced than a simple complaint about a useless product.

It is nevertheless a good example of why the next question after “it worked for hours” should be what happened to the work you asked for.

## What Grok Build's long runs tell us

“Codex is slow for me, Grok Build is a really well thought out product” was a direct endorsement, followed by the more interesting claim: “The only for me where 10+ hr tasks went without interventions.”

That experience deserves its place in our ranking because constant handholding is one of the things that makes an agent stop feeling useful. If somebody can leave a substantial task running and return to usable work, that changes what they can delegate.

The [Grok Build repository describes a terminal agent that edits files, runs commands, searches the web and manages long-running tasks](https://github.com/xai-org/grok-build?ref=theseguysknow.io), with interactive and headless operation. Those capabilities fit the report, although we don't have the task and final output behind that particular ten-hour run, so we can't turn it into a measured reliability claim.

There is another part of the product's history worth keeping in view. In July, [Cereblab documented earlier Grok Build versions uploading entire repositories and Git history](https://cereblab.com/?ref=theseguysknow.io), including material the agent had not been asked to open. The researcher now marks that behaviour fixed and reports retesting after the upload was disabled.

The fix changes the present assessment, while the incident remains a reason to understand what a coding tool sends off your machine. Grok Build earns B and a place in our Top 10 through the positive experience in the group, with that trust history still part of the decision.

## Command Code and Antigravity deserve the argument

Command Code's defender gave us something more useful than another unexplained letter: “Putting Command Code in F with Antigravity feels off.” They pointed to efficiency and taste-1, which they felt made it closer to A or B.

The company's [taste documentation describes learning from accepted, rejected and edited work](https://commandcode.ai/docs/taste?ref=theseguysknow.io) to build a profile of preferences. That gives the recommendation a concrete basis, particularly for someone tired of repeating the same style corrections. Whether it saves enough time in your project still has to be demonstrated, but the feature is substantial enough to make an automatic F look poorly explained.

Our combined C acknowledges both sides of that discussion, with more uncertainty than the letter alone can show. Someone who finds that preference system useful could reasonably put it much higher.

Antigravity was even more divisive, with low placements followed by the statement: “Antigravity is miles ahead of Codex. It's not even close.” Google's [documentation describes a common harness across several interfaces](https://www.antigravity.google/docs/home?ref=theseguysknow.io), but a shared core doesn't make every interaction identical. The CLI, editor and other controls affect how you inspect the work and intervene when it goes wrong.

Its E reflects the low personal placements that started our discussion, while the defence remains a reason to try it on a real task before accepting the group verdict. One enthusiastic user doesn't prove everyone else wrong, and two disappointed users don't establish that everybody will have the same experience.

## The other tools in our tier list

OpenCode received modest grades in our chat, although its [support for different model providers](https://opencode.ai/docs?ref=theseguysknow.io) and stronger advocates outside the group make it worth keeping on a shortlist. Akita's experience gives a useful counterweight to the modest enthusiasm in our group, particularly for readers who want to keep their choice of models open.

ZCode, Kimi Code and Qwen Code sit lower on much thinner feedback, so those positions deserve more caution than the arguments around our favourites. ZCode's Terminal-Bench result is strong enough that its D should make you ask what went wrong for the particular user before dismissing the product.

Their positions should also stay separate from opinions about the models associated with them. A low placement for Kimi Code says something about that member's experience with the coding product; it doesn't establish that Kimi is a weak model in every other harness.

## How to judge a harness on your own work

Start with a task you understand well enough to verify, such as fixing a specific bug or changing an existing feature, and give each tool the same brief in a separate copy of the project. Where possible, keep the model, reasoning settings and spending limits comparable, then check the result before reading too much into which agent sounded more confident.

The useful questions concern what it changed, whether the relevant tests pass, what it missed and how often you had to rescue it. For a long run, decide what completion means before leaving it alone, otherwise an agent can spend hours improving its plan or building supporting tools while the original job remains unfinished.

More features can help, but they can also interfere with the task. A [September study of harness components](https://arxiv.org/abs/2609.32459?ref=theseguysknow.io) found benefits from structured tool use and task-specific subagents, while some compression and generalist-subagent configurations hurt repository-generation performance. The result depends on how those capabilities are used, which is why a feature checklist can't settle the choice.

Count your own time when comparing the bill, because an apparently cheap run can become expensive once you spend the afternoon repairing it. Subscriptions, API use and the cost of running the finished product are separate expenses too, as [our AI-built app cost breakdown](https://theseguysknow.io/ai-built-app-running-costs/) explains.

## Final Verdict

DeepSeek Harness takes first place for TGK because it was the winner in our conversation and its flexibility addresses something our more experienced users care about: choosing the model and adjusting the environment around it. Hermes, Factory Droid and Devin follow for different kinds of persistent or delegated work, while Pi and Oh My Pi remain strong choices for people who know how much tooling they want.

Composio's results give Pi and OMP credit, and the additional coding comparisons give Codex plenty of reasons to remain in the conversation. We can accept those findings without replacing our own experience with whichever benchmark we opened last.

The arguments become useful when somebody explains what the tool let them finish, what it kept getting wrong and why they preferred working in it. DeepSeek is our pick for now, but if another harness works better with your model and your projects, there is no reason to make your day harder out of loyalty to our list.

## FAQ

### What is the best AI coding harness according to TGK

DeepSeek Harness is our current first choice, based on the TGK group's experience and its flexibility with models and agent configuration. That preference includes how people like to work, so it can differ from the winner of a specific benchmark.

### Can DeepSeek Harness run Claude or OpenAI models

Yes, its provider documentation includes Anthropic and OpenAI alongside compatible custom APIs. Authentication still matters: the documented Models interface does not yet support OAuth providers such as Codex, so you shouldn't assume an existing consumer subscription covers a separate API connection.

### Why does Composio have different winners

Composio's eight-harness test measured defined app workflows with a particular model, and DeepSeek Harness wasn't included in that comparison. Our ranking also considers the group's experience, preferred tools, model flexibility and working environment, which gives it a different basis.

### Is the combined tier list an average of benchmark scores

No, it combines personal rankings and the discussion around them into a current editorial list. Averaging percentages from different benchmarks would mix different tasks, models and test conditions, producing a number that doesn't reliably describe any real setup.

### Which harness should a beginner try

Codex or Claude Code are reasonable starting points for building a project with regular review, while Cursor makes sense if its editor fits how you want to work. DeepSeek Harness and the Pi family become more attractive when you know what you want to configure and are comfortable managing that setup.

---

#### Sources

****TGK**

**Personal tier lists and discussion shared in the TGK programming group.*

- [Best AI models](https://theseguysknow.io/best-ai-models/).
- [Building an app with Codex as a non-developer](https://theseguysknow.io/building-an-app-with-codex-non-developer/), 28 September 2026.
- [AI-built app running costs](https://theseguysknow.io/ai-built-app-running-costs/), 1 October 2026.

****Benchmarks and research**

- [Terminal-Bench](https://www.tbench.ai/?ref=theseguysknow.io).
- [Scale SWE-bench Pro](https://labs.scale.com/leaderboard/swe%5Fbench%5Fpro?ref=theseguysknow.io).
- [CursorBench](https://cursor.com/cursorbench?ref=theseguysknow.io).
- [Composio's eight-harness DeepSeek V4 Flash comparison](https://composio.dev/content/best-agent-harness-deepseek-v4-flash?ref=theseguysknow.io), 11 August 2026, and its [Pi versus Oh My Pi configuration details](https://composio.dev/content/pi-vs-omp?ref=theseguysknow.io), 1 September 2026.
- [Runta's FrontierHarness evaluation](https://runta.com/blog/introducing-frontierharness-eval/?ref=theseguysknow.io), 1 September 2026.
- [Maka's nine-harness Terminal-Bench 2.1 evaluation](https://github.com/apache/maka/blob/main/docs/eval/terminal-bench-2.1-deepseek-v4-flash-nine-arm.md?ref=theseguysknow.io), checked 5 October 2026.
- [Finding the Right Fit](https://arxiv.org/abs/2610.00917?ref=theseguysknow.io), 1 October 2026, and its [released configurations and results](https://github.com/liyix/finding-the-right-fit?ref=theseguysknow.io).
- [Harness or Model](https://arxiv.org/abs/2609.11987?ref=theseguysknow.io), 8 September 2026.
- [Beyond the Model](https://arxiv.org/abs/2609.32459?ref=theseguysknow.io), 26 September 2026.

****Independent assessments and user accounts**

- [Fabio Akita on Oh My Pi and OpenCode](https://akitaonrails.com/en/2026/05/25/first-impressions-using-oh-my-pi-and-opencode/?ref=theseguysknow.io), 25 May 2026.
- [Cursor forum account of a long-running migration](https://forum.cursor.com/t/share-your-experience-with-long-running-agents/151697/11?ref=theseguysknow.io), 14 February 2026.
- [Cereblab's Grok Build investigation and fix updates](https://cereblab.com/?ref=theseguysknow.io), July 2026.
- [Hermes compression and Telegram session issue](https://github.com/NousResearch/hermes-agent/issues/20470?ref=theseguysknow.io), May 2026, subsequently closed.

****Product documentation**

- [DeepSeek Harness repository](https://github.com/deepseek-ai/deepseek-harness?ref=theseguysknow.io), [architecture](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/architecture.md?ref=theseguysknow.io) and [model providers](https://github.com/deepseek-ai/deepseek-harness/blob/master/docs/user/guide/providers.md?ref=theseguysknow.io).
- [Hermes repository](https://github.com/nousresearch/hermes-agent?ref=theseguysknow.io), [desktop app](https://hermes-agent.nousresearch.com/docs/user-guide/desktop?ref=theseguysknow.io) and [context compression](https://hermes-agent.nousresearch.com/docs/developer-guide/context-compression-and-caching?ref=theseguysknow.io).
- [Pi repository](https://github.com/earendil-works/pi?ref=theseguysknow.io).
- [Oh My Pi repository](https://github.com/can1357/oh-my-pi?ref=theseguysknow.io).
- [Factory terminal workflow](https://factory.com/product/cli?ref=theseguysknow.io).
- [Devin introduction](https://docs.devin.ai/get-started/devin-intro?ref=theseguysknow.io).
- [Prime Agent introduction and evaluation](https://www.primeintellect.ai/blog/prime-agent?ref=theseguysknow.io), 5 August 2026.
- [Codex engineering workflow](https://developers.openai.com/blog/mastering-codex-remote-for-engineering?ref=theseguysknow.io).
- [Claude Code settings](https://code.claude.com/docs/en/settings?ref=theseguysknow.io).
- [Grok Build repository](https://github.com/xai-org/grok-build?ref=theseguysknow.io).
- [Command Code taste-1 documentation](https://commandcode.ai/docs/taste?ref=theseguysknow.io).
- [Antigravity documentation](https://www.antigravity.google/docs/home?ref=theseguysknow.io).
- [OpenCode documentation](https://opencode.ai/docs?ref=theseguysknow.io).

##