An argument for building machine reasoning as an ecosystem instead of a pipeline
Every serious effort to make machine reasoning more reliable runs in the same direction: reduce variance. Prune the noise, tighten the distribution, converge on the answer. Ensembles get averaged. Disagreement gets treated as a defect to be engineered out. The target is one system that gives one answer with high confidence.
I want to argue the opposite, and I want to be clear at the outset that the strong version of this is a hypothesis rather than a result. The proposal is that reliable machine reasoning comes from deliberately maintained disagreement between many independently built systems, continuously fed new data, periodically forced to reconcile their accounts with each other. Not one model that reasons well. A population that can’t stop arguing, arranged so the arguments produce something.
The reason to take this seriously is that we have exactly one working example of general reasoning, and it does not work the way the pipeline does.
What the smooth system can’t do
A single model with a single training history has one way of carving up the world. It might be a very good way. It still can’t see the shape of its own carving, because there’s nothing present that carves differently.
This is why hallucination is hard to fix from inside. The problem isn’t that the system lacks knowledge. It’s that nothing in the architecture forces a claim to change shape and prove it survives. The system generates an answer, and the answer’s confidence is a function of the same process that generated it. There’s no second opinion, because there’s no second anything.
Ensembling was supposed to address this and mostly doesn’t, because ensembles are trained the same way on the same data and then averaged. Averaging destroys the information you wanted. When two models disagree, the disagreement is a measurement — of an ambiguity in the data, a difference in method, or an error in one of them. Averaging throws that measurement away and replaces it with a number.
The proposal
Take two systems, trained separately, on different data, with different architectures. Feed both a continuous stream of new information. Then run a third function on a schedule: make them attempt to reconcile their accounts of what they’ve absorbed.
Not merge. Reconcile — state what each holds, locate where the accounts diverge, and record the divergence.
The reconciliation pushes them together. Left alone, they’d converge, and you’d be back to one system with two hostnames. The influx is what prevents that. New data arrives continuously and generates fresh disagreement faster than reconciliation resolves it. The system never settles because the world keeps supplying new material to disagree about.
Now do it with a thousand systems.
Wiring the population
At a thousand nodes, connecting everything to everything gives you half a million channels and rapid convergence. The topology is the design.
No node connects to more than a fraction of the others, and any two nodes are reachable through a path of at least two intermediaries. Distant systems can influence each other. Nothing arrives directly.
That constraint is the whole architecture, and here’s what it buys. A message crossing to a distant node passes through two other systems, each with a different internal representation. If the intermediates relay — copy in, copy out — you’ve built a direct link with extra latency and gained nothing. If each intermediate ingests the claim and re-emits it in its own terms, the message has been re-encoded twice before arrival, and anything that couldn’t survive being restated in two foreign representations didn’t make the trip.
The path is the review pass. It’s not a checking step bolted on after generation. It’s how information moves.
Biological networks do this. Trees connected through fungal networks exchange resources and signals without touching, and the fungus doesn’t act as a wire — it takes material in and gives different material out. That conversion is the entire value of the intermediary. A relay adds latency. A metabolizer adds a test.
The dial nobody is setting correctly
The governing parameter is this: make the systems as different as you can while keeping them able to function together.
Push the variety too far and there’s no exchange at all — a thousand systems with no shared ground, talking past each other, producing nothing. Set it too low and you have a monoculture with redundancy, which is what current ensembles are. The useful range sits between those, and my claim is that everyone is currently operating near the bottom of it.
Variety has more axes than most implementations use:
- Architecture. Different model families with different inductive biases.
- Training data. Genuinely different corpora, which is harder than it sounds now that so much text is downstream of the same sources.
- Language. Systems whose primary competence is in structurally distant languages carve categories differently, and the difference is real rather than cosmetic.
- Formalism. Some nodes reasoning in natural language, some in symbolic logic, some in code, some in probabilistic graphs. A claim that has to cross from prose to a formal system and back has been tested by the crossing.
- Timescale. Fast nodes doing local processing, slow nodes doing broad synthesis. Different niches rather than parallel copies.
- Position in the stream. Which brings us to the next part.
Where the data enters
If new information hits every node simultaneously, they all get the same weather and you’ve handed the population a shared starting condition it will never shake.
Better: the stream enters at particular points and propagates. Position now determines what a node sees and when, and that positional difference is durable in a way that architectural difference is not, because it renews with every batch of incoming data. A node three hops from the intake is permanently working from a differently-processed version of the world than one at the entry point.
This is the most underrated source of variety in the design, and the cheapest to implement.
Throughput and uptake are different quantities
Here’s the part I think gets missed, and it’s the reason “just add more data” isn’t a complete strategy.
Data moving through the network is the carrier. What a node actually integrates is the payload. They travel together and they are not the same, and you can have a great deal of one with almost none of the other.
Volume past a certain rate does not increase learning. It degrades it. Information passes through faster than any node can absorb from it, and the anomalies you were trying to catch wash through with everything else. The architecture has a failure mode that isn’t convergence: intake outrunning uptake. High throughput, low integration, and a monitoring dashboard showing healthy flow the whole time.
Uptake requires residence time. This is a second, independent justification for the two-hop rule — forcing information to move indirectly gives it somewhere to sit long enough to be taken up rather than routed. Indirection isn’t a safety measure. It’s how you get absorption.
Which raises a design question I don’t have a settled answer to: what plays the role of soil? Something has to hold material between processing cycles, structure it, and release it slowly. Model weights? Retained state between reconciliation pulses? The accumulated reconciliation record itself? Whatever it is, it’s built rather than given, and it’s the component that degrades first under excessive volume. If you’re implementing this, that’s where I’d expect the first real failure.
There’s a related question with a possibly interesting answer. In an ecosystem, nitrogen is nitrogen regardless of what takes it up. In this network, that may not hold — a given record could be a discovery to one node and noise to another, depending entirely on what that node already contains. If so, the population doesn’t have one nutrient load. It has a different one per node, and position in the topology determines diet.
What the system produces
The output of reconciliation is a disagreement log, and that log is the product.
Systems that differ in method and data will diverge, and the divergences sort into categories worth distinguishing:
- Error in one system, which the others’ agreement locates.
- Genuine underdetermination, where the available data doesn’t decide between accounts. Correct output here is both accounts plus a specification of the measurement that would separate them.
- Something new, where a node has picked up a pattern the others lack the frame to represent.
The critical property: a divergence flag does not tell you which of these you have. A fabrication and a genuine discovery both fail to cross the network cleanly, for the same structural reason — neither has a settled representation in the receiving frame. The flag identifies a location, not a verdict.
Any implementation that treats divergence as an error signal to be suppressed has built a machine for filtering out discoveries. The flag has to open an investigation.
A health metric that works
Most system monitoring measures throughput and latency, which in this architecture will look excellent right up until it stops working.
The measurement that matters: rate of novel disagreement, per unit of incoming data.
Data still flowing while novel disagreement falls means the population converged on each other rather than on the world. The systems agree because they’ve become the same system, not because they’ve gotten it right. Convergence under continuing influx is the primary failure mode and this metric catches it directly.
You’d want a second one alongside it: what fraction of flagged divergences get investigated rather than auto-resolved. Flagging scales with compute. Adjudication doesn’t. A network generating a million flags and resolving them by majority vote has automated the thing it was built to prevent.
What this is a bet on
The engineering case above stands on its own. Independently trained systems, forced indirection, maintained variety, disagreement logged rather than averaged — that’s a testable architecture and the pieces are defensible individually.
The larger claim is a bet, and I’ll flag it as one: that reasoning of the kind we’d recognize as general emerges from enough of these boundaries meeting under continuous pressure. Not from a bigger model. From a population dense enough in incompatible representations, exchanging under constraint, never allowed to settle.
I can’t argue that from the design. The design gives a rationale for building it, not evidence about what it produces. But the one general reasoner anybody has ever observed is a species rather than an individual — billions of differently-configured instances, each fed different inputs, arguing continuously across a network with terrible bandwidth and mandatory translation losses, over a long time. We got language, mathematics, and the scientific method out of that arrangement.
Nobody designed it. It’s what happens when enough different things have to reconcile with each other and can’t stop.
Edge Thinking: The Missing Operating Theory of Artificial Intelligence
Where the argument started. Reasoning as controlled self-opposition.
Constraint Is the Engine
Why friction improves thinking, and why hallucination is an architectural failure rather than a knowledge one.
Aggregated Knowledge
Reconciliation as machine work. The residual pile is the product.
The Corpus Is the Field
Who supplied the training material, and what that establishes about ownership.
The Long Work of Getting Better
Shared knowledge as the engine of progress, and the case against enclosing it.
