Any benchmarks showing if this actually improves problem solving? Or reduces errors?

The idea is cool, but from own experience in harness engineering, lots of cool sounding ideas can have a negative impact on performance due to emergent and confounding effects.

So I'm a bit skeptical!

So if I understand correctly, one of the agents is creating the workflow as a DAG dynamically for each new job it's given? That's the most interesting part to me. The rest I was already pretty familiar with.

So maybe that's a big chunk of what you need for an 'AI Company': an agent that manages the goals and hierarchies. Although of course the DAG and agent hierarchy is not quite the same thing. But maybe the workflows and subworkflows are what matter.

A harness [1] was developed by Terrence Tao and some collaborators to prove mathematical results. It has since then been used by others with positive effect. Can someone critique the structure of this harness? I don't know anything about this stuff.

[1] https://github.com/1stproof/batch-2/tree/main/batch-2-submis...

A good tutorial. Generally speaking, the harness is the environment layer between a language model and its task, such as the action set it can call, the state, the context it can see and the memory etc.

However, currently the bigger question comes to my experience during harness is actually not where we use LLM in the system, but where we do NOT use LLM in the system. And the validation of the results becomes more and more important. Any thoughts on this?

I (like presumably many others) have built something similar. My main difference though is that the critics operate on each stage of development before it can move onto the next. The stages are defined by deliverable artifacts: issue, plan, pull request. Critics must approve each artifact before you can move onto the next. So the process is defined by a DAG which defines how to transition successfully from one artifact to the next. It's been fun to work on and I would like to open source it soon, but I assume many others are working on similar systems.

> The plan is a graph

I much prefer giving the LLM a REPL loop, and injecting all the tools as functions inside the REPL loop.

That means that the LLM isn't constrained to writing a DAG, it can write code that loops, exits early, etc.

Contrary to the title and intro, this appears to be an agentic _workflow_ builder/runner, not an advanced “agent harness”

A few things:

- they note: “nothing in this post proves it actually works in most cases”

- the DAG sounds good, but LLMs often split tasks into smaller pieces than they need to, which can cause them to lose the forest for the trees

- the forced JSON interplay, in my experience, causes even gpt-5.6-sol to lose a few “IQ points”

For anyone reading this, this tutorial is much more reminiscent of how folks were building “agents” pre-Claude Code.

tl;dr the “orchestrator” here is just a software loop, and the LLM prompts restrict flexibility of the planner/workers

Anyone else have related reading that touches on this? I'm building my own custom harness and want to start implementing loop support, etc. But I also want to build some sort of framework so that it's dynamic (e.g. this needs to run x number of iterations, while planning needs to run y number of iterations).

And the associated GitHub repo: https://github.com/DataForScience/LLMs

Do big models benefit from Conway's Law, or only small ones?