How to Make AI Better

Ask a popular AI chatbot a serious question and you'll often get a confident, well-written, professional-sounding answer. Sometimes it's right. Sometimes it's completely invented — a court case that was never decided, a study that was never published, a citation that looks perfect and points to nothing. And here's the unsettling part: the AI can't tell the difference. The made-up answer and the true one feel exactly the same to it.

This isn't a rare glitch. It's a known, measured, structural problem. In an independent Stanford study of the leading AI legal research tools — products built specifically for lawyers, with years of engineering behind them — the systems fabricated information in 17% to 33% of answers. General-purpose chatbots do far worse. For any field where being wrong has consequences — law, medicine, engineering, government, a museum's catalogue — that failure rate is a non-starter.

The industry's answer, for years, has been the same: make it bigger. More data, more parameters, more graphics cards, more electricity. That approach is running into a wall. And it turns out that "bigger" was never going to fix the real problem, because the real problem isn't size. It's architecture.

Here's what's actually going wrong, and how it can be fixed.

Why AI makes things up

To understand the fix, you first have to understand why today's AI hallucinates — and it's simpler than it sounds.

Picture a brilliant expert who has read entire libraries but kept none of the books. No shelves, no notes, nothing to look up. Everything they know is blended together in their memory. When you ask a question, they answer from that blur. Most of the time it's fine. But when their memory is thin on a topic, they don't go quiet — they reach for whatever sounds like the kind of thing that would be true, and they say it with total confidence. They aren't lying. They genuinely can't distinguish a real memory from a plausible-sounding reconstruction.

That is, almost exactly, how a transformer — the technology behind today's mainstream AI — works. All of its knowledge is baked into billions of internal numerical settings during training, mixed in with its ability to reason and write. Facts and reasoning live in the same place, inseparably. So at the moment it answers, the system has no way to check whether a statement is true. It only knows whether the statement fits the pattern of its training. Truth and plausibility are not the same thing, and the architecture can't tell them apart.

This is why making the model bigger doesn't solve it. A larger model is a more knowledgeable expert with a better memory — but it's still an expert with no library, still answering from a blur, still unable to catch its own inventions. Researchers have even shown mathematically that for a system generating purely from its own memory, without the ability to say "I don't know," a certain rate of confident fabrication is unavoidable. You cannot scale your way out of it. It's built into the shape of the thing.

The cost of "just make it bigger"

While bigger doesn't fix the reliability problem, it does make three other problems dramatically worse.

The first is energy. Running these giant models consumes staggering amounts of electricity — enough that data-center power demand is projected to nearly double by the end of the decade, and the largest AI companies are now buying nuclear plants to keep up. Every answer from a frontier model draws real power from a rack of expensive hardware. That's why serious AI has, until now, meant the cloud: the models are simply too heavy to run anywhere else.

The second is that this locks most people out. If your AI can only live in a distant data center, then it can't run in a rural clinic, a secure government facility, a ship at sea, or anywhere without a fat internet connection and a big power budget. Whole categories of work — anything private, air-gapped, remote, or offline — are shut out by default.

The third is that these systems can't easily learn anything new. Because a transformer's knowledge is fused into its training, teaching it something new means retraining it — a process that can cost tens or even hundreds of millions of dollars per cycle. New case law, a regulatory change, this morning's research, your own updated files: none of it is truly in the model until someone pays for another enormous training run. The knowledge is always a little out of date, and there's no cheap way to fix that.

Three expensive problems, all flowing from one root: cramming knowledge and reasoning into the same place and then making that place bigger.

A different approach: give the expert a library

Now imagine we do the opposite. Instead of one all-knowing expert answering from memory, we split the job in two.

We keep a reasoning engine — the part that understands your question and writes a clear answer — but we take the knowledge out of its head entirely and put it in an external, organized library. The engine's job is no longer to remember every fact. Its job is to reason over the facts the library hands it. And critically, before any answer reaches you, a verification step checks every claim and every citation against what's actually in the library. If a statement isn't grounded in a real source, it doesn't go out. If the library simply doesn't contain the answer, the system says so — "I don't have grounding for that" — instead of inventing something.

This is the heart of the Engraphic approach, and it changes the outcome completely. An expert who has to consult a real library, and whose answers are fact-checked against it before they're allowed out the door, cannot confidently cite a case that doesn't exist — because there's no book on the shelf to point to.

In our benchmarks, this is exactly what happens. Across 969 questions spanning nine different fields — legal, medical, historical, scientific, and more — the system produced zero fabrications. Not a lower rate. Zero. In a head-to-head test where the only thing we changed was switching our architecture on or off, the same underlying model went from passing 15% of hard questions to passing 100%. The fabrication didn't get better. It disappeared, because the thing that caused it was removed.

We designed and ran these tests ourselves, and we publish the full method and the verifiable result files precisely so that others can check our work. That openness is deliberate: a reliability claim you can't inspect isn't worth much.

A library that thinks like a mind

The library isn't just a pile of documents. It's organized using two ideas borrowed from how knowledge and memory actually work.

The first comes from the human brain. When you read two things in the same sitting, your mind links them — and the more often you draw on that link, the stronger it gets, while links you never use quietly fade. We apply that same principle to the library. Documents that come in together become associated; associations that prove useful strengthen with use; ones that don't, decay. Over time the library learns which pieces of knowledge belong together — not because someone programmed the connections in advance, but because they earned their strength through use, the way memory does. This also lets it surface a connection between two fields that share no common vocabulary but are genuinely related — the kind of insight a seasoned researcher makes and a keyword search never will.

The second idea is about shape. Knowledge is naturally tree-like: broad principles branch into frameworks, which branch into specific cases. Ordinary filing systems flatten that tree and lose the relationships. We instead organize the library using a kind of "curved" geometry that fits tree-shaped knowledge the way a globe fits the round earth better than a flat map does. It means the library can hold an enormous, deeply layered body of knowledge while keeping every relationship intact. In plain terms: we shape the library to match the shape of knowledge itself.

Smaller, cheaper, and yours

Here's the payoff that surprises people most. Once the reasoning engine no longer has to memorize the world — because the library holds the facts — the engine itself can be small. And a small engine backed by a great library beats a giant memorized model on the work that matters.

How small? We've run this system, with the same zero-fabrication result, on an ordinary laptop with no special graphics card, drawing about the power of a night-light. A compact model paired with a well-built library matched the performance of models more than a hundred times its size on grounded, factual tasks. That's not a minor efficiency gain. It's the difference between "this only runs in a billion-dollar data center" and "this runs in your office, on hardware you already understand."

We push the same idea down to the hardware level, too. Normally a computer spends most of its effort just moving an AI model's data back and forth to be worked on — that shuffling is the real bottleneck, and most of the machine sits idle waiting for it. We've developed a way to make the act of reading the data perform the calculation itself, so the work happens in the same motion as the retrieval, with no added specialized chips. It's a second, deeper source of the same result: far more capability from far less compute.

Add it all up and you get something the cloud-and-scale model can't offer:

The system runs on your own premises, on modest hardware, fully offline if you want it — which makes it suitable for private, secure, air-gapped, and remote settings that mainstream AI simply can't serve. Your data never leaves the building. You can teach it instantly: add a document and it's available the moment it's saved, no retraining, no waiting, no seven-figure cost. Every answer comes with a checkable, auditable record of what it was grounded in — which is exactly what regulated fields and new AI-transparency rules require. And because you can add or remove any single record cleanly, it handles real obligations like correcting an error or honoring a deletion request without breaking the rest of the system.

You own it. No subscription, no per-question meter, no dependence on someone else's servers staying up or their prices staying flat.

The real lesson

For years the story of AI has been a story of more — more scale, more power, more money, chasing improvements that never quite fix the thing that matters. The uncomfortable truth underneath all that spending is that the flaw everyone worries about, the confident lie, was never a problem you could outspend. It was baked into the design.

Which means it can be designed out.

Fabrication isn't a property of intelligence. It's a property of an architecture — one particular way of building AI that fuses knowledge and reasoning and then hopes for the best. Build it differently — keep the knowledge in an honest, learning library, keep the reasoning separate, and check every answer before it goes out — and the problem doesn't shrink. It goes away.

Better math makes better AI. That's the whole idea, and it's available now.