momentichenry
1. It should be pretty efficient using prior knowledge from other runs.
2. It helps expand the graph as your app evolves so that the DAG is always up to date.
- Your first point sounds like a frontend bug to me. I wonder if there's missing revalidation.
- Sounds like the defaults need a little more tuning. You can actually update the definition yourself in settings https://app.momentic.ai/settings/mo.
- I'll take a look at this "stop testing" button thing as well. Thanks for flagging.
- What kind of export would you like? We currently have integrations that allow syncing bugs to Linear or other project management software.
- The candidate ground truth bugs are generated using runs from all agents
- Every candidate gets reviewed by the other agents to generate a recommendation (just makes human review easier)
- A human reviewer makes the final call (no candidates are discarded just because Mo couldn't reproduce)
And in terms of grading the final runs:
- A lot of the final runs still found a small percentage of novel bugs (5-10%), because it's extremely difficult to build a comprehensive list of all bugs, even after hundreds of runs.
- Nothing that didn't match was auto-discarded (read - it wasn't rejected because Mo couldn't repro).
- All unmatched findings were run through the same human review process as above.
- All the runs were regraded after human review to get a final score with zero unmatched findings.
One interesting thing we did notice during this is that Codex and Claude tend to converge on the same findings run over run (very few initially unmatched findings on final runs), whereas Mo tends to find a lot more novel bugs on ever run.
- Precision/recall vs pass/fail: I really like this point, and I would say QA bench is actually not a great fit for measuring pass/fail currently, because all of the fixtures have numerous bugs in them, and almost all agent runs find at least one (so the fail rate is basically zero). My assumption would be that recall is correlated with pass/fail accuracy, but we are working on a PR-review variant of QA-bench that I think would be more suited to measuring pass/fail directly.
- I think the insight about allowing "unsure" is interesting, and this is actually similar to what we have for some of the completions in regular Momentic tests, although I'm curious how you generate something useful for the user from the agent basically saying "there might be a bug in this code but I don't know what it is."
- Internally, if Mo can't reproduce a suspected bug it gets discarded. Although we do review some of these to make sure that there aren't issues with the reproduction agent.
- QA bench has zero planted bugs; they're all from the original source. Initially, we did try planting bugs and even generating apps with given bugs using an LLM, but we found that this didn't actually help us establish the ground truth because the agents were still finding bugs that we hadn't planted and needed manual review.
- I expect there will be many more competitors to come, as there already are. I also think achieving these performance improvements is non-trivial and depends on a lot of internal tooling we've built over the last two years (see next answer). As with any software, there will obviously be new competitors that match our historical performance eventually, but we will also be continuing to evolve our product. As you can see from the recall numbers in the benchmark, there is still a lot of room for improvement.
- Mo is really our second product. Over the last two years we've been building the Momentic e2e test framework and tooling around it, which allows engineering teams to own quality by authoring tests in plain-english and maintaining them with little to no effort. Mo builds on top of that nicely because we've already spent a lot of time tuning the underlying tools so that agents can use them efficiently to get better results.
- Real device support is already in the works! It should go live in the next couple of weeks. Would love to connect once it's ready.
The main thing we're trying to show is that Mo finds over 3x as many correct bugs in the same amount of time as the next-best QA agent. This is the main thing we optimize for since the worst thing you can do in QA is miss a real bug and ship broken code to prod. Currently, the tradeoff you make for that better recall is higher cost. I would say the precision is more or less comparable, but marginally lower.
Obviously we'd love to be beating every other agent on all of these numbers, and we're actively working on it, but for now this is an honest and transparent look at how the tool is doing.
Feel free to take a look at the full writeup for more detail!