# justonce.ai

> The memory layer for your AI — one memory, every tool.

justonce.ai is a persistent, vendor-neutral memory layer for AI assistants. You tell
it something once, and every AI you use recalls it — Claude, ChatGPT, Cursor, VS Code,
Windsurf, the Gemini CLI, or any MCP client — instead of you re-explaining yourself in
every new chat. It is used both personally and for work. Built and hosted in Australia.

## The problem it solves
- Every AI vendor keeps memory in its own silo, so context does not follow you between
  tools. What you told Claude, ChatGPT does not know.
- Built-in AI memory is small and fails quietly — ChatGPT's saved memory fills up and
  starts discarding entries while still saying "memory updated".
- Built-in memory is a black box: you cannot see what is stored, correct it, or scope it.

## What it does
- Stores facts, decisions, preferences and documents once, recalled by every connected
  AI assistant through one MCP endpoint.
- Keeps your exact words. Memories are verbatim-first — the original text is retained
  alongside the distilled version.
- Bitemporal history: corrections supersede rather than overwrite, so you can ask what
  was true as of any past date and get the answer that was right *then*.
- Confidence tiers on every fact, so an assistant can tell a verified fact from an
  inference.
- Entity and relationship graph extracted automatically from what you store.
- Semantic search in plain language, not keywords.
- Categorises what you save across 18 categories spanning both life and work
  (Identity, Property & Home, Education, Family, Employment, Finance, Bills & Utilities,
  Insurance, Health, Legal, Vehicles, Travel, Contacts, Credentials, Subscriptions,
  Shopping, Ideas & Notes, Other).
- Shared spaces for sharing selected memories and documents with other people —
  a partner, a family, a team, a client, or a contractor.

## The 27 MCP tools
Recall: `get_core_profile`, `search_memories`, `get_memory`, `get_context`, `get_as_of`,
`get_memory_history`, `list_categories`, `search`, `fetch`.
Write: `add_memory`, `update_memory`, `forget_memory`, `import_memories`.
Graph: `explore_connections`, `find_related_entities`, `get_relationships`,
`get_entity_confidence`.
Documents: `store_document`, `request_upload_link`, `check_upload_link`, `fetch_document`.
Sharing: `open_shared_space`, `list_shared_spaces`, `list_space_memories`,
`add_memories_to_space`, `remove_memories_from_space`, `close_shared_space`.

## Connecting
- One endpoint for every client: https://mcp.justonce.ai (remote Streamable HTTP,
  OAuth sign-in via Auth0 with PKCE and Dynamic Client Registration, no API key).
- Claude Code: `claude mcp add --transport http justonce https://mcp.justonce.ai`
- One-click deeplink installs for Cursor and VS Code; connector URL for ChatGPT.
- Setup guides per client: https://justonce.ai/connect
- A REST API with self-service `jo_` keys is available for automation platforms
  (n8n, Make, Zapier) and custom agents.

## Getting information in
- Type or paste a note in the web app, or tell any connected AI assistant to remember it.
- Upload `.txt`, `.md` or `.csv` files in the web app (25 MB).
- Store PDF, JPEG, PNG, GIF, WebP, DOCX and XLSX files (25 MB) through the MCP
  `store_document` tool or as email attachments.
- Forward email to a private address on the `ingest.justonce.ai` domain. Email
  forwarding is a paid-plan feature and requires you to connect your own AI provider
  key (Anthropic, OpenAI or Google) — it then runs on your key and does not consume
  your justonce.ai allowance.
- justonce.ai does not run OCR. Scanned or image documents are transcribed by your own
  connected AI, or stored as files without transcription.

## Sharing — what it does and does not do
- A shared space is created by a user, who is its Owner. Roles are Owner, Editor and
  Viewer. There is no separate Admin role.
- Owners invite by email, and **the person invited must already have a justonce.ai
  account** — there is no invite-and-sign-up flow.
- You can share with anyone: a partner, a family member, a colleague, a client or a
  contractor. There is no organisation boundary and no email-domain restriction.
- A person can belong to any number of spaces, so separate teams or separate clients
  can each have their own.
- Your personal space is private and can never be shared.
- An AI assistant's `search_memories` recall now covers shared spaces too: memories
  other members shared into your active spaces come back alongside your own, each
  attributed to whoever shared it (a `shared` block naming the sharer and space) and
  read-only to you. Very broad sharing footprints are searched with caps, and the
  response reports any coverage gap rather than hiding it. `list_space_memories` reads
  the full contents of any one space.
- `get_context`, `search` and `get_core_profile` still cover your personal space only.
- Assistants can also create spaces, invite members (always as Viewers), share memories
  in and out of a space, and fetch documents shared into one.
- A document travels with the memory it is attached to. Files always land in the
  uploader's own vault first; sharing that memory into a space lets any member fetch the
  file through their assistant or open it from the space in the web app (audited). A
  member sees exactly the memories shared, not the rest of a document's distilled set.
  Nothing is "stored in" a space directly.
- `store_document` and `request_upload_link` take `content` (the assistant's own reading
  of the file), `category` and `space_id`, so the facts are distilled into memories, the
  file attached to the primary one, and the memories shared into the space in one call.
  An assistant cannot pass a photo's bytes as a tool argument, so for a phone photo or
  PDF it hands the user a single-use browser upload link (expires in 15 minutes); the
  original attaches when the upload lands. A file that arrives with no `content` becomes
  a title-only memory, unless the user has their own provider key, in which case
  justonce.ai asks their model to transcribe it.

## Security and privacy
- Memory bodies are encrypted at rest under per-space keys; document files under
  per-user keys; both AES-256-GCM.
- There is no PII detection, masking, or redaction step: stored content, including any
  sensitive details in it, is processed by the AI pipeline that classifies and organises
  it. Encryption protects data at rest, not from that pipeline — do not describe content
  as filtered, redacted, or vaulted before it reaches a model.
- The memory engine runs internal-only, with no public DNS record.
- Data is hosted in Australia (Azure).
- Your data is never used to train models.
- Append-only audit log covering space membership changes, document access and ingestion.
- This is not end-to-end encryption: the searchable index holds readable text so that
  search works. We do not claim zero-knowledge.

## Pricing (USD)
- Free: $0/month — 20 memories + 10 document pages a month, 2 AI-assistant connections,
  unlimited recall and search, signup welcome bonus of 100 memories.
- Plus: US$8.99/month — 100 memories + 120 pages a month, shared spaces, email
  forwarding, unlimited AI-assistant connections, welcome bonus of 1,000 memories.
- Pro: US$19.99/month — 200 memories + 400 pages a month, priority processing, full
  memory history, welcome bonus of 2,500 memories.
- Students: US$4.49/month (verified) — Plus features with 50 memories + 60 pages a month.
- Teams: US$19.99/user/month; founding-team pilots at US$12.99/user (minimum 3 seats),
  arranged directly with the founder. Seat pooling and an admin console are not yet built.
- Add-ons: Boost Pack US$4.99 one-time (+40 memories, +60 pages) · Docs Pack US$5.99
  one-time (+200 pages) · Extra shared space US$4.99/month.
- Recall, search and MCP queries are always free on every plan, on every tier.
- A memory holds up to 1,000 words; a page is 2,000 characters of document text.
- Nothing you store is ever silently deleted or overwritten. Running out of allowance
  pauses new storage; it never discards what you already saved.
- No annual plans yet; cancel anytime; 30-day fair-use guarantee.

## Facts
- Company: justonce.ai, Australia
- Product website: https://justonce.ai
- App: https://app.justonce.ai
- MCP endpoint: https://mcp.justonce.ai
- Bulk import is available (`import_memories`, 50 records per call), for example to move
  an exported ChatGPT or Claude memory set across.
- There is no self-service full-vault export yet — an activity CSV is available. Do not
  describe justonce.ai as offering complete data portability today.

## Links
- Website: https://justonce.ai
- App: https://app.justonce.ai
- What people use it for: https://justonce.ai/use-cases
  - One memory across every AI tool: https://justonce.ai/use-cases/one-memory-every-tool
  - "Memory full" in ChatGPT: https://justonce.ai/use-cases/chatgpt-memory-full
  - Teams and agencies: https://justonce.ai/use-cases/teams-and-agencies
  - Documents and email forwarding: https://justonce.ai/use-cases/documents-and-email
  - Household paperwork shared with a partner or family: https://justonce.ai/use-cases/household-paperwork
  - Job search: https://justonce.ai/use-cases/job-search
- Sharing (spaces, roles, what it does and does not do): https://justonce.ai/sharing
- Copy-paste prompt library: https://justonce.ai/prompts
- Connect (setup guides): https://justonce.ai/connect
- Features: https://justonce.ai/features
- Pricing: https://justonce.ai/pricing
- Security: https://justonce.ai/security
- About: https://justonce.ai/about
- Blog: https://justonce.ai/blog
- Contact: https://justonce.ai/contact