# Geniuz: every page

The summary is at https://geniuz.life/llms.txt

---
title: "Geniuz | Your AI forgets everything. Fix that in a minute."
url: https://geniuz.life/
---

# Your AI forgets everything. Fix that in a minute.

Geniuz gives your AI a memory that lasts, so tomorrow it already knows what you told it today.

[Download for Mac](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz.dmg)

Free. No account. Stays on your computer.

Also for [Mac](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz.dmg), [Windows](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz-Setup.exe) and , or [try it in your browser](/try/)

`curl -fsSL https://raw.githubusercontent.com/jackccrawford/geniuz/main/install.sh | bash`

## Yesterday

Acme wants invoices rounded down, never up. They failed an audit over it in 2024. Dana is their contact.

Got it. I'll build the totals with rounding down.

Kept in Work

## Today, in a new chat

Dana just emailed about the Acme totals. Anything I should watch out for?

Check the rounding first. Acme wants amounts rounded down, because of their 2024 audit, so that's likely what Dana will look for.

## Three steps, and you're done.

1.  **Download and open**
    
    Drag it to Applications and open it. There's nothing to sign up for.
    
2.  **Restart Claude**
    
    Geniuz connects to Claude Desktop by itself. It also works with Claude Code, Cursor and anything else that speaks MCP.
    
3.  **Keep talking**
    
    Your AI saves what matters as you go. Tomorrow, ask it what you told it today.
    

## Your memory is yours.

**On your computer**

No cloud and no telemetry. Search runs on your machine too.

**Open source**

MIT licensed. [Read every line](https://github.com/jackccrawford/Geniuz).

**Not tied to one AI**

Change tools and your memory comes with you.

**Nothing overwritten**

A correction is added beside the original, so you can trust what you find.

## Tomorrow, it remembers.

Nothing walks out the door.

[Download for Mac](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz.dmg)


---
title: "AI Assistants and Developers · Geniuz"
url: https://geniuz.life/developers/
---

# AI Assistants and Developers

Geniuz is memory for AI agents. It runs on the user's own computer, and agents reach it over MCP or the command line. There is no account, API key or hosted service.

**Want your AI to set it up? Paste this to it:**

Install Geniuz so you can remember things across our conversations. Read https://geniuz.life/developers.md first, tell me what you'll run, and ask before you run it.

## How agents use it

Geniuz works best when an agent checks its memory at the start of a conversation, and saves what a future session would need and could not get from the files: decisions and why, people, preferences, constraints.

A memory can't be moved or removed afterwards, so a folder is chosen first, and its description may say what belongs there. Passwords and other secrets don't belong in memory.

Installing changes the user's computer, so it's the user's decision.

## Install

On Linux, or for the command line on a Mac:

```
curl -fsSL https://raw.githubusercontent.com/jackccrawford/geniuz/main/install.sh | bash
```

This installs to `~/.geniuz/bin/`. For the desktop app, use [Geniuz.dmg](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz.dmg) on a Mac or [Geniuz-Setup.exe](https://github.com/jackccrawford/Geniuz/releases/latest/download/Geniuz-Setup.exe) on Windows. The first memory downloads a small model, about 130 MB, that runs locally.

## Connect over MCP

For Claude Desktop, run `geniuz mcp install` and restart it. For any other MCP client, add this stdio server, using the full path to `geniuz` if it isn't on the client's PATH:

```
{
  "mcpServers": {
    "geniuz": {
      "command": "geniuz",
      "args": ["mcp", "serve"]
    }
  }
}
```

| Tool | What it does | Arguments |
| --- | --- | --- |
| `keep` | Saves a memory | `content` and `gist` required. `folder`, `thread` |
| `recall` | Finds memories. With no query, the newest. An address in `query` opens that memory | `query`, `folder`, `all`, `grep`, `thread`, `full`, `limit`, `since`, `until` |
| `folders` | Lists folders and their descriptions, and creates new ones | `name`, to read one in full |

The server also tells a connecting agent when to use these, so most clients need no further instructions.

## Or use the command line

Anything that can run a command can use Geniuz. Every command takes `--in <folder>`, and `--json` where it returns results.

```
geniuz keep -c "what happened and why" -g "category: short summary"
geniuz keep --in Work -c @notes.md -g "session: review"
geniuz recall                         # the newest memories
geniuz recall "topic"                 # by meaning
geniuz recall --grep Acme --since 7d  # exact words
geniuz recall --all "topic"           # every folder
geniuz recall 13625F6B:3487B9B0       # open an address
geniuz folder list
geniuz skill                          # the full guide for agents
```

## What there isn't

Geniuz has no HTTP API, hosted MCP server or remote access. Your memories stay on your computer, so there's nothing for a site to serve. The schema is [public](https://github.com/jackccrawford/Geniuz/blob/main/schema/schema.sql): read it and borrow it, and write through Geniuz, which keeps embeddings and identity right.

## Machine-readable versions

-   Every page has a Markdown version: add `.md` to its address, such as [/developers.md](/developers.md) or [/wiki/using-it.md](/wiki/using-it.md). A request with `Accept: text/markdown` gets it at the page's own address.
-   [/llms.txt](/llms.txt) is the summary and [/llms-full.txt](/llms-full.txt) is everything on one page. There's also a [sitemap](/sitemap.xml).
-   The source and issues are on [GitHub](https://github.com/jackccrawford/Geniuz). All the agent guidance is in the [skill guide](https://github.com/jackccrawford/Geniuz/blob/main/skills/SKILL.md).


---
title: "Why Geniuz | Nothing walks out the door"
url: https://geniuz.life/why/
---

The persistence problem

# Each evening, your best judgment walks out the door.

The call you made by feel. The standard you set. The reason behind a decision. Gone by morning, and rebuilt from scratch tomorrow. _It doesn't have to be._

The Memory Wall · every tile a decision, kept.

One problem, many faces

## The same problem shows up everywhere.

i.

### The chat that resets

You spend twenty minutes teaching an AI your context. You close the tab. It forgets all of it, and tomorrow you start over.

ii.

### The discovery you repay

A consultant learns your operation, writes it in a deck, and leaves. Six months later you pay again to reconstruct what was already known.

iii.

### The expert who retires

Thirty years of judgment built one decision at a time. On their last day, most of it walks out the door with them.

Different stories. Same problem: **what your people learn doesn't stick around.**

The reframe

## Judgment is not a ghost. It is _data._

Every call leaves a trail. A specific choice with a reason behind it. We talk about taste like it's mystical. In daily work it is concrete. And concrete things can be written down and kept.

onboarding

Cut the flow from 12 steps to 6 after completion dropped to 58%. It climbed to 71%, and time to first action fell from four minutes to under two.

a decision, with its reason

pricing

Shifted from per-seat to per-team after the call with David. It aligns with how memory actually compounds across a team.

a call, made by feel, now kept

the Wilson estimate

The context behind a number that would otherwise live only in one person's head, and leave when they do.

tacit knowledge, made durable

the vendor we left

Why we left them is more useful than which one we left. The next person who hears their pitch already knows the answer.

a correction, kept

So we built the thing that catches it.

## Geniuz is soil for everything your business knows.

It holds your standards, your tweaks, and your reasoning. It travels with you across every tool. It does not reset at the end of the session. Not facts a system extracts about you. The things actually worth keeping, written down as a side effect of doing the work.

And then it compounds

## Every AI starts at the same place. What you feed it is the difference.

The Floor

Cold start

a fresh chat, starting from zero

The Edge

With your memory

the same AI, fed a deep well

A fresh chat gives you generic answers. A chat that already knows what you know gives you yours. The AI is the same. The memory is what changed.

The proof

## We built it for ourselves first.

Geniuz comes from the memory our own team of AI agents runs on. They share it and pass work between them. When one learns something, the others know it too. Every morning, without rebuilding what we did yesterday.

One memory. Many agents. When one learns something, the others have it.

Which is why we say the same thing to everyone.

## Accelerate. Don't replace.

Your CRM stays. Your team stays. Your most experienced people don't get sidelined. Their judgment becomes the memory the whole team starts from. The new hire reads what the senior knows. The AI does too. What made your company hard to copy stops walking out the door.

### Nothing walks out the door.

## The best way to see it is to use it.

[Get Geniuz](/index.md#get)

Further reading

[Every Morning We Start From Zero](https://github.com/jackccrawford/methinks/blob/main/articles/2026-05-17-every-morning-we-start-from-zero.md)

Field notes from the persistence problem. Why memory is the missing layer, and what changes when it is in place.


---
title: "Map · Geniuz Wiki"
url: https://geniuz.life/wiki/
---

# Map

The parts of Geniuz and how they connect. There is no server: each part opens the same files, and everything stays on your computer.

## Surfaces

The ways in, for you and for your AI.

### Dashboard

The desktop app. Browse, keep and find across your folders, pin the ones you use most, and change your shortcuts.

#### Guardrail

A window stays with the folder it shows, so a draft can't land somewhere else.

#### Calls

-   [Folders](#folders) lists, switches and pins
-   [Library](#library) app commands

#### Source

[`desktop/dashboard`](https://github.com/jackccrawford/Geniuz/tree/main/desktop/dashboard)

### Menubar

The folder in use, a way to switch, and your recent memories, always one click away. A tray menu on Windows and Linux.

#### Guardrail

The Mac menubar only ever reads your memories.

#### Calls

-   [CLI](#cli) asks which folder is in use
-   [Store](#store) read-only SQL

#### Source

[`desktop/Geniuz`](https://github.com/jackccrawford/Geniuz/tree/main/desktop/Geniuz), [`src/tray.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/tray.rs)

### MCP

How your AI reaches Geniuz: `keep`, `recall` and `folders`, plus guidance on when to use them.

#### Guardrail

A wrong folder name is an error, never a different folder.

#### Calls

-   [Folders](#folders) finds the folder for each call
-   [Library](#library) tool calls

#### Source

[`src/mcp.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/mcp.rs)

### CLI

Every command, for people, scripts and agents.

#### Guardrail

`capture` refuses files that are not prose unless you pass `--force`.

#### Calls

-   [Folders](#folders) finds the folder for each command
-   [Library](#library) all commands

#### Called by

-   [Menubar](#menubar) asks which folder is in use

#### Source

[`src/cli.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/cli.rs), [`src/main.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/main.rs)

### Terminal UI

Browse and compose in a terminal.

#### Guardrail

Refuses to start without a real terminal.

#### Calls

-   [Library](#library) browse and compose

#### Source

[`src/tui.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/tui.rs)

## Core

Where memories are kept and found.

### Folders

Finds, moves, pins and archives folders, and decides which one a command uses.

#### Guardrail

A duplicate is refused, and nothing is ever deleted.

#### Calls

-   [Store](#store) reads identity without changing anything

#### Called by

-   [Dashboard](#dashboard) lists, switches and pins
-   [MCP](#mcp) finds the folder for each call
-   [CLI](#cli) finds the folder for each command

#### Source

[`src/folders.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/folders.rs)

### Library

Reads, writes and every kind of search.

#### Guardrail

An ambiguous ID prefix is an error, never a guess.

#### Calls

-   [Store](#store) transactional writes
-   [Embedding](#embedding) embeds text

#### Called by

-   [Dashboard](#dashboard) app commands
-   [MCP](#mcp) tool calls
-   [CLI](#cli) all commands
-   [Terminal UI](#terminal-ui) browse and compose

#### Source

[`src/db.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/db.rs), [`src/dig.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/dig.rs), [`src/window.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/window.rs)

### Store

One SQLite file per folder. Tables: `memories`, `memory_embeddings`, `embedding_meta`, `_meta`. View: `memory_chains`.

#### Guardrail

Triggers refuse update, delete and replace on memories.

#### Called by

-   [Menubar](#menubar) read-only SQL
-   [Folders](#folders) reads identity without changing anything
-   [Library](#library) transactional writes

#### Source

[`schema/schema.sql`](https://github.com/jackccrawford/Geniuz/blob/main/schema/schema.sql)

### Embedding

Turns text into numbers that capture its meaning, with ONNX or Ollama.

#### Guardrail

Rejects stored embeddings of the wrong size when reading them.

#### Calls

-   [Embed helper](#embed-helper) socket first
-   [Hugging Face](#hugging-face) model download
-   [Ollama](#ollama) as a fallback

#### Called by

-   [Library](#library) embeds text

#### Source

[`src/embedding.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/embedding.rs)

### Embed helper

Keeps the model ready between calls.

#### Guardrail

Local socket only. Exits after five idle minutes.

#### Called by

-   [Embedding](#embedding) socket first

#### Source

[`src/embed_server.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/embed_server.rs), [`src/embed_client.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/embed_client.rs)

## Outside

Reached only when needed, and never with your memories by default.

### Hugging Face

Where the model is downloaded from.

#### Guardrail

Once, then local.

#### Called by

-   [Embedding](#embedding) model download

#### Source

[`src/embedding.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/embedding.rs)

### Ollama

A second way to embed, by default on your own machine.

#### Guardrail

Used only if the built-in model fails to load.

#### Called by

-   [Embedding](#embedding) as a fallback

#### Source

[`src/embedding.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/embedding.rs)


---
title: "How it works · Geniuz Wiki"
url: https://geniuz.life/wiki/how-it-works/
---

# How it works

Your AI saves what matters as you work, and finds it again in the next conversation. Underneath, Geniuz is a Rust core and SQLite files, and everything else is a way of reaching them.

## How your AI knows to use it

When an AI tool connects, Geniuz tells it what to do: recall at the start of a conversation, and before finishing a task, keep what a future session would need and could not get from the files, such as decisions and why, people, preferences and constraints. This is part of the [MCP server](https://github.com/jackccrawford/Geniuz/blob/main/src/mcp.rs). Tool descriptions alone weren’t enough: in our tests, agents ignored them until they had this guidance.

## What a memory is

A memory has two parts: a **gist**, which is how you find it later, and **content**, which is the full detail. It can also have a **parent**, which links it to an earlier memory to form a thread.

Memories are stored in the `memories` table of [`schema/schema.sql`](https://github.com/jackccrawford/Geniuz/blob/main/schema/schema.sql). Database triggers refuse any update, delete or replace, including from other tools that open the file. Changing the past takes a deliberate step: dropping the trigger.

## What a folder is

A folder is a directory holding one `memory.db`. Its identity is inside that file: a UUID, a name, a description and when it was made, in the `_meta` table of [`schema/schema.sql`](https://github.com/jackccrawford/Geniuz/blob/main/schema/schema.sql). So a folder can be renamed, or moved anywhere, and is still the same folder. The first one is `~/.geniuz/memory.db`, called “My memory”, and it stays where it is. Pinned folders come first in every list.

The same file serves many uses: a project, a standard, a knowledge base, personal notes, what an agent keeps between sessions, messages between agents. There are no folder types. The description says what a folder is for, and the prompt for writing one is “What should whoever comes here next know?”

Geniuz looks in two places: its data directory, and directories you added on purpose. It reads each one level down and never searches your disk. That decides what Geniuz shows. Your file permissions decide who can read, so a file it can’t read is simply left out. The rules are in [`src/folders.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/folders.rs).

A command uses the first of these that applies: `--in <name>`, the `GENIUZ_DB` file path, a `.geniuz-folder` file in this directory or a parent, the folder chosen with `geniuz folder use`, then “My memory”. A name that matches nothing is an error, so a typo can’t send a memory somewhere else. In the dashboard, Keep has a pulldown for the folder, and an open window stays with the folder it shows.

### One of each

A folder’s UUID is permanent, and so is the UUID of every memory in it, and addresses like `13625F6B:3487B9B0` rely on both. So a folder can be moved but not copied. `folder add` refuses a directory holding a folder already here. If a copy turns up later, every copy is blocked until one is moved, because nothing can tell which is the original, and using the wrong one would split the history in two. Names are unique too, ignoring case.

`folder move` is the safe way to relocate one. SQLite keeps recent writes in a `-wal` file beside the database, so copying a live `memory.db` by hand can lose them. Moving flushes that file and holds off writers first. Across drives it also checks the new copy’s integrity, identity and memory count, closes the original to further writes, then moves it to `archive/` for you to delete when you’re satisfied. If a move across drives is interrupted, Geniuz finishes or undoes it the next time it runs, and waits if the original is out of reach and the copy can’t be shown to be final. Links to folders aren’t moved: move the folder itself.

`folder archive` moves a folder into `archive/` beside itself, one level below where Geniuz reads. Nothing is deleted, and `folder restore` puts it back.

## When you keep

1.  The command reads your text, which can be inline, from a file (`-c @notes.md`) or piped in (`-c -`).
2.  [`signal_with_backend`](https://github.com/jackccrawford/Geniuz/blob/main/src/db.rs) refuses empty content and creates an ID. If you named a parent, it looks it up. An unknown parent does not stop the write: the memory is saved as the start of a new thread.
3.  The text is turned into an embedding, a list of numbers that represents its meaning. Geniuz asks the small background helper first, then falls back to loading the model itself.
4.  If embedding fails, the memory is still saved and can be found by keyword until it is embedded later.
5.  The memory and its embedding are written in one transaction.

## When you recall

`geniuz recall "topic"` searches by meaning: it compares your query with stored embeddings and ranks the closest. A few details make that work better:

-   **Names come first.** Capitalized names in a query are matched exactly and put at the top, because searching by meaning alone tends to miss them.
-   **Memories not yet embedded still count.** They are found by keyword and given a share of the results.
-   **Time windows.** `--since 7d` limits results to a period.

Other kinds of recall skip meaning entirely:

| Flag | What it does |
| --- | --- |
| `--grep Cubic --grep PR` | Memories holding every term, showing each line with any of them |
| `--thread 98672A90` | A whole thread, starting at its root |
| `--keyword "exact words"` | Keyword search |
| `--random` | Something you may have forgotten |

Two more forms reach across folders. `recall --all "topic"` searches every folder and shows each result with its address. `recall 13625F6B:3487B9B0` opens that memory in full, whichever folder it is in. In the dashboard, Find can search any selection of folders, and an address in a memory’s text can be clicked.

The reason is in [`src/dig.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/dig.rs): “Semantic search is for discovery; exact search is for recall”.

## The model

Search by meaning runs locally through ONNX Runtime, using a BERT sentence model that covers more than 50 languages. It downloads once from Hugging Face, about 130 MB, into `~/.geniuz/models/`, the first time anything is embedded. That includes your first `keep`. Loading a model is slow, so a helper called `geniuz-embed` keeps it ready over a local socket and exits after five idle minutes.

If the built-in model fails to load, Geniuz tries an embedding service instead: Ollama on your own machine by default. See [Using it](/wiki/using-it.md#settings).

## Your data stays on your machine

When Geniuz runs, it stores all your data locally, in a file on your computer. There is no account, no cloud and no telemetry.

For completeness, Geniuz reaches the network in a few small ways, and none of them sends your memories:

-   **Hugging Face:** to download the model, once.
-   **GitHub:** when you run the install script or download a release.

Geniuz itself sends memory text to another address in only one case: if the built-in model fails to load and `GENIUZ_EMBED_URL` points at another machine, text goes there to be embedded. By default that address is your own machine. What you recall through an AI tool goes wherever that tool sends it.


---
title: "Using it · Geniuz Wiki"
url: https://geniuz.life/wiki/using-it/
---

# Using it

## Install

| You have | Do this |
| --- | --- |
| A Mac | Download [Geniuz.dmg](https://github.com/jackccrawford/geniuz/releases/latest/download/Geniuz.dmg) and drag it to Applications. To use `geniuz` in a terminal, use **Settings → Copy Install Command** in the menubar. |
| Windows 11 | Download [Geniuz-Setup.exe](https://github.com/jackccrawford/geniuz/releases/latest/download/Geniuz-Setup.exe). It installs per user, with no admin prompt. |
| Linux | Run the command below, or see the [releases](https://github.com/jackccrawford/geniuz/releases/latest) for `.deb`, AppImage and tarballs (x86\_64 and arm64). |

```
curl -fsSL https://raw.githubusercontent.com/jackccrawford/geniuz/main/install.sh | bash
```

The script installs to `~/.geniuz/bin/`. To build from source, see [below](/wiki/.md#from-source).

### From source

```
git clone https://github.com/jackccrawford/geniuz && cd geniuz
cargo build --release --bin geniuz
cp target/release/geniuz ~/.local/bin/
```

To build the dashboard as well: `cd desktop/dashboard && cargo tauri build`.

## Connect your AI

| You use | Next step |
| --- | --- |
| Claude Desktop | Connects by itself when Geniuz opens. Restart Claude Desktop once. To connect by hand: `geniuz mcp install` |
| Claude Code, Cursor, Windsurf | `geniuz skill` prints instructions to give your agent |
| Your own agents | Call `geniuz keep` and `geniuz recall` from a shell, or run `geniuz mcp serve` |

Then keep talking. Your AI saves what matters as you go. Tomorrow, in a new chat, ask it what you told it today.

## Commands

```
geniuz keep -c "what happened" -g "category: short summary"
geniuz keep -c @notes.md -g "session: review"
echo "content" | geniuz keep -c - -g "piped: from a process"
geniuz keep -c "follow-up" -g "update" -p 98672A90

geniuz recall "topic"
geniuz recall "topic" --since 7d
geniuz recall --grep Cubic --grep PR
geniuz recall --thread 98672A90
geniuz recall --keyword "exact words"
geniuz recall --random
geniuz recall --full "topic"
geniuz recall --json "topic"

geniuz recall
geniuz recall -l 5
geniuz recall --all "topic"
geniuz recall 13625F6B:3487B9B0
geniuz tui
geniuz dashboard
geniuz capture ./docs/
geniuz backfill
geniuz status
geniuz watch
geniuz mcp install
geniuz mcp status
geniuz mcp serve
geniuz settings list
```

`geniuz remember` still works as another name for `keep`, and `geniuz recent` for `recall` with no search. `keep` and `recall` take `--in <folder>`, as does every other command that reads or writes memories.

## Folders

```
geniuz folder list
geniuz folder list --archived
geniuz folder show Work
geniuz folder create Work -d "Client projects. No passwords here."
geniuz folder create Notes --at ~/notes
geniuz folder use Work
geniuz folder rename Work Clients
geniuz folder describe Clients "Client projects, and who owns them."
geniuz folder add /some/directory
geniuz folder remove /some/directory
geniuz folder move Clients --to /some/directory
geniuz folder archive Clients
geniuz folder restore Clients
geniuz folder pin Clients
geniuz folder unpin Clients
```

In the dashboard, folders are in the sidebar and in the Folders menu. Click the pin beside a name to keep it at the top of every list. Keep has a pulldown for choosing a folder, and Find can search any selection of them. To give a project its own folder, put the folder’s name in a `.geniuz-folder` file in the project.

Editing a description keeps the old wording. Your first folder, “My memory”, can be renamed, but it can’t be moved or archived, because other files live beside it.

## Keyboard shortcuts

In the dashboard. Change any of these under Settings, and the menu follows at once.

| Keys, on a Mac | What they do |
| --- | --- |
| ⌘N | Keep |
| ⌘K | Find |
| ⌘0 | Memories in this folder |
| ⌘1 to ⌘9 | Your first nine folders, in sidebar order (not changeable) |
| ⇧⌘N | New folder |
| ⌘B | Show or hide the sidebar |
| ⇧⌘S | Status |
| ⌘, | Settings |
| ⇧⌘E | Export this folder |
| ⌘R | Refresh |

On Windows and Linux, use Ctrl in place of ⌘.

## Good to know

**Note on `geniuz watch --exec`.** Your command runs through the shell with your own rights. `{gist}`, `{content}` and `{json}` reach it as shell variables, so put them in double quotes, not single. Shell syntax in a memory does not run.

**Do not store secrets.** A memory cannot be removed through Geniuz.

## Where your data lives

Everything is under `~/.geniuz/` unless you moved it: `memory.db`, one directory per folder you made, `archive/`, `models/`, `settings.json` and `bin/`. A few small files hold your choices: `current`, `added-folders`, `pinned-folders` and `shortcuts.json`.

**To back up**, use Export under Data & Export in the dashboard, which saves the folder in use as one complete file. Time Machine and similar tools are fine too. A backup is a file to keep, not a folder to use: it holds the same permanent IDs, so Geniuz refuses it while the original is present.

**Do not copy a folder by hand to use it elsewhere.** A copy of a live database can lose recent memories, and copies aren’t supported. Use `geniuz folder move`.

Read the schema freely, and write through Geniuz, which keeps embeddings and identity right.

## Settings

| Variable | What it does |
| --- | --- |
| `GENIUZ_HOME` | Where Geniuz keeps its files |
| `GENIUZ_DB` | Use one specific memory file, for the CLI and MCP |
| `GENIUZ_MODELS_PATH` | Where the model is stored |
| `GENIUZ_EMBED_URL`, `GENIUZ_EMBED_MODEL` | The embedding service to try if the built-in model fails to load |
| `GENIUZ_EMBED_SOCKET`, `GENIUZ_EMBED_SPAWN`, `GENIUZ_EMBED_IDLE` | Control the embed helper |


---
title: "Why it is built this way · Geniuz Wiki"
url: https://geniuz.life/wiki/why/
---

# Why it is built this way

## Memories are never edited

“Memories are immutable”, says [`schema/schema.sql`](https://github.com/jackccrawford/Geniuz/blob/main/schema/schema.sql), “the log is the truth”. Triggers enforce it in the file itself, so changing the past takes a deliberate step: dropping the trigger. To correct something, you add a memory that replies to it, and both remain.

The cost is that a mistake stays on the record. In return, the history is hard to rewrite by accident.

## No server

Geniuz has no HTTP server. There is nothing to host, keep running or secure, and tools reach Geniuz by running it or through MCP.

## One table

A UUID, a JSON payload, a parent, a time. Rows are added and never changed. That shape holds a surprising range of work, and it spares you most of the design a normalized schema would demand up front. It is a way of working as much as a file format, so tailor it: the name of the UUID column, the shape of the payload, the promises a given store makes. Make something updatable only where a concrete need says so, and write that need down beside the schema.

## Folders without types

A project, a knowledge base and a conversation between agents are the same file with a different description. Adding types would mean deciding the categories for everyone, and the people who used stores like these wrote what they needed in free text anyway.

## UUIDs are forever

Memories point at each other by address, so an ID that changes breaks every memory that mentions it. That is why a folder can be moved but not copied, and why Geniuz would rather refuse than guess.

If a copy turns up anyway, every copy stops working until one is moved. Nothing can tell which is the original, and carrying on with the wrong one would split the history in two. That’s disruptive when it happens, and we chose it knowingly: an error you can fix beats a loss you can’t see.

## The AI has to be told

A memory nobody uses is worth nothing. In our tests, agents with good tools and no other guidance used Geniuz in 0 of 8 sessions. With a few sentences on when to recall and keep, all of them did, in the right folders. So the server says so when an AI connects. It is a small sample on one model, and the point stands: being available isn’t the same as being used.

## Local by default

Your memory is files on your computer. You can move them, back them up or read the code that touches them, and no account or API key stands between you and them.

## Meaning and exact search, together

Search by meaning finds things you cannot quite name, and misses things you can: a person, a date, an exact phrase. [`src/dig.rs`](https://github.com/jackccrawford/Geniuz/blob/main/src/dig.rs) says it this way: “Semantic search is for discovery; exact search is for recall”. So Geniuz has both, and puts names first when a query contains them.

## Independent of any AI tool

A memory that belongs to one AI product is lost when you leave it. Geniuz works with anything that can run a command or speak MCP, so your memory comes with you.

## Small on purpose

“Geniuz is a small substrate by design”, says [`CONTRIBUTING.md`](https://github.com/jackccrawford/Geniuz/blob/main/CONTRIBUTING.md). New features have to justify themselves against that.


---
title: "Glossary · Geniuz Wiki"
url: https://geniuz.life/wiki/glossary/
---

# Glossary

| Term | Meaning |
| --- | --- |
| Memory | One entry that Geniuz will not change: a gist, content, and optionally a parent. |
| Gist | The short line you find a memory by. |
| Content | The full detail of a memory. |
| Thread | Memories linked by parent, such as a problem and its solution. |
| Parent | The earlier memory that a memory replies to. |
| Folder | A directory holding one `memory.db`, with its own permanent UUID, name and description. |
| Address | Two short IDs that open one memory from anywhere: `13625F6B:3487B9B0`, folder then memory. |
| Allow list | The directories you added, where Geniuz looks for folders besides its own data directory. |
| Pin | Keeping a folder at the top of every list. |
| Archive | Hiding a folder by moving it into `archive/`. Nothing is deleted, and it can be restored. |
| Station | The older name for a folder. It survives in `station.db`, which Geniuz still reads. |
| Embedding | Numbers representing a memory’s meaning, used to search by meaning. |
| Backfill | Embedding memories that do not have one yet. |
| Capture | Loading existing files into memory in bulk. |
| Keep | Saving a memory. `remember` still works as another name for it. |
| Recall | Searching your memories, by meaning or exactly. With nothing to search for, it shows the newest. |
| Harvest | What a recall’s results point onward to, read from those memories. |
| MCP | Model Context Protocol, a standard way for AI tools to call other programs. |
| Embed helper | `geniuz-embed`, which keeps the model loaded between calls. |


---
title: "Privacy Policy · Geniuz"
url: https://geniuz.life/privacy/
---

# Privacy Policy

Effective: April 13, 2026

Geniuz is a product of **Managed Ventures LLC**, doing business as mVara.

## What we collect

Nothing. This site does not use cookies, tracking pixels, analytics services, or contact forms. We do not create user accounts. We do not collect personal information when you browse this site.

## What we don't do

-   We do not collect personal data.
-   We do not track you.
-   We do not use cookies.
-   We do not sell data.
-   We do not use data to train AI models.

## Geniuz software

Geniuz Free is open source under the MIT License. Downloading and using the software does not require providing personal information. Geniuz stores all memories locally on your machine. We do not collect telemetry or usage data from installed software.

Geniuz Team and Geniuz Enterprise involve hosted or managed deployments. Data handling for those tiers is governed by a separate data processing agreement between mVara and the customer.

## Your rights

You may request access to, correction of, or deletion of any personal information we hold about you by emailing [legal@managedv.com](mailto:legal@managedv.com). California residents have additional rights under the CCPA, including the right to know what information we have collected and the right to request deletion. We do not sell personal information.

## Security

We use standard security practices to protect any information you provide. However, no method of transmission over the internet is completely secure.

## Changes

We may update this policy from time to time. Changes will be reflected in the effective date above.

## Contact

Managed Ventures LLC  
Email: [legal@managedv.com](mailto:legal@managedv.com)


---
title: "Terms of Service · Geniuz"
url: https://geniuz.life/terms/
---

# Terms of Service

Effective: April 13, 2026

Geniuz is a product of **Managed Ventures LLC**, doing business as mVara. By using this website or software, you agree to these terms.

## Open source software

**Geniuz Free** is available under the **MIT License** and hosted at [github.com/jackccrawford/geniuz](https://github.com/jackccrawford/geniuz). Use, modification, and distribution are governed by the MIT License. The software is provided "as-is" under that license.

## Commercial products

**Geniuz Team** and **Geniuz Enterprise** are commercial products. Use requires a separate agreement with Managed Ventures LLC. For licensing inquiries, contact [legal@managedv.com](mailto:legal@managedv.com).

## Website content

The website design, text, graphics, and logos are owned by Managed Ventures LLC and may not be reproduced without permission. This does not apply to open source software, which is governed by the MIT License.

## AI-generated content

Geniuz facilitates the use of artificial intelligence. AI-generated content may be inaccurate or incomplete. You are responsible for reviewing and validating any AI-generated output before relying on it.

## Disclaimer of warranties

All software and content are provided "as-is" without warranties of any kind, express or implied, including warranties of merchantability, fitness for a particular purpose, or non-infringement.

## Limitation of liability

To the maximum extent permitted by law, Managed Ventures LLC shall not be liable for any indirect, incidental, special, or consequential damages arising from your use of this website or any software downloaded from it.

## Governing law

These terms are governed by the laws of the State of California. Any disputes shall be resolved through mediation, and if unresolved, by binding arbitration administered by JAMS in Scottsdale, Arizona.

## Changes

We may update these terms from time to time. Changes will be reflected in the effective date above.

## Contact

Managed Ventures LLC  
Email: [legal@managedv.com](mailto:legal@managedv.com)