███████╗ ███████╗ ███╗   ███╗  █████╗
██╔════╝ ██╔════╝ ████╗ ████║ ██╔══██╗
███████╗ █████╗   ██╔████╔██║ ███████║
╚════██║ ██╔══╝   ██║╚██╔╝██║ ██╔══██║
███████║ ███████╗ ██║ ╚═╝ ██║ ██║  ██║
╚══════╝ ╚══════╝ ╚═╝     ╚═╝ ╚═╝  ╚═╝

A question can be answered in more than one way, and the ways are not interchangeable. Sema holds several, lets them compete, and takes the one that leaves the least of your question unaccounted for.

                 ┌──────────────────────────────────────┐
 your question   │  every route prices its own answer   │
       │         └──────────────────┬───────────────────┘
       ▼                            ▼
┌─────────────┐        one price, one question:
│  route  ·   │        "how much of what you asked
│  route  ·   │  ───▶   did this route fail to
│  route  ·   │         account for?"
│  route  ·   │                     │
└─────────────┘                     ▼
                         ┌─────────────────────────┐
                         │  the lightest answer    │
                         │  wins — and arrives     │
                         │  tagged with the route  │
                         │  that produced it       │
                         └─────────────────────────┘

Because the price is unexplained question — not speed, not confidence — the winner is the route that accounts for most of what you actually asked, rather than the one most eager to answer. It is also why the last line of that table is a legitimate outcome and not a failure: when no route can account for what you asked, silence is a first-class answer. A system that must always produce something will always, eventually, produce fiction.

Give Sema four plain notes — the way you'd jot them down — then ask things no note answers. From three worked examples it learns the shape of "X was painted by Y", lifts the painter out of a sentence it has never seen, and — in the same pass — reasons onward to a separate fact about that painter. Nothing in the reply but the painter's own name comes from the question.

// demo.ts — one short session that drives the WHOLE pipeline from one memory.

import { Mind } from "../src/index.js";
import { SQliteStore } from "../src/store-sqlite.js";

async function main(): Promise<void> {
  const mind = new Mind({ store: new SQliteStore({ path: ":memory:" }) });
  const ask = async (q: string) => (await mind.respondText(q)).trim();

  // ── Jot down what we know. Each line is just (context → what follows). ──
  await mind.ingest([
    // One relation, shown three times — a pattern taught purely by example:
    ["The Mona Lisa was painted by Leonardo da Vinci.", "Leonardo da Vinci"],
    ["The Starry Night was painted by Vincent van Gogh.", "Vincent van Gogh"],
    [
      "The Night Watch was painted by Rembrandt van Rijn.",
      "Rembrandt van Rijn",
    ],
    // One stray fact, keyed on a name none of the examples mention:
    ["Pablo Picasso", "Pablo Picasso co-founded the Cubist movement"],
  ]);

  // 1) GENERALIZE — apply the learned pattern to an unseen sentence and read out
  //    the painter, then keep going into what is known about him.
  console.log(await ask("The Weeping Woman was painted by Pablo Picasso."));

  // 2) COMPUTE — exact arithmetic, grounded right where the notes go silent.
  console.log(await ask("a museum charges 12*4 for a family ticket"));

  await mind.store.close();
}

main();

Pablo Picasso co-founded the Cubist movement
48

Ask for the receipt instead of the text, and each answer says how it was reached — mind.respond(q) returns the same bytes plus a provenance tag naming the route, and, on request, the complete replayable trace behind it:

"The Weeping Woman was painted by Pablo Picasso."  →  provenance: cast
    ( structure carried across the three worked examples )

"a museum charges 12*4 for a family ticket"        →  provenance: cover
    ( composed from the question's own parts — one of them computed exactly )

There is no training phase distinct from using it. Depositing is learning, and a fact is available the instant it lands.

Not "faster than an LLM" — possible where an LLM is not. Each of these sectors is blocked by a requirement no sampled model can meet.

A self-contained app that opens a web chat with Sema. Download, run, start talking — no install, no runtime, no API key.