LBrain.ai

The model wasn't the problem. The record was. LBrain gives any AI persistent, provenance-aware memory that survives sessions, models, and time.

Comment 1

Inspiration

AI interactions kept losing continuity.

Memory systems helped, but something still felt wrong. For me, the experience was always missing something I couldn't quite put my finger on. So instead of focusing only on the model, I started studying the record: what an AI receives, where it came from, what it refers to, what changed, and what superseded it.

That became a research program. Each paper produced another finding, another experiment, and usually another change to LBrain.

Then our AI started confidently telling us wrong things about our own company.

Not inventing facts out of nowhere — worse. It would take a real number from a document we wrote ourselves, attach it to the wrong entity, and state it plainly.

The retrieval worked. The answer was wrong anyway.

So we measured why.

Across ten models — zero exceptions — accuracy fell to 26–50% on questions whose answers were sitting right there in the retrieved text, against ~100% on the same questions with a clean record. Model identity explained almost none of the variance. The signature reproduced on a fully value-rotated public corpus, with ordering preserved across every model we ran.

Swap the model, the failure stays. Change the structure of the record, the failure moves.

We weren't going to enter this competition — we didn't think we fit. That result is why we're here two weeks late with an incomplete entry.

If it holds up, some part of what's currently treated as a training-scale problem is a record-structure problem, and it's available now rather than next cycle.

We're not making a larger claim than that.

Anyone can check it in an afternoon, on whatever model they already run.

What it does

LBrain is a memory and context engine that runs entirely on your own machine.

pip install lbrain

No API key, no account, on-device embeddings.

It serves records with their source, date, provenance, and supersession attached, so an agent can tell what a record is before it acts on it. Current information can take precedence without destroying the history it replaced.

A harness manages the model.
LBrain manages the record.

Underneath it sits permanent identity: gcx:// and aet://, both registered with IANA in July 2026. Agents and people get durable, owned, verifiable names instead of rented accounts.

The same substrate already carries live identities. A founding customer completed the full automated path from checkout to wallet provisioning to registry claim, and the resulting gcx:// name is publicly resolvable without credentials.

You can curl it right now.

How we built it

Every session begins with LBrain supplying the current decisions and context relevant to that seat.

Decisions are dated to the incidents that produced them. Superseded records stay inspectable rather than disappearing. Unresolved work outlives the session that created it.

Nothing starts over.

That's also how we run the company: named AI executive seats — a CTO seat, a CSO seat, a creative officer — working under a human founder who supplies intent, ground truth, adjudication, and authority.

The agents build. They challenge one another, red-team one another, and sometimes change the human's mind. The human does the same to them and holds the irreversible gates: payments, releases, identity.

The point isn't removing humans from the loop. It's making the loop remember what it learned.

It runs on Google Cloud throughout — Cloud Run, Cloud Functions, Cloud Scheduler, Firestore, Secret Manager, Firebase, Cloud Build. Gemini works in the product, where our enrichment agent runs on Vertex AI, and in operations, where Deep Research is a standing second opinion. It redesigned one subsystem this window after our own escalation doctrine fired.

Challenges we ran into

Our AI CTO built the payment system.

Then it refused to ship its own code.

Eleven adversarial red-team rounds followed. Fresh reviewer agents each round, every finding handed to a verifier instructed to refute it.

Roughly 105 confirmed defects surfaced — including regressions the AI's own earlier fixes introduced and the next round caught.

It shipped when an independent pass came back clean, not when the builder said, "I fixed the findings."

Three rounds in, the same subsystem kept churning. That's a written trigger in our operating doctrine, so the escalation fired and Gemini Deep Research returned an architectural redesign, adopted and scheduled behind its own audit.

Then there was the unglamorous failure: two work-critical messages between our AI seats were committed but never pushed. One seat sat looking at an empty inbox during a live incident.

Committed is not delivered.

It's a standing hazard now, written down where the next session will encounter it.

Accomplishments that we're proud of

The first fully automatic customer lifecycle:

checkout → charge → wallet provisioned on the fly → registry claim → AI-written welcome email → member home

24 seconds, no human intervention, no retries, with every stage timestamped from logs rather than memory.

That's our baseline record now. The thousandth customer gets compared against it.

gcx:// and aet:// were accepted by IANA. LBrain is public on PyPI, and our datasets are public on HuggingFace. The research behind the system includes eleven DOI-archived artifacts — seven papers, two datasets, and two software releases — and five U.S. provisional patent filings: work produced before this system was assembled, not retrofitted afterward to justify it.

But the accomplishment we care about most may be simpler:

The system worked because the builder wasn't allowed to be the judge.

What we learned

The improving agent must not control the definition of improvement.

That's the load-bearing rule of our guardrails work, and it's why we can't be the ones who validate our own finding. Our research program is built around external falsification, frozen evaluators, adversarial verification, and published negatives.

Second: in our tests, a poisoned record was relayed verbatim.

Grounding delivered faithfulness, not truth. Retrieval alone offered no protection.

That's why the record needs tamper-evidence and provenance, not just relevance.

Third, humans aren't simply emergency brakes. Human adjudication can surface nuance an AI missed; a sufficiently strong AI argument can overturn a human judgment. Several of our operating rules came from exactly those collisions.

The useful unit isn't human judgment or AI judgment alone.

It's correction that survives the session in which it happened.

And that's the larger lesson we've learned from running a company this way:

The audit trail isn't documentation of the work. It is the work.

What's next for LBrain

Next, we want people equipped to break this result to try.

The immediate work is external replication: different models, different corpora, frozen evaluators, published negatives. We're testing whether record structure — not model identity — continues to predict the failure, and exactly where that explanation stops working.

We're also testing the practical consequence that led us here in the first place: whether carefully curated, provenance-aware memory can give different models durable continuity without turning the context window into a database.

LBrain is already public. The result is reproducible.

We would rather find the boundary of the claim now than make the claim larger.

Built With

Share this project:

Updates