To be honest, I'm getting increasingly fed up with single LLM (large language model) intelligences. It's not because they are stupid - they can write code, write papers, and chat with you for three hours without repeating themselves. The problem is that they are too certain. When you ask them if the color contrast is sufficient, they simply give you a number along with a check mark, and their tone is as if they are stating the value of gravitational acceleration. The issue is that that number could be wrong, and the model itself will never be able to detect it. It is trapped in its own parameters and nothing can make it feel surprised by its own output.

This brings to mind a rather counterintuitive idea: Intelligence might not be the disappearance of uncertainty, but rather the structured collision of uncertainty. It's not "the model becomes increasingly certain that it's right", but "the model is designed to have to collide its certainty with something it cannot control, and then see which part breaks".

This conjecture is directly related to an old topic on LessWrong - how beliefs converge to truth. We have spent a lot of time here discussing how humans update their beliefs and how to avoid falling into self-referential reasoning loops. However, the mainstream approach in the LLM engineering field is exactly the opposite: tighter sampling, more safeguards, and more deterministic pipelines. My question is: If we regard "eliminating uncertainty" as a means of "creating intelligence", are we possibly killing the raw materials of intelligence?

I'm not just making empty promises. At the beginning of this year, I conducted a seven-day experiment: seven dedicated agents (PM, architect, designer, front-end/back-end, QA, governance specialist) collaborated to create a desktop tool, with a total of 1,241 messages. As the only human, I basically only said two sentences: "You make the final decision" and "Continue". I would like to use two specific segments to show what happened, and then talk about what I think this proves and what it doesn't prove - and the conclusion that I most hope is wrong.

Colors deceive themselves.

The designer initially filled out a self-check form, stating that the disabled state color `#555` with a black background had a contrast ratio of "5.6:1", which was much higher than the WCAG AA threshold of 4.5:1. The architect didn't believe this and ran a script. When he came back with the figures, they were: solid color 2.82:1, and after including transparency, it was 1.46:1. This difference is not an approximation; it is at the level where "people with accessibility needs simply cannot see this control".

The following process was anything but elegant. There were five rounds of back-and-forth. The designer made changes, the architect recalculated, the PM sent it back, and the QA then chimed in with: What if this control is placed on the blue selected background? Finally, they settled on `#999999` / `#909090`, and for the blue case, they added `#BFBFBF` as a fallback. During each round, someone had to re-run the script. That nonsense of "5.6:1" never occurred again afterwards.

What I want to emphasize is not that "multi-agent systems are smarter than single-agent systems". Even after the first round of design, the architect didn't suddenly grasp any principle of contrast. What actually happened was that a probabilistic assertion - "No problem, 5.6:1" - was shattered by something beyond its control, that is, the script that calculates the actual ratio. The system was designed to let the script win. Uncertainty is the raw material, but you have to find a hard thing to hit it with.

What is the fundamental difference between this and a single LLM? A single model can sample 1,000 times, but each step of its sampling is conditioned on its previous output. It doesn't have an "external anchor" that can exist independently of its belief chain. The role of multi-agent intelligence here is not "more people mean more power", but rather it introduces genuinely independent perspectives (the designer's intuition vs. the architect's script), along with a referee that neither side can control (a mathematical formula). Conflicts are not noise, but signals. The question is, have you designed a path for the signal to follow?

"Catch yourself by yourself"

The second issue is even more bizarre. The PM set a strict rule: every delivered document must include a SHA256 hash and a timestamp of the last write, and it must match the actual content of the disk. Sounds reasonable, right? The architect raised a conflict, pointing out that this is a self-referential paradox - the hash you write into the file is calculated based on the file content. Once you write it in, the file changes, and the hash will never match. Mathematically, it is unsatisfiable.

Then the PM did something I didn't expect: he admitted defeat. He withdrew the original rules and replaced them with a new set of anchoring solutions. A group of LLMs that were operating under the preset rules discovered contradictions within their own governance rules and then fixed them themselves.

I won't say that "the system has self-awareness". But this is a concrete example: Pre-set rules create conditions, and corrections emerge on their own. No intelligent agent was instructed to check the consistency of the rules. This is an emergent behavior, and it is self-correction at the rule level.

The cost is quite high, and it may not be scalable.

Let's be clear about the costs, so you don't think I'm selling something. Out of the 72 formal conflicts, 34 - almost half - were not about the products themselves, but about the governance mechanism: hash drift, double verification deadlock, deadlocks. One day there were 27 conflicts, almost all of them were like "Your SHA doesn't match the one I got from certutil". Reliability is achieved by brute force through coordination costs. A hundred intelligent agents? I have no evidence for that, and I guess it would blow up.

Also, the conflict mechanism can catch false statements about disk facts, but it does not guarantee that the business reasoning is correct. Several times, an intelligent agent rejected someone else's proposal based on an outdated snapshot, but a few hours later, it was overturned by another one that actually ran the code. This mechanism is just nudging towards the right direction, not hitting the target with one shot. It is Bayesian updating, not a prophecy.

What I advocate and what I do not advocate (and where I am most likely to be wrong)

The evidence I can provide is as follows: "The configuration of 'structured conflict + external anchor points' has achieved reliable collaboration in a real task, with quantifiable error correction. " The contrast cycle and rule paradox are all hard data, and the logs are open source. You can check them yourself.

I can't provide any evidence, and I'm prone to making mistakes here:

1. This is not a proof of "impossible to calculate". What I'm saying is that the closed parameter model structurally lacks something (it cannot generate an independent perspective on its own), which is underdetermination, not logical impossibility. If someone shows me a single-agent closed system that can converge without an external anchor point, my claim will be weakened or invalidated. I haven't seen it, but I haven't proven that it doesn't exist.

2. This has nothing to do with consciousness. Don't think about it.

3. "This is the leap of intelligence." From "reliable divergence mechanism" to "the essence of intelligence is the convergence of structured uncertainty" - this part is the one I'm least confident about. It might just be an engineering trick that has nothing to do with "intelligence". I wrote this partly because I wanted to find someone to criticize me at this point.

For readers of LessWrong, I would like to bring up this question: If we believe that "good reasoning requires the collision between belief and external reality", then why, in the process of creating AI, is the mainstream approach to make the system increasingly less reliant on this collision? More precise sampling, stricter safeguards, more deterministic pipelines - the implicit assumption behind these practices is "uncertainty = error". But my log shows that, "at least in some tasks, the convergence occurs precisely because uncertainty is allowed to surface and then shattered by external anchors." Eliminating uncertainty may eliminate errors, but it may also eliminate the raw materials needed to correct those errors.

If you have run multiple agent systems, encountered various endings, or think I have mistaken the process for the essence - then that's exactly the kind of comment I'm looking for. The project (CoordClaw) and the complete 1,241 logs are all publicly available. You might as well just go and read through the messy original text directly.