Haven't gone through full PDF as its very detailed, few things have resonated with me so far.
Basically if a Car A is performing better (be it speed, milage or in general sense) than Car B, then it is not necessarily because its engine. It could be because of better tires, better gearbox, lighter body, better usability of features, etc.
You can implement an AI feature (like AI for BI) in different ways even with the same model - via ReAct-loop, or plan-and-execute, or hybrid. You can make it stateless, stateful, RAG-based, etc. depending upon whether you want to prioritize result accuracy or depth of analysis. You can use LLM to generate either intent (requires lesser reasoning) or the queries itself (requires much more capable model).
Your harness can adapt to the underlying model's native capabilities, or can make up for its absence, e.g. query generation in above example requires your model to have MOE capabilities but intent generation wouldn't.
Anyone that's into auto racing as a hobby will tell you the engine is the last thing you should modify unless your whole goal is to get into the guts of engine mechanics.
But if you just want to improve lap times it's way less of a priority than brakes, tires, suspension setup, cooling to keep everything happy, etc.
I'm not a car guy but would it be fair to see that your maximum possible performance is bounded by the engine, but the average performance gains are from tuning the rest of the vehicle?
Kind of like if your RAM has to constantly page, you would see much more improvement from upgrading your RAM than overclocking your CPU?
Cool study, we definitely need more principled studies on the role of harnesses. I'd also say that there aren't too many benchmarks where the more complicated harnesses consistently outperform extremely simple agents. But I'm also biased, because I wrote https://github.com/swe-agent/mini-swe-agent/ , which is probably the most minimal agent out there (it started as just 100 lines, all included), and it's used in a lot of benchmarks like DeepSWE, terminalbench, programbench (seems like it's still top of the ranking for TB3, but wasn't evaluated with the best models on TB4).
Minimal agents also allow room for more focused add-on tools/infra. I'm working on a context management layer[1] and it's very difficult to do well. In our benchmarking, we've observed simple harnesses like Stirrup[2] outperforming more elaborate ones.
I'd really love to see more studies about effectiveness of AI in general. As in, what works best and how to use it and such.
Because I feel that the technology and space is - so - hyped and fast moving that a lot of cultish feeling rituals seem to pop up, none of which are backed by evidence. Anthropic openly recommend giving the agents.md file an architectural overview of the code, and the one time this was studied they found the opposite - that the agents.md file is best for concrete commands about how to build stuff and such, and - not - huge overviews. This was, and still is, the official recommendation from Anthropic as far as I can tell.
And then there are the benchmarks, how feel vague and not concrete, and everyone kind of knows they're not the best cuz you can't just assign these tools one fixed number ( for multiple reasons ), but everyone still looks at them and compares them.
People share skills and superpowers and plugins and mcps and very, very few of them have and kind of proof they do much at all.
It all feels a bit weird to me, and I've been on the lookout for exactly these kinds of studies more lately, because I think having this research, even if not done on the exact newest models or not the exact, newest thing, are still - vastly - superior to the alternative.
I think that generally speaking, the tighter the feedback loop, the better AI performs. Ask it to do things that are fast and easy to check and I suspect not much else matters. That's why AI's eating programming but has mitigated success elsewhere, feedback loops in the digital world are orders of magnitude faster.
The various “minimal” agents (at least Pi, mini SWE, dsh minimal) seem to benchmark quite differently and none is clearly better in all cases. Do you have any thoughts about why?
I would expect the agent loop and system prompt to be basically the same. Is it the precise semantics of the tools (and how closely they match what a particular agent was trained on) or something else?
> Planning improves success at additional cost for weaker models but mainly reduces cost, with small decreases in success rate, for stronger models.
> Predefined tools raise success rates for models with weak bash control, whereas bash-only yields higher success at lower cost for bash-capable models, most clearly on shell-centric task types.
> context management extends execution trajectories without substantially altering agent behavior and is most beneficial under tight context budgets
> planning sustains the trajectories of models that abandon tasks too early and trims repeated verification in models that verify too long
> structured tools support models with limited shell proficiency, while bash-only enables capable models to combine multiple code modifications in a single tool call
Seems fairly intuitive to me, based on feeling. But also fairly kind of obvious; bash-only tooling has higher success for bash-capable models, compared to using predefined tools for models that aren't good at bash? Yeah... They all seem a bit "duh" to me. The final piece of the conclusion is agreeable regardless of how they arrived at it though:
> Harness design is thus a conditional systems problem in which each component should be selected for the target model, task type, and resource budget rather than adopted as a default.
I think lots of people treat the harness/model/prompts combo as interchangeable, but in my experience the quality and efficiently depends heavily on the combo of the harness/model, and using the harness + model made by the same lab, has vastly better experience compared to more "general purpose" (for the lack of a better term) harnesses. Most likely because they use their own traces when training future model iterations.
Testing the "obvious", "duh" things is incredibly valuable science. It provides a more solid foundation on which to build because it reduces the assumption space.
bash scripts, famously the last word in software engineering. all these castles of sand we've built atop the beautiful, perfect, timeless Bourne Again SHell. all for naught. fools!
What an intensely wrong comment. The trajectory of all software is the opposite of what you say. Bash is the entry level, everything flees.
At one point the web was bash scripts glued together. Now everything is brought into a runtime. Then brought into virtualized containers to isolate and hide from every other aspect of the operating system.
Eventually the agents will be on a runtime as well. The existing ones just aren't good enough. Rather than forking like made as a way of doing everything, exfiltration into arbitrary executables will be something more tightly controlled.
Organizations need better in-product control and auditing of the operations of the agent. They need it to work across OSes and not depend on the state of the machine, and not conflict with what else the developer is trying to do with it.
> In other words, MCP was just a bunch of bullshit
This is a complete misunderstanding of why a team would want MCP.
If you're just using bash scripts, where are you putting your enterprise secrets for external systems? How do you cleanly revoke them when a developer leaves your team?
MCP moves execution into a remote environment where it is easy for enterprises to secure access to internal and external systems. OAuth based access makes it easy to audit and revoke tokens. Central HTTP interface makes it trivially easy to monitor and audit.
It might be 'duh' but it means we need a formal list of what each model is good at, and to pick or change harnesses to closer fit the model. Like an llm recipe book. Not just for remote models, but also local ones where how you run the model is critical too.
> using the harness + model made by the same lab, has vastly better experience compared to more "general purpose" (for the lack of a better term) harnesses
not really, there was a recent benchmark with claude and codex and it showed no difference in ability with a harness like pi agent compared to their native harnesses, pi was in fact cheaper per task.
This is done on Nemotron models + mistral, so its not very relevant to the current frontier of cheap chinese models + big models from Claude/GPT. Big miss not having qwen or deepseek in this research.
The focus of the study was the different harness approaches and how they scale across model sizes. The fact that they used any particular set of models is irrelevant.
I'm not totally convinced that models are fungible, the claudes/gpts/Gemini all have pretty individual feels when you're working with them. I wouldn't be surprised if the approaches don't scale or even work the same in a poly model setup
that's anecdotal though, right? your subjective feeling of how a model responds to you will greatly influence how you 'feel' about a model and its performance in the same way that a co-worker who you get along with will fuck something up and you'll be more forgiving than when you work with a too-verbose, mansplainer of a co-worker who fucks up
I think until we have actual repeated-use measurements tracked over time (eg consistent prompts used to do the same tasks, count number of hallucinations and errors and bugs over a long period of time) you won't really have any idea of which model is better
I also think of it like a car - some just feel better to drive even if they are materially worse in other measures. until you start measuring the metrics important to you (eg MPG and cost of maintenance over a long period), you have no idea which car is actually better suited for you. and the fact that you can only do so with a limited number of cars (or hours available to work, or money to burn on tokens) means there's no true measure approaching objectivity
Anecdotal or subjective don't mean "wrong." I would 100% agree that claude and chatgpt have different 'styles.' They do have their own patterns, and those patterns are distinguishable.
it doesn't mean wrong, it's just probabilistically full of unregarded bias and prone to hallucinated ineferences, much in the same way that LLMs sometimes are
You can write a config that points your claude code at any anthropic-compatible endpoint, and replace opus and sonnet with whatever you want. Things like deepseek and glm in there do not feel at all like they do in more minimal harnesses, but neither do they convincingly act like claude models. It's very stark and frankly they run like shit this way. Try it.
I'm going to cherry pick one example where newer models are noticeably improving at least in my experience.
What is a noticeable improvement with something that struggles to read a message longer than 200 characters without missing information in the middle, may be a 0.000000001% improvement with a model that... almost never misses info in the first place.
Agree. Harnesses are effective because they interact with the underlying model effectively. If the latest models were fundamentally different, excluding them would be a miss. But I don’t think they are, at least not in ways that would affect these observations.
I think the confounding issue is that by now, millions of sessions of Claude Code and Codex are now in the training set for these models. So they have been trained to work the way these harnesses are configured, and at least in the case of Claude Code the harness itself is greatly stripped down because the model has absorbed it.
I have to say, I am starting to hate this line of reasoning. Yes, LLMs move extremely fast and a lot of improvements are done in a short amount of time.
And there might be a point to these arguments, vaguely. However:
There never seems to be - any - kind of counter example or reasoning behind the rationale. You have an in depth and empirical study, done by researchers who, frankly, now their shit (most of the time)
And on the other hand a random internet comment saying "nope" because...the models aren't the latest.
If the latest models really would make a difference, you should at least provide some kind of evidence towards that. As it stands though, every time these comments come up this is missing.
There seems to just be a vaguely defined understanding that "everything changes all the time, and nothing you ever research is transferable to state-of-the-art models"
Which brings me to my second point about these kinds of arguments:
LLM models often - aren't - fundamentally different. Yes, they are vastly more capable. And yes, there are emergent properties. But at their core, they function very much similarly. And for quite a while now, there have not been any of these drastic changes we saw when LLMs first become "good enough" for agentic coding.
I am tired of dismissing empirical evidence and studies every. single. time for reasons without evidence and seemingly a vague sense of "no, but my model is different"
The models they are using are Nemotron3 series from last year. For reference at that time, the state of the art was Sonnet 4.6 and GPT was essentially unused for coding. Currently, you can run Qwen 27B in your gaming PC and it will absolutely trounce every model they show in their report.
This is a field that changes significantly every few months, so using 1 year old models essentially invalidates the entire report, as they are 2 model generations behind and the newer generation models are heavily RL-d around their harness. For example they put a lot of emphasis on context management but that kind of context management isnt done anymore because many models now have 250k or 1M context and inferencing the models heavily rewards cache hits so you should never touch the context until you decide to compact. They comment on plan mode, which is something that Claude decided to remove from their client because they dont consider it needed at all anymore.
I sympathise completely but a ~3B parameter model and ~3T parameter model are going to exhibit very different behaviour, one can only infer so much large model behaviour from the former.
Todo/task-tracking tools (TaskCreate/Get/Update/List, TodoWrite) are no longer available on Opus 4.8, Sonnet 5, Fable 5, Mythos 5, and newer models; set CLAUDE_CODE_ENABLE_TODO_TOOLS=1 to bring them back"
Anthropic appears to agree frontier models don't need in-session planning tools.
In their case, context management pays off more the tighter your window. Their gap between managing and not managing is 35.7 points of success rate at 32k and 2.7 points at 128k. My version of that was a rule I stick to, as much as I can. I checkpoint a session at about 25-30% of the window, write the state out to a PROGRESS.md and a JSON file of the requirements, and start fresh. This restart costs me 30 seconds, since a bloated session doesn't get any cheaper the longer you stay in it.
Also worth knowing that the models are Nemotron-3 and Mistral-Medium, not the frontier models most people here are paying for.
I've been pushing the context window well into the 400-600k+ token range lately (mostly Opus 5). I prefer not to since I'm aware of context collapse, but I've been leaning that way lately.
Lately, I've been finding that the game of telephone of handoffs causes more mistakes than just letting the session run longer. Not too mention the wasted time waiting for agents to poke around as they bootstrap a new session from the handoff.
Of course, I still have handoffs for the large-scale plan being accomplished, but I've been having better results letting an agent finishing what it starts. The game of telephone is a painful waste of time when it goes wrong, which is far too often for me.
And what you describe doing is also very in line with Cursor's published recommendations.
Though of course every single element of their application's actual UX is pushing hard in the opposite direction. The cynical part of me can't help but notice that there's a bit of a conundrum here: using coding agents more effectively seems to involve working pretty hard at giving the agent vendor less money.
This could potentially be an important part of price discovery, though. The market is constantly seeking that balance point between 'chasing whales' and 'making it up on volume'.
As far as I can tell, the paper says "bash capable", without ever describing what that means. How would one know whether a given model is "bash capable" or not?
I would have to imagine, that Luna would very much fall into the camp of "bash capable". At which point- it seems to me that adding any tools beyond just Bash requires some rigorous testing and verification that value is being added.
I think it’s sort of self-defined. If a model is able to use bash well enough to not need specific tools.
The research seems to agree with you, though. The paper calls out that for “bash capable” models, adding tools to do things bash can already do doesn’t improve performance.
Vaguely the same result as RAG. Unless you’re in specific domains, you won’t beat handing the agent a shell and grep.
> Vaguely the same result as RAG. Unless you’re in specific domains, you won’t beat handing the agent a shell and grep.
This has been my conclusion as well, and I'm doing my best to try and back this up quantitatively. In a perfect world, I could smite all of the internal MCP servers in my Corp environment and replace them with REST/GraphQL. No one using any of these servers is hitting them with models that would perform worse orchestrating with bash- and some of these folks are running harnesses with awful MCP clients.
I am still wondering about the effectiveness of using grep/awk (and ad-hoc python scripts) in code bases, as opposed to more sophisticated LSP and the like?
Something that totally confuses me is the use of the term “harness.”
Is it the harness that enables the LLM to use tools and implement plans, or is it the short leash that, through many guardrails, ensures that the LLM follows the desired path?
I see both meanings used. The former is still plausible, but I see many people using the second interpretation.
Planning and tooling are suitably designed for execution. That's why they fail to decide on the resulting coding accuracy. If the product is user-facing (i.e. all products), a blind verification harness that is specifically designed to behave like a real user should be the decider.
nice work and paper, seeing more harness benchmarks emerge and we definitely need more. I ran mouse on the Frontier Harness benchmark and scored the highest pass rate, however I'm not convinced the results there actually translate to meaning the "best" harness in practice.
Always looking for more harness evals, although I'm going broke running them across all these models and tasks.
I tried to get my lawyer-mom switched to Linux a bit ago, and she loved it in generally, but none of the Office competitors had good enough compat to work.
The only other thing keeping her on Windows is Adobe PDF pro, since it can do OCR where, when you edit it, it reflow the text in a font that matches the scanned in one to look like the original. (I also got weird "This feels like it enables fraud vibes" from this, but, no, turns out it's a totally common workflow for lawyers to need to do this ... I hate it.)
Cool to see 1/2 of the problems keeping her on Windows solved.
> but none of the Office competitors had good enough compat to work.
Don't worry about that - all the agents/harnesses/tools that produce .doc or .docx files do so with LibreOffice now. In a short time people would rather tell their agent "produce this file" and get one that is 99.9% compatible with Word than actually open Word and use the builtin copilot.
Haven't gone through full PDF as its very detailed, few things have resonated with me so far.
Basically if a Car A is performing better (be it speed, milage or in general sense) than Car B, then it is not necessarily because its engine. It could be because of better tires, better gearbox, lighter body, better usability of features, etc.
You can implement an AI feature (like AI for BI) in different ways even with the same model - via ReAct-loop, or plan-and-execute, or hybrid. You can make it stateless, stateful, RAG-based, etc. depending upon whether you want to prioritize result accuracy or depth of analysis. You can use LLM to generate either intent (requires lesser reasoning) or the queries itself (requires much more capable model).
Your harness can adapt to the underlying model's native capabilities, or can make up for its absence, e.g. query generation in above example requires your model to have MOE capabilities but intent generation wouldn't.
Love your analogy.
Cars performance is hugely dependent on use case and overall setup (suspension, engine (NA, turbo, supercharger, etc), coef of drag, etc).
Maps well onto the LLM surface.
Anyone that's into auto racing as a hobby will tell you the engine is the last thing you should modify unless your whole goal is to get into the guts of engine mechanics.
But if you just want to improve lap times it's way less of a priority than brakes, tires, suspension setup, cooling to keep everything happy, etc.
I'm not a car guy but would it be fair to see that your maximum possible performance is bounded by the engine, but the average performance gains are from tuning the rest of the vehicle?
Kind of like if your RAM has to constantly page, you would see much more improvement from upgrading your RAM than overclocking your CPU?
so then what I’m really interested in are benchmarks of OSS models vs closed source frontier models, using Claude Code as a harness
Cool study, we definitely need more principled studies on the role of harnesses. I'd also say that there aren't too many benchmarks where the more complicated harnesses consistently outperform extremely simple agents. But I'm also biased, because I wrote https://github.com/swe-agent/mini-swe-agent/ , which is probably the most minimal agent out there (it started as just 100 lines, all included), and it's used in a lot of benchmarks like DeepSWE, terminalbench, programbench (seems like it's still top of the ranking for TB3, but wasn't evaluated with the best models on TB4).
> Minimal: Just some 100 lines of python for the agent class (and a bit more for the environment, model, and run script) — no fancy dependencies!
It is way more than 100 lines. Why keep advertising something that is no longer the case?
I think they are referring to the file https://github.com/SWE-agent/mini-swe-agent/blob/main/src/mi...
190 lines with comments included so close enough
Which is the actual agent? Everything else is just glue code to connect to different LLM providers, etc
190 is not close enough. It is close to double.
Minimal agents also allow room for more focused add-on tools/infra. I'm working on a context management layer[1] and it's very difficult to do well. In our benchmarking, we've observed simple harnesses like Stirrup[2] outperforming more elaborate ones.
[1] https://www.induction.ai/docs/context-management [2] https://github.com/ArtificialAnalysis/Stirrup
I'd really love to see more studies about effectiveness of AI in general. As in, what works best and how to use it and such.
Because I feel that the technology and space is - so - hyped and fast moving that a lot of cultish feeling rituals seem to pop up, none of which are backed by evidence. Anthropic openly recommend giving the agents.md file an architectural overview of the code, and the one time this was studied they found the opposite - that the agents.md file is best for concrete commands about how to build stuff and such, and - not - huge overviews. This was, and still is, the official recommendation from Anthropic as far as I can tell.
And then there are the benchmarks, how feel vague and not concrete, and everyone kind of knows they're not the best cuz you can't just assign these tools one fixed number ( for multiple reasons ), but everyone still looks at them and compares them.
People share skills and superpowers and plugins and mcps and very, very few of them have and kind of proof they do much at all.
It all feels a bit weird to me, and I've been on the lookout for exactly these kinds of studies more lately, because I think having this research, even if not done on the exact newest models or not the exact, newest thing, are still - vastly - superior to the alternative.
> People share skills and superpowers and plugins and mcps and very, very few of them have and kind of proof they do much at all.
At least 3 times last month I was asked to review a change in a .md file used by agents. And I am like: "yeah I guess it makes sense?"
It feels we need to write unit tests for this stuff, but even how to do so in reasonable time and complexity seems difficult.
[dead]
I think that generally speaking, the tighter the feedback loop, the better AI performs. Ask it to do things that are fast and easy to check and I suspect not much else matters. That's why AI's eating programming but has mitigated success elsewhere, feedback loops in the digital world are orders of magnitude faster.
The various “minimal” agents (at least Pi, mini SWE, dsh minimal) seem to benchmark quite differently and none is clearly better in all cases. Do you have any thoughts about why?
I would expect the agent loop and system prompt to be basically the same. Is it the precise semantics of the tools (and how closely they match what a particular agent was trained on) or something else?
The conclusions:
> Planning improves success at additional cost for weaker models but mainly reduces cost, with small decreases in success rate, for stronger models.
> Predefined tools raise success rates for models with weak bash control, whereas bash-only yields higher success at lower cost for bash-capable models, most clearly on shell-centric task types.
> context management extends execution trajectories without substantially altering agent behavior and is most beneficial under tight context budgets
> planning sustains the trajectories of models that abandon tasks too early and trims repeated verification in models that verify too long
> structured tools support models with limited shell proficiency, while bash-only enables capable models to combine multiple code modifications in a single tool call
Seems fairly intuitive to me, based on feeling. But also fairly kind of obvious; bash-only tooling has higher success for bash-capable models, compared to using predefined tools for models that aren't good at bash? Yeah... They all seem a bit "duh" to me. The final piece of the conclusion is agreeable regardless of how they arrived at it though:
> Harness design is thus a conditional systems problem in which each component should be selected for the target model, task type, and resource budget rather than adopted as a default.
I think lots of people treat the harness/model/prompts combo as interchangeable, but in my experience the quality and efficiently depends heavily on the combo of the harness/model, and using the harness + model made by the same lab, has vastly better experience compared to more "general purpose" (for the lack of a better term) harnesses. Most likely because they use their own traces when training future model iterations.
"Everybody knows foul air causes sickness."
"Duh, of course Mars has canals."
Testing the "obvious", "duh" things is incredibly valuable science. It provides a more solid foundation on which to build because it reduces the assumption space.
> bash-only tooling has higher success for bash-capable models, compared to using predefined tools for models that aren't good at bash?
No. The conclusion is that:
bash-capable models + bash-only tools > bash-capable models + predefined tools
In other words, MCP was just a bunch of bullshit that maybe helped a little bit until the models got good at bash, and now it's basically useless.
bash scripts, famously the last word in software engineering. all these castles of sand we've built atop the beautiful, perfect, timeless Bourne Again SHell. all for naught. fools!
What an intensely wrong comment. The trajectory of all software is the opposite of what you say. Bash is the entry level, everything flees.
At one point the web was bash scripts glued together. Now everything is brought into a runtime. Then brought into virtualized containers to isolate and hide from every other aspect of the operating system.
Eventually the agents will be on a runtime as well. The existing ones just aren't good enough. Rather than forking like made as a way of doing everything, exfiltration into arbitrary executables will be something more tightly controlled.
Organizations need better in-product control and auditing of the operations of the agent. They need it to work across OSes and not depend on the state of the machine, and not conflict with what else the developer is trying to do with it.
This unironically.
The design of pipes and the philosophy of simple composable tools tied together with the Unix shell has proven remarkably difficult to improve upon.
If you're just using bash scripts, where are you putting your enterprise secrets for external systems? How do you cleanly revoke them when a developer leaves your team?
MCP moves execution into a remote environment where it is easy for enterprises to secure access to internal and external systems. OAuth based access makes it easy to audit and revoke tokens. Central HTTP interface makes it trivially easy to monitor and audit.
They solve different problems.
[flagged]
It might be 'duh' but it means we need a formal list of what each model is good at, and to pick or change harnesses to closer fit the model. Like an llm recipe book. Not just for remote models, but also local ones where how you run the model is critical too.
> using the harness + model made by the same lab, has vastly better experience compared to more "general purpose" (for the lack of a better term) harnesses
not really, there was a recent benchmark with claude and codex and it showed no difference in ability with a harness like pi agent compared to their native harnesses, pi was in fact cheaper per task.
This is done on Nemotron models + mistral, so its not very relevant to the current frontier of cheap chinese models + big models from Claude/GPT. Big miss not having qwen or deepseek in this research.
The focus of the study was the different harness approaches and how they scale across model sizes. The fact that they used any particular set of models is irrelevant.
I'm not totally convinced that models are fungible, the claudes/gpts/Gemini all have pretty individual feels when you're working with them. I wouldn't be surprised if the approaches don't scale or even work the same in a poly model setup
that's anecdotal though, right? your subjective feeling of how a model responds to you will greatly influence how you 'feel' about a model and its performance in the same way that a co-worker who you get along with will fuck something up and you'll be more forgiving than when you work with a too-verbose, mansplainer of a co-worker who fucks up
I think until we have actual repeated-use measurements tracked over time (eg consistent prompts used to do the same tasks, count number of hallucinations and errors and bugs over a long period of time) you won't really have any idea of which model is better
I also think of it like a car - some just feel better to drive even if they are materially worse in other measures. until you start measuring the metrics important to you (eg MPG and cost of maintenance over a long period), you have no idea which car is actually better suited for you. and the fact that you can only do so with a limited number of cars (or hours available to work, or money to burn on tokens) means there's no true measure approaching objectivity
Anecdotal or subjective don't mean "wrong." I would 100% agree that claude and chatgpt have different 'styles.' They do have their own patterns, and those patterns are distinguishable.
it doesn't mean wrong, it's just probabilistically full of unregarded bias and prone to hallucinated ineferences, much in the same way that LLMs sometimes are
You can write a config that points your claude code at any anthropic-compatible endpoint, and replace opus and sonnet with whatever you want. Things like deepseek and glm in there do not feel at all like they do in more minimal harnesses, but neither do they convincingly act like claude models. It's very stark and frankly they run like shit this way. Try it.
it's almost like the harness was specifically designed for their model and not others :)
But the behaviour of the system can totally change under different scales.
comparing x10 to x100 doesn’t necessary inform you about x100_000 to x1_000_000
That can only be assumed by someone with zero clue about harness engineering.
So i can skip this study.
Nope. Sorry. Not how this works.
How does it work then?
I'm going to cherry pick one example where newer models are noticeably improving at least in my experience.
What is a noticeable improvement with something that struggles to read a message longer than 200 characters without missing information in the middle, may be a 0.000000001% improvement with a model that... almost never misses info in the first place.
Agree. Harnesses are effective because they interact with the underlying model effectively. If the latest models were fundamentally different, excluding them would be a miss. But I don’t think they are, at least not in ways that would affect these observations.
I think the confounding issue is that by now, millions of sessions of Claude Code and Codex are now in the training set for these models. So they have been trained to work the way these harnesses are configured, and at least in the case of Claude Code the harness itself is greatly stripped down because the model has absorbed it.
I have to say, I am starting to hate this line of reasoning. Yes, LLMs move extremely fast and a lot of improvements are done in a short amount of time.
And there might be a point to these arguments, vaguely. However:
There never seems to be - any - kind of counter example or reasoning behind the rationale. You have an in depth and empirical study, done by researchers who, frankly, now their shit (most of the time)
And on the other hand a random internet comment saying "nope" because...the models aren't the latest.
If the latest models really would make a difference, you should at least provide some kind of evidence towards that. As it stands though, every time these comments come up this is missing.
There seems to just be a vaguely defined understanding that "everything changes all the time, and nothing you ever research is transferable to state-of-the-art models"
Which brings me to my second point about these kinds of arguments:
LLM models often - aren't - fundamentally different. Yes, they are vastly more capable. And yes, there are emergent properties. But at their core, they function very much similarly. And for quite a while now, there have not been any of these drastic changes we saw when LLMs first become "good enough" for agentic coding.
I am tired of dismissing empirical evidence and studies every. single. time for reasons without evidence and seemingly a vague sense of "no, but my model is different"
The models they are using are Nemotron3 series from last year. For reference at that time, the state of the art was Sonnet 4.6 and GPT was essentially unused for coding. Currently, you can run Qwen 27B in your gaming PC and it will absolutely trounce every model they show in their report.
This is a field that changes significantly every few months, so using 1 year old models essentially invalidates the entire report, as they are 2 model generations behind and the newer generation models are heavily RL-d around their harness. For example they put a lot of emphasis on context management but that kind of context management isnt done anymore because many models now have 250k or 1M context and inferencing the models heavily rewards cache hits so you should never touch the context until you decide to compact. They comment on plan mode, which is something that Claude decided to remove from their client because they dont consider it needed at all anymore.
I sympathise completely but a ~3B parameter model and ~3T parameter model are going to exhibit very different behaviour, one can only infer so much large model behaviour from the former.
How do Nemotron models + mistral compare to "the current frontier" in your experience?
Todo/task-tracking tools (TaskCreate/Get/Update/List, TodoWrite) are no longer available on Opus 4.8, Sonnet 5, Fable 5, Mythos 5, and newer models; set CLAUDE_CODE_ENABLE_TODO_TOOLS=1 to bring them back"
Anthropic appears to agree frontier models don't need in-session planning tools.
https://github.com/anthropics/claude-code/issues/80487
Quite inline with what I had found with my Claude code sessions over the last year. I wrote about this a few months ago.
https://rahulmax.com/notes/how-i-keep-the-ai-bill-down/
In their case, context management pays off more the tighter your window. Their gap between managing and not managing is 35.7 points of success rate at 32k and 2.7 points at 128k. My version of that was a rule I stick to, as much as I can. I checkpoint a session at about 25-30% of the window, write the state out to a PROGRESS.md and a JSON file of the requirements, and start fresh. This restart costs me 30 seconds, since a bloated session doesn't get any cheaper the longer you stay in it.
Also worth knowing that the models are Nemotron-3 and Mistral-Medium, not the frontier models most people here are paying for.
I've been pushing the context window well into the 400-600k+ token range lately (mostly Opus 5). I prefer not to since I'm aware of context collapse, but I've been leaning that way lately.
Lately, I've been finding that the game of telephone of handoffs causes more mistakes than just letting the session run longer. Not too mention the wasted time waiting for agents to poke around as they bootstrap a new session from the handoff.
Of course, I still have handoffs for the large-scale plan being accomplished, but I've been having better results letting an agent finishing what it starts. The game of telephone is a painful waste of time when it goes wrong, which is far too often for me.
[dead]
And what you describe doing is also very in line with Cursor's published recommendations.
Though of course every single element of their application's actual UX is pushing hard in the opposite direction. The cynical part of me can't help but notice that there's a bit of a conundrum here: using coding agents more effectively seems to involve working pretty hard at giving the agent vendor less money.
This could potentially be an important part of price discovery, though. The market is constantly seeking that balance point between 'chasing whales' and 'making it up on volume'.
As far as I can tell, the paper says "bash capable", without ever describing what that means. How would one know whether a given model is "bash capable" or not?
I would have to imagine, that Luna would very much fall into the camp of "bash capable". At which point- it seems to me that adding any tools beyond just Bash requires some rigorous testing and verification that value is being added.
I think it’s sort of self-defined. If a model is able to use bash well enough to not need specific tools.
The research seems to agree with you, though. The paper calls out that for “bash capable” models, adding tools to do things bash can already do doesn’t improve performance.
Vaguely the same result as RAG. Unless you’re in specific domains, you won’t beat handing the agent a shell and grep.
> Vaguely the same result as RAG. Unless you’re in specific domains, you won’t beat handing the agent a shell and grep.
This has been my conclusion as well, and I'm doing my best to try and back this up quantitatively. In a perfect world, I could smite all of the internal MCP servers in my Corp environment and replace them with REST/GraphQL. No one using any of these servers is hitting them with models that would perform worse orchestrating with bash- and some of these folks are running harnesses with awful MCP clients.
I am still wondering about the effectiveness of using grep/awk (and ad-hoc python scripts) in code bases, as opposed to more sophisticated LSP and the like?
I think it just means “is there some parser program that consumes the LLM token stream and spawns shell processes with the detected command strings”.
Im not sure how this could make sense, considering the content of the paper.
Something that totally confuses me is the use of the term “harness.”
Is it the harness that enables the LLM to use tools and implement plans, or is it the short leash that, through many guardrails, ensures that the LLM follows the desired path?
I see both meanings used. The former is still plausible, but I see many people using the second interpretation.
Planning and tooling are suitably designed for execution. That's why they fail to decide on the resulting coding accuracy. If the product is user-facing (i.e. all products), a blind verification harness that is specifically designed to behave like a real user should be the decider.
nice work and paper, seeing more harness benchmarks emerge and we definitely need more. I ran mouse on the Frontier Harness benchmark and scored the highest pass rate, however I'm not convinced the results there actually translate to meaning the "best" harness in practice.
Always looking for more harness evals, although I'm going broke running them across all these models and tasks.
definitely sending this to claude to take lessons from it and audit my harness, thanks for sharing
Awesome work!
I tried to get my lawyer-mom switched to Linux a bit ago, and she loved it in generally, but none of the Office competitors had good enough compat to work.
The only other thing keeping her on Windows is Adobe PDF pro, since it can do OCR where, when you edit it, it reflow the text in a font that matches the scanned in one to look like the original. (I also got weird "This feels like it enables fraud vibes" from this, but, no, turns out it's a totally common workflow for lawyers to need to do this ... I hate it.)
Cool to see 1/2 of the problems keeping her on Windows solved.
> but none of the Office competitors had good enough compat to work.
Don't worry about that - all the agents/harnesses/tools that produce .doc or .docx files do so with LibreOffice now. In a short time people would rather tell their agent "produce this file" and get one that is 99.9% compatible with Word than actually open Word and use the builtin copilot.
[flagged]
[flagged]
[flagged]
[flagged]
[flagged]
[flagged]
[flagged]
[flagged]
[dead]