An agent brain still needs an ontology overlay

Garry Tan’s GBrain starts with a blunt public claim: an AI agent can be smart and still forgetful.

The public GBrain README makes that claim concrete. It describes a brain that ingests meetings, emails, tweets, voice calls, and ideas; enriches people and companies; creates typed links when pages are written; and combines hybrid search with a self-wiring knowledge graph. Its public gbrain-evals README publishes BrainBench and LongMemEval results for the retrieval layer.

Hadto agrees with the direction. Durable memory is a real primitive for agent work. The next question is narrower: when does a remembered page become safe enough to steer an operating decision?

In this note, the proof means a small Hadto test harness. It contains a documented overlay contract, a JSON schema for that contract, a deterministic scorer, and fixture-backed tests for three example work surfaces. A fixture is a sample operator record plus the expected overlay answer. The proof tests behavior. It does not claim that a live GBrain integration has shipped.

Memory is not yet authority

An agent brain can tell the operator what it remembers. A remembered fact still has to prove it is ready to steer work.

A brain page is the durable page a memory system keeps about a person, company, job, claim, meeting, or decision. It can retrieve the story and connect it to nearby pages. That is not the same as deciding that the page can govern the next action.

A page might remember that a service lead is owner-led, that a dispatch job is waiting in a route queue, or that a dental claim is blocked by a plan rule. Before the business acts on that page, it needs sharper answers.

What ontology class names the subject? Which relation did the page assert? What operator question is being answered? Which source item supports the answer? What state transition is being claimed? Which rule would block it? What score decided whether the surface renders cleanly, renders with warning, routes to review, or refuses to render?

Search helps find the page. Governance decides what the page is allowed to do.

The overlay is the contract beside the page

Hadto’s overlay treats the brain page as the remembered narrative and the overlay as the machine-checkable contract beside it.

The overlay does not replace GBrain-style memory. It assumes the memory exists. It adds a typed, deterministic payload that can sit next to a page and say what the page is allowed to mean inside the work system.

The contract asks the overlay to bind itself to one page and one business subject. It requires class assertions, relation assertions, evidence items, competency-question answers, state machines, transitions, invariants, blockers, and a repeatable scoring result.

The important part is the refusal path.

A good memory system should get richer over time. A good operating system should also know when a rich memory is not enough.

What the proof actually tested

Hadto tested the overlay with three fixtures: owner-led revenue work, home-services dispatch work, and dental claim lifecycle work.

Each fixture gave the scorer a candidate overlay and an expected overlay. The scorer checked class matches, relation matches, operator-question answers, evidence status, transition validity, invariant status, unsupported assertions, and the diagnostic report. The output had to be stable enough for a test to fail for the same reason every time.

The tests covered clean passes and refusal behavior. A matching overlay passed. Missing evidence routed the page to review. An invalid transition failed. An unsupported assertion failed. Conflicting evidence routed the page to review instead of letting the page sound confident.

The owner-led revenue fixture followed a lead that needed a clear owner, a supported routing reason, and an affordability gate. The overlay had to say who owned the lead, which evidence supported the owner-led claim, what changed the route, and when the page should review instead of render cleanly.

The home-services dispatch fixture followed a service call moving through work-order states. The overlay had to distinguish a job waiting in a route queue from a technician assignment claim. It also had to reject a transition that skipped the required dispatch step.

The dental claim lifecycle fixture followed a treatment, plan rule, claim status, and evidence packet. The overlay had to keep those facts in one reviewable payload and route the surface to review when active evidence conflicted with the claim path.

That is what the proof tested: whether a remembered page can pass a typed evidence contract before it governs work.

What we have not proved yet

This proof does not show a production runtime wired into GBrain. It does not show live ingestion from meetings, email, dispatch systems, or claims systems. It does not show a finished operator interface, a human review queue, or performance under a large page set.

Those are later integration tests. The current proof is smaller and still useful: it shows the contract a remembered page should satisfy before Hadto treats it as a governed operating surface.

Why it matters for owner-operators

Owner-operators do not need a second brain only to make a better summary.

They need a system that helps the next person make a better decision. That requires memory, but it also requires typed work objects, source evidence, review gates, and clear refusal rules.

A dispatch manager should be able to ask which jobs are blocked and see the evidence path. A revenue owner should be able to ask why a lead is routed through an affordability gate and inspect the rule. A dental operations lead should be able to ask which claim path is blocked by a plan rule and see the supporting source, not only a polished paragraph.

GBrain makes the public case that agent memory should be durable, searchable, linked, and self-improving. Hadto’s overlay proof adds the operator constraint: the remembered page needs an ontology-backed contract before it becomes a surface for authority.

That contract does not make the agent omniscient. It makes the agent’s uncertainty useful.

When evidence is missing, the page should not pretend. An invalid transition should fail. Conflicting evidence should route the work to review. Clean assertions should give the operator a typed page with enough structure to show the next person how the decision was made.

The practical bridge from agent brain to operating company is not a longer summary. A brain remembers what happened. An ontology overlay says what the remembered page is allowed to do next.

---

Source evidence used in this note: public GBrain README permalink, public gbrain-evals README permalink, and public Garry Tan status thread. Hadto tested the overlay internally on 2026-05-17 against a documented contract, JSON schema, deterministic scorer, and fixture-backed cases for owner-led revenue, home-services dispatch, and dental claim lifecycle work. This note describes the tested behavior without requiring readers to inspect internal implementation artifacts.