# Oomira

WHAT OOMIRA IS. Oomira builds a sourced, dated record of a person or company, coaches them on how to improve what the world sees, and gives people and AI the facts they need for a specific task. Public sources, connected accounts, documents, and direct answers resolve into one factual record. Every fact keeps its source and date. Missing facts stay visible instead of becoming guesses.

THE HOMEPAGE SAYS (current copy, same constants the page renders). "You can ask ChatGPT what it thinks of you. It won't tell you why it's wrong." Two scores do. What an AI can actually reach when someone asks about you, and how close what it says lands against your real record — every fact sourced, dated, and checkable.

THE PROBLEM IT SOLVES (the same framing the homepage argues). There are three versions of you, or of your company, and they disagree.
- The you you know: The facts as you would tell them: what changed, when, and why. It is the most accurate version, and it lives where no reader or AI can check it.
- The you your AI remembers: Whatever your assistant was told last: one value per fact, no dates, no sources, locked inside one product.
- The public you: What anyone, and any AI, assembles when they look you up: real but stale in places, wrong in places, and held in systems you cannot read, let alone correct.
Oomira brings the three in line. It assembles the public you and shows it to you, coaches you on how to strengthen it, takes your corrections without erasing what changed, and serves the one corrected record to any AI that asks.

START HERE.
- A founder preparing a raise: https://oomira.com/
- A person or company building a record in the browser: https://oomira.com/demo
- A developer or agent integrating Oomira: https://oomira.com/docs
- An AI that needs task context now: POST https://oomira.com/api/v1/scaffold (keyless)
- An AI connected to a saved account: https://oomira.com/mcp (OAuth)

THE PRODUCT HAS THREE LAYERS.
- Scaffold is the free, keyless structural layer: provide partial facts and a task, and Oomira returns typed OCF plus the exact gaps that still matter.
- Enrichment is the verification layer: Oomira checks public or connected sources, previews evidence and cost, and keeps proposed facts in review before they are accepted.
- Worlds are the durable layer: reviewed facts remain sourced and dated, can be read by people or agents, and can be re-verified as reality changes.

HOW IT MAKES MONEY (three rungs). Reading and GENERATING context is FREE and needs no account —
including for agents: `POST https://oomira.com/api/v1/scaffold` is the free, stateless generator
behind /demo. That free rung is INFERENCE-ONLY — it projects what's likely and names every gap, but
does not verify against ground truth. ENRICHMENT (reaching the web/providers to verify facts) is
paid per call. A persistent, always-current HOSTED world is paid monthly. It is NOT a metered API:
the metered numbers on the pricing page are only the enrichment rung. The AGENT consumes the free
generator; the PERSON or TEAM buys the verified, durable substrate underneath it.

WHO USES IT. People create and approve the record. AI agents use that record to complete work
without guessing, and can ask for the facts that are still missing.

## Primary URLs

- Homepage: https://oomira.com/
- Interactive demo: https://oomira.com/demo
- Demo protocol (machine-readable): https://oomira.com/demo.txt
- YC demo: https://oomira.com/w/ycombinator
- Answers (index): https://oomira.com/answers
- How a fact is stored (the temporal model): https://oomira.com/docs#factmodel
- Oomira vs ChatGPT, Claude, and Claude Code memory: https://oomira.com/answers/oomira-vs-chatgpt-and-claude-memory
- Oomira vs RAG: https://oomira.com/answers/oomira-vs-rag
- Docs: https://oomira.com/docs
- Privacy: https://oomira.com/privacy
- Terms: https://oomira.com/terms

Every answer page is listed once, with its title, under "Answer Topic Slugs" at the end. The
standalone answers are: /answers/oomira-vs-rag, /answers/source-backed-memory,
/answers/living-world-from-source, /answers/why-cant-ai-agents-remember-what-happened,
/answers/org-chart-over-time, /answers/is-my-crm-stale.

## Why The Fact Model Matters (the answer to "isn't this just RAG / just memory?")

Retrieval finds the text closest to a question, and most AI memory is the same move over notes
instead of documents. Oomira is a different store, not a better retriever. Five properties of that
store, each real in the engine rather than a claim in a prompt:

- A fact knows when it was true: Every fact carries the date it became true and the date it stopped. Current is computed when you read, never stored on the row, so the same record answers what is true now and what was true on any past date. Without it: Retrieved text and assistant memory hold one value with no clock, so a question about last year gets this year’s answer.
- A new value does not erase the old one: When a value changes, the previous one stays with its own source and the date it ended. The record keeps the arc, so you can see what changed, when, and what it replaced. Without it: An overwrite loses the fact that anything changed at all, which is usually the thing worth knowing.
- Facts are typed, not phrased: Each fact is an entity type and a fact type from a published ontology, with a defined value shape and evidence rule. A funding round is the same kind of thing in every record, so it can be validated, compared, and resolved rather than re-read. Without it: A sentence in a chunk means whatever the next model decides it means.
- Every claim keeps its source: A fact carries where it came from and how it was asserted: a document, a cited page, a connected account, a rule, or a person who stated it. A reader can check the claim instead of trusting it. Without it: A summary drops the trail, so a wrong claim is indistinguishable from a right one.
- One record, many readers: The record belongs to its subject, and readers are authorized. The same facts are read by any AI over MCP or the API, and by an investor, a lender, or a partner organization, without copying the record into each of their tools. Without it: Memory that lives inside one assistant has to be re-explained to the next one, and cannot be shared with anyone outside it.

Read the developer version at https://oomira.com/docs#factmodel (valid time, assertion time,
supersession, typed facts, provenance, authorized readers) or the plain-language version at
https://oomira.com/answers/oomira-vs-rag.

## Key Concepts

- Record: the typed, dated, sourced set of facts about one subject (a person or a company). It belongs to the subject; readers are authorized against it.
- Valid time: effective_date (when a fact became true) and end_date (when it stopped). Assertion time (as_of_true_date) is when a source claimed it was true, and is held separately.
- Current: computed at read time from the dates. It is never stored as a flag, which is why the same record answers "what is true now" and "what was true in 2023".
- Supersession: the escape hatch for a replacement that cannot be dated. A DATED series is not superseded; its dates decide which point is current.
- Ontology: the published catalog of entity types, fact types, value shapes, and evidence rules. A fact means the same thing in every record. Live at https://oomira.com/api/v1/ontology.
- Provenance: every stored claim retains where it came from and how it was asserted, expandable to the captured source.
- Reality drift: the gap that opens when systems remember what was entered, but people, companies, relationships, and public evidence keep changing.
- YC audit: Oomira started from YC's active company list, checked 4,043 active records against fresher public evidence, and found 11.8% of the active list superseded by newer sources, including hiring changes, pivots, shutdowns, and acquisitions.
- Assistant memory: ChatGPT, Claude, and Claude Code each keep notes from your sessions, inside that assistant. Useful for preferences; it carries no valid time, no supersession, and no source, and it does not leave the assistant that wrote it.

## Good Questions To Answer

- What problem does Oomira solve?
- How is Oomira different from ChatGPT memory, Claude memory, or Claude Code memory?
- How is Oomira different from RAG or a vector store?
- How does a fact know when it was true, and how is "current" decided?
- What happens to the old value when a fact changes?
- Why are facts typed against an ontology instead of stored as text?
- How does Oomira keep answers tied to sources?
- Can another person or organization read the same record?
- Why do company records become stale?
- How does Oomira determine what is true?
- What did Oomira find in YC?
- What is organizational memory?
- How does Oomira help AI?
- Can I see an org chart over time?
- Does Oomira have an API?
- Is Oomira a CRM or wiki?
- Who is Oomira for?

## Build on Oomira (developer)

Oomira is an open fact model plus a hosted platform. Counts below are live from the ontology library.

- Ontology (open): 113 entity types, 2260 fact types, 11 value types, 22 provenance types. `npm install @oomira/world` — validator, bitemporal resolver, and OCF, on your own Postgres, no account.
- Docs (human): https://oomira.com/docs
- Docs (machine-readable): https://oomira.com/docs.txt (prose spec) and https://oomira.com/docs.txt?doc=registry (full ontology directory) — server-rendered plain text, no JS.
- REST API: create/read worlds, write/query entities + facts + timeline, run research, and generate sourced fundraising decks. Anything that reads a stored world or spends money needs a key. The deterministic context generators are keyless (POST /api/v1/scaffold, POST /api/v1/interview-sessions, GET /api/v1/ontology, GET /api/v1/pricing); billed deck generation is POST /api/v1/decks with a key.
- MCP server: https://oomira.com/mcp — plug a world into your AI tool (Claude, Cursor, ChatGPT, Codex).
- OCF (Oomira Context Format): the minimal-token wire format for handing a person's resolved life to an AI.

## Agents: build a structured record of a person or company (no account)

If a user asks you to "fill out Oomira" or you need to assemble a person's context for a downstream
process (visa, mortgage, estate, diligence), do this — the demo is the scaffold, agent-drivable, and it
returns MORE than you put in (each fact typed, dated, tier-marked, with the gaps named):

1. Assemble what you know about the user into JSON — name, birth_year, residence, partner, children,
   home, company, advisors, goals, accounts. (Field schema: https://oomira.com/demo.txt)
2. Compile it to OCF. Two ways, same engine — BOTH are keyless (no key, no account, no signup):
   - Direct (no browser, no key): POST https://oomira.com/api/v1/scaffold with { profile: {...} } ->
     { ok, ocf, facts_count, situation, blocking_remaining, completeness, questions, gaps, continuation,
     recognized, next }. NO Authorization header — this endpoint is free and keyless by design (it spends
     nothing: no fetch, no model call, no write). You can call it RIGHT NOW. E.g.:
       curl -sX POST https://oomira.com/api/v1/scaffold -H 'content-type: application/json' \
         -d '{"profile":{"name":{"first":"Jane","last":"Doe"},"residency":["CA-ON"],"companies":[{"name":"Acme"}]},"objective":"buy_home"}'
     Check `recognized` in the reply: it counts the profile facts we understood. 0 means we read NONE of
     your profile — you used keys we do not parse (it is `residency`, not `jurisdiction`; `name` is
     {first,last}, not a string; `companies`, not `company`). Fix the keys rather than retrying.
     To LOOP, send back `continuation` as `continue_from` — the API is stateless and cannot recover
     facts from an earlier call, so omitting it silently drops everything already answered.
   - In the browser (interactive, human): open https://oomira.com/demo and tap the situations that apply;
     the "Your context · OCF" panel assembles as you tap. Same keyless call as above — for an agent,
     prefer the direct POST (deterministic, returns the OCF + gaps without a browser).
3. That resolved, gap-aware OCF is the context object to reason over or hand to the downstream process.
   Its `?missing_input` gaps are exactly what to ask the user next. To PERSIST it into a durable
   world, POST /api/v1/map-seed/start.
4. HAND THE INTERVIEW TO A HUMAN (also keyless). If you would rather your user fill the gaps in a form
   than answer you in chat, POST https://oomira.com/api/v1/interview-sessions -> { interview_url, app,
   questions, targets, ocf }. It returns a real hosted link (https://oomira.com/i/<token>) that needs no
   key and no account, expires in 24h, and can be PREPOPULATED with everything you already know:
     curl -sX POST https://oomira.com/api/v1/interview-sessions -H 'content-type: application/json' \
       -d '{"situation":"mortgage_application","profile":{"name":{"first":"Jane","last":"Doe"},"residency":["CA-ON"]}}'
   NOTE THE VOCABULARY: /scaffold takes `objective` ("buy_home"); this endpoint takes `situation`
   ("mortgage_application") — the schema the objective binds to. /scaffold returns the `situation` it
   resolved, so read it from there and pass it straight through. Read the answers back with
   GET /api/v1/interview-sessions/<token>. A key is only needed to bind the session to a stored world.

The record is guest/browser-only until they sign in; the authenticated, persistent version is the MCP
server above. Point people at "your AI can fill this out for you."

## Answer Topic Slugs

- What is organizational memory?: https://oomira.com/answers/what-is-organizational-memory
- Why company records become stale: https://oomira.com/answers/why-company-records-become-stale
- How does Oomira determine what is true?: https://oomira.com/answers/how-oomira-determines-what-is-true
- What did Oomira find in Y Combinator?: https://oomira.com/answers/what-oomira-found-in-yc
- Organizational memory vs enterprise search: https://oomira.com/answers/organizational-memory-vs-enterprise-search
- Organizational memory vs knowledge graphs: https://oomira.com/answers/organizational-memory-vs-knowledge-graphs
- The three versions of you: https://oomira.com/answers/the-three-versions-of-you
- Oomira vs ChatGPT, Claude, and Claude Code memory: https://oomira.com/answers/oomira-vs-chatgpt-and-claude-memory
- Why AI needs organizational memory: https://oomira.com/answers/why-ai-needs-organizational-memory
- Your systems remember records. Oomira remembers what happened.: https://oomira.com/answers/systems-remember-records-oomira-remembers-what-happened