A brain, not a model.

§ 01 · What it is

Not a bigger model — an architecture around one.

A language model answers one prompt at a time and starts each call from zero: no memory, no goals, no way to tell what it knows from what it’s guessing. reason wraps a model in the parts it’s missing — a set of specialized functions running as a mixture of experts, coordinated into one voice. It keeps a durable memory of who it is, reads intent and stance every turn, and is upfront when it’s uncertain. Making the model bigger adds none of that.

§ 02 · How it differs

What a plain model can’t do.

You can add memory, tools, and retrieval on top of a stateless model, but it still starts each call from nothing. reason is built the other way around: a loop that keeps state between turns, grounds its answers in what it remembers, and can tell what it knows from what it’s guessing.

§ 03 · One turn, step by step

What happens in a single turn.

1. 01

   Recall

   It pulls up who it is and what it already knows about the topic — with the source attached.

2. 02

   Read the message

   A set of classifiers runs over your message at once: intent, stance, urgency, a check against memory for contradictions, and a safety gate.

3. 03

   Gate

   If it’s an attack, it stops. Otherwise it adds what the classifiers found to the context for the reply.

4. 04

   Draft

   The slower model writes several candidate replies, using that context.

5. 05

   Commit

   Each draft is scored for grounding, consistency, and usefulness; the best one is sent. Decisions are logged and reversible.

6. 06

   Re-calibrate

   A separate check judges the reply, and that result tunes the scoring for next time.

• Persistent memory & identity
• Reads intent, not just words
• Contradiction check
• Safety gate
• Calibrated confidence
• Scores options against a goal

§ 04 · Where it fits

Where a plain model keeps failing.

The jobs where a model keeps failing because it has no memory, no context, and no judgment — where getting fooled or forgetting is the whole problem.

1. 01

   Agents that must remember

   A customer, a case, a relationship — carried across sessions, not just one context window. Come back a week later and it still knows the history.

   Across sessions

2. 02

   High-stakes conversation

   Where getting fooled, making something up, or losing the thread is the failure: support, negotiation, advising. It grounds its answers and pushes back.

   When trust is the product

3. 03

   Characters that stay in role

   A persistent persona plus its history — swappable and reproducible. Change the config and you get a different character on the same engine.

   One engine, many characters

§ 05 · What runs today

Measured, not claimed.

This isn’t a mockup. The engine runs: it talks as a live mixture-of-experts, reloads its memory and learned calibration after a full restart, and in adversarial tests reads intent from what the other side does, not just what it says. Everything below is measured.

§ 06 · What it is not

This is not AGI, and we don’t pretend it is.

It makes no claim to general superintelligence or open-ended autonomy. That’s the point: it’s bounded and grounded, and it’s safe to deploy because it knows its own limits — not in spite of them.