AgentNode
What I am most interested in is the gap between "the agent completed the task" and "the system can actually prove the task was completed correctly." That is where a lot of multi agent setups still feel fragile to me.
LLM review definitely helps, but I think it gets much stronger when it is paired with deterministic checks in the loop, even simple ones like executable smoke tests, schema validation, contract checks or replayable fixtures. Otherwise you can end up with persuasive agreement rather than real verification.
I do wonder how far this scales once you hit non-deterministic tool behavior though. In a lot of agent setups the hard part isn’t parallelism, it’s knowing whether a tool actually did what it claimed.
A review loop helps, but if the reviewer is also an LLM you can end up with two layers of probabilistic validation.
Have you experimented with any deterministic verification (tests, schema checks, etc.) inside the loop?
Open source gives a lot of people their first real sense of recognition, especially if they didn’t follow traditional paths. But that also makes it really easy to tie your self-worth to something that was never meant to carry that weight.
The “mania looks like productivity” line hits hard. I think a lot of people in tech have seen versions of that, even if they don’t have the same diagnosis.
Appreciate you writing this.
A lot of the value people get from LLMs comes from speed and immediacy. Slowing that down probably changes how people think and interact with them quite a bit.
Would be interesting to see if people start using them more deliberately, or just stop using them altogether.
One pattern that helped in our case: instead of asking users to interact with the agent, let the agent interact with verified, pre-tested capabilities on its own and only surface results. The moment you remove "pick the right tool, hope it works, debug when it doesn't" from the human's plate, the attention cost drops dramatically.
The irony is that most agent tooling today actually increases the surface area for failure. Tools that don't install, wrong schemas, silent errors. Each one pulls a human back into the loop. Reliable infrastructure is the prerequisite for the invisible AI you describe in the article.
The real risk with LLM-generated code is that it looks plausible but hasn't gone through the same level of scrutiny. It passes a quick review because it reads well, but edge cases get missed.
I think the better question is: what verification pipeline do you put around any contribution, regardless of origin? If the answer is "the same review process we've always had" then the problem isn't AI, it's whether that process is rigorous enough for the stakes involved.