Getting started

LatticeSearch Help

Task-by-task guides for finding anything on your PC — instantly and privately.

LatticeSearch searches your files by meaning, not just by filename. Ask for "the invoice from March" or "photos of the beach" and it finds them, even when those words appear nowhere in the file name. Everything runs on your own machine — nothing is uploaded.

---

Table of contents

---

First run: what happens when you start

The first time you open LatticeSearch, it builds an index of your files. This is tiered and progressive — you can start searching almost immediately, and the deeper "senses" fill in behind the scenes.

1. Names come first. LatticeSearch scans your drive and builds an instant name index. This takes minutes (roughly 5 minutes for a large drive; under a minute on a machine with the fast-path name indexer). As soon as this finishes, name search and the file explorer are fully live.

2. Meaning fills in behind it. In the background, per file type, LatticeSearch adds:

  • Images — understood by content (the lattice), so you can search photos by describing them.
  • Documents — text extracted and chunked so you can search by what they say.
  • Videos — sampled frame by frame, with jump-to-timestamp results.
  • Audio — indexed by sound and by speech transcript.
  • Heavy senses last — text inside screenshots (OCR), spoken words (speech-to-text), scene captions, and face grouping. On a big library these run for hours, often overnight. This is a one-time cost.

3. A banner shows progress. While the deeper tiers build, a status banner reads "Search is live — AI layers filling in" with a checklist of tiers. You never have to wait for it — search stays instant throughout.

While indexing is still catching up, a file may be findable by name before it's findable by meaning. If you just added something and it hasn't appeared yet, its content sense may still be filling in.

> Tip: After the first build, LatticeSearch keeps itself fresh automatically. It watches your active folders for changes, and it runs a quiet maintenance pass in the small hours (roughly 3–5 a.m.) when your machine is idle to backfill anything new.

---

Searching

The search bar sits at the top of every screen. Type a query and results stream in: instant name matches first, then images, videos, audio, and documents ranked by meaning below.

Search by meaning

Just describe what you want in plain words.

  • a kitchen interior
  • the invoice from March
  • red things
  • cartoon flame mascot

LatticeSearch matches the *idea*, so a photo named IMG_4821.jpg still turns up under "beach sunset."

Search by name

Type part of a filename or path. Name results are exact and instant, ranked so that exact stem matches beat basename matches beat path matches (searching apple surfaces apple.py, not WinSxS applet junk). Pure extension queries switch into filter mode:

  • .png — every PNG on the drive, newest first
  • report.pdf

Search by dropping a file or a crop

You can search with a file instead of words — useful to find where something lives, or to find things that look or sound like it.

1. Drag an image, video, or audio file straight onto the search bar (it glows and shows "drop to search by content"), or onto the drop zone on the Home page.

2. LatticeSearch reports where that exact file lives, plus a pixel-identical-copy check and a list of similar files by content.

This works with crops, too. Drop a cropped piece of an image and LatticeSearch still finds the full original, because images are indexed as overlapping tiles as well as whole. You can also paste an image from your clipboard (Ctrl+V) anywhere in the app to search for it.

Query operators

Mix these filters into any search to narrow it on the instant name path:

| Operator | Example | Meaning |

|---|---|---|

| ext: | ext:png | only files of this extension |

| in: | in:downloads | only inside a folder whose name matches |

| size:> / size:< | size:>10mb, size:<2gb | larger / smaller than |

| before: | before:2025 | modified before a date |

| after: | after:2024-06 | modified after a date |

They combine freely, e.g. screenshot ext:png in:downloads size:>1mb.

Ask Lumen

Lumen is the crystalline assistant in the bottom-right corner. Click it to open a chat and ask in full sentences:

  • "photos of the beach"
  • "the recording where we discussed pricing"
  • "my biggest videos"

Lumen interprets your request (pulling out time, size, and type filters automatically), searches every sense, and answers with the best hits — thumbnails included. Click any hit to preview it, or "Open all results" to see the full search. Lumen can also carry out actions like opening Backup, toggling Incognito, or walking you through connecting an AI. Longer, plain-language questions typed into the main search bar (four or more words) also trigger the assistant automatically.

"Did you mean…" suggestions

If you mistype, LatticeSearch corrects toward the vocabulary of your own machine — the actual words in your filenames and documents. Search fire safty poster and a 💡 banner offers fire safety poster; click it to run the corrected search. Correct queries get no suggestion. This is *Lattice Suggest*, and it never slows the instant search path.

Expand and Focus

On any search results screen:

  • ⊕ Expand broadens the search — it lowers the threshold and pulls in related items nearby.
  • ⊙ Focus narrows it — only the strongest, most on-target hits remain.

From a file preview you can also click ⊕ Expand from here to pivot the whole search onto that file's meaning and explore its neighbourhood.

---

The quick-search palette (Ctrl+Alt+Space)

The palette is a small always-on-top search bar you can summon anywhere in Windows, without switching to the app.

1. Press Ctrl+Alt+Space. A compact "Lattice Search Bar" appears on top of whatever you're doing.

2. Type your query. Results — image thumbnails, files, documents by meaning, and audio cued to the matched moment — appear as you type, with a Lattice Suggest row for typos.

3. Navigate with ↑ / ↓, press Enter to open the top result (or ➜), and Esc or ✕ to close.

Drop a file onto the palette. The palette stays pinned (it doesn't vanish when you click elsewhere), so you can drag a file from Explorer directly onto it to search by content — find where it lives, its pixel-identical copies, and similar files.

Clipboard history from the palette. Type clip followed by words to search your Lattice Clipboard history by meaning — for example clip that address I copied. Click a match to paste it back to your clipboard.

---

Browsing files instantly

Open All files (or the 🗂 rail icon) for a file explorer that never waits — folder listings are served from the in-memory index with zero disk I/O, so most folders open in a few milliseconds.

  • Breadcrumbs across the top let you jump to any parent; ↑ Up goes up one level; the timing readout ("listed in N ms") shows how instant it is.
  • Folders appear as cards with live item counts; files honour your chosen layout.
  • Layout menu (top-right) switches between Grid, Large grid, List, and Details (a list with a sticky preview pane). In List and Details you can click column headers to sort by name, modified, size, or type.
  • Back / Forward work everywhere: the ‹ › buttons in the top bar, your mouse's back/forward buttons, and Alt+← / Alt+→.
  • Recents and Starred live in the left nav. Star any file with the ☆ on its row or in its preview; starred files also appear in the nav for quick access.

> Listings come from the index snapshot. Brand-new files show up once the live watcher picks them up (seconds) or after a re-scan; very large folders are display-capped for speed.

---

Photos and People

Open Photos for a timeline of all your images and videos (system folders and app internals are excluded).

  • Filter the strip with All Items · Photos · Videos · Starred.
  • Group by Years · Months · Days using the segmented control.
  • Click any thumbnail to open it in the lightbox; video tiles carry a ▶ badge and preview on hover.

People (faces). When face grouping has run, a circular People strip appears at the top of Photos. Each circle is one person LatticeSearch clustered from your photos. Click a person to see every photo they appear in, then click any photo to view it. Face detection and clustering run entirely on your machine.

---

The Knowledge Graph

Open Knowledge graph to see how your files relate, as an interactive force-directed map.

  • Pick a lens to colour and connect the graph: Related images, Related text, Largest, Smallest, By colour, By type, or By folder.
  • The node is the thing. Image nodes render as live thumbnails, audio nodes as little waveform tiles you can play, document nodes as cards showing their actual text snippet. Only hubs are plain circles.
  • Interact: drag nodes around, scroll to zoom, drag the background to pan. Click a node for a detail card (with the real image, playable audio at the matched moment, or readable text); double-click to open the file.

Two more ways to reach the graph:

  • On any search, click 🕸 Graph to see the query as a hub with its multi-modal hits and a ring of second-order related files the flat list can't show.
  • In the file explorer, click 🕸 Graph to see how the files in the current folder cluster by meaning.

---

Previewing media

You can inspect almost anything inside the app before deciding to open it.

  • Preview drawer. Click any file to slide out a preview with a hero image (or video thumbnail / audio player), the filename, and a metadata table — type, size, dimensions, dates, clickable location, and which "lattice senses" know the file. Buttons: Open, Open folder, Star, 🎯 Similar, ⊕ Expand from here.
  • Lightbox. Click a hero image, a photo, or a video to open the full-screen lightbox. Images zoom; videos and audio stream and are seekable (audio jumps to the matched moment when you arrived from a sound search). Close with Esc or by clicking the backdrop; buttons let you Open file, Show in folder, or see Details.
  • Hover-scrub video. Hover a video thumbnail anywhere (results, Files grid, previews) and it plays silently; move your mouse left-to-right across it to scrub through the clip, YouTube-style.

---

File operations (move, rename, copy, delete)

Right-click any file (in results, the explorer, or the graph) for a context menu:

  • Open · Find similar · Open in → File Explorer or Quick view
  • Copy path
  • Rename · Move · Copy · Delete
  • File / Folder info · More → Folder activity, Star

These are safe and fast:

  • Move on the same drive is instant. A same-volume move is an O(1) rename — it completes in about a millisecond regardless of file size, and the toast says so.
  • Delete is recoverable. Deleted files go to the Recycle Bin *and* are archived to LatticeSearch's recovery store, so you can restore them later (see Recovery). Nothing is hard-deleted out from under you.
  • Every operation is recorded in Folder activity, viewable per folder from the context menu's More submenu.

From Windows itself (right-click and Send-To)

LatticeSearch can add entries to Windows Explorer's own right-click menu (installed per-user, no admin needed): ⚡ Instant Move to…, ⚡ Fast Copy to…, ♻ Delete (recoverable), and 🔎 Find similar (which opens the app focused on that file). Matching Send-To entries — Find similar, Safe delete, and copy into your Lattice Drive — are installed too.

---

Import to Drive vs. drop-to-search

These two look similar but do opposite things — the distinction matters:

  • Drop-to-search (the Home drop zone and the search bar): you drop a file to find it — where it lives on your machine, its copies, and things like it. It does not move or copy anything.
  • Import to Drive (the ⬆ Import page): you bring files into the lattice. They are copied into your Lattice Drive (at L:\Imports), which is always watched and indexed the moment files arrive. Use this to pull things off a USB stick, a camera, or your Downloads into an always-searchable home.

To import: open Import, then either Choose files / Choose folder, or drag files or a whole folder onto the drop area. They're searchable within seconds — by name first, by meaning shortly after.

Lattice Drive is a real drive letter (L:) that LatticeSearch live-watches, so anything you keep there is pre-indexed by construction.

---

Reclaim space (duplicates)

Two tools find redundant files; both remove copies reversibly (originals are archived to Recovery and sent to the Recycle Bin, never hard-deleted).

Reclaim Space — byte-identical duplicates

1. More → Reclaim Space.

2. Enter a folder to scan and click Scan. LatticeSearch buckets files by size, then hashes to find exact duplicates. It reports how many duplicate sets and how many MB are reclaimable.

3. Click Remove … of duplicates to clear them (keeping one of each set). You'll be asked to confirm; removed copies stay recoverable.

Visual Duplicates — the same picture, different files

1. More → Visual Duplicates.

2. LatticeSearch groups images that are the *same picture* even when saved under different names, sizes, or formats — matched by pixel fingerprint, not just bytes.

3. Review each group and reclaim space, keeping the largest of each.

---

Backup and restore

More → Backup makes deduplicated, compressed, integrity-verified snapshots of a folder.

Create a snapshot

1. Enter a folder to back up and, optionally, a store location (blank uses the app's backup store).

2. Click Create snapshot. Files are written to a content-addressed store: unchanged files cost almost nothing on the next snapshot, so backups are incremental forever.

Verify — click Verify store integrity to hash-check every stored blob; a flipped byte is pinpointed to the exact blob.

Restore — in the Snapshots list, type a target folder next to a snapshot and click Restore. Restores are byte-perfect.

---

Recovery: find deleted files

Deleted files in the left nav (or More → Recovery) restores things you deleted through LatticeSearch — by *describing* them.

1. Open Deleted files.

2. Type what you remember, e.g. the fire safety document I deleted last month. Recovery searches the archived trash by meaning as well as by name.

3. Click Restore on a match. Files come back byte-identical (to a *LatticeSearch Recovered* folder).

Recoverable files are retained for 90 days. Recovery covers files deleted via the app (and archived protected files); it can't resurrect files deleted by other tools that never touched LatticeSearch.

---

Vault

The Vault (More → Vault) is a searchable encrypted archive. Files and their search index are sealed with AES-256 using a key derived from your passphrase, so you can search inside the vault without exposing its contents — even across languages. Without the passphrase, the stranger sees only opaque data.

Vault USB packages a vault plus a portable app onto a USB stick, so you can carry an encrypted, searchable archive that unlocks only with your passphrase.

> In this build the Vault is driven by its command-line tools; a guided in-app wizard is on the way. The encryption, sealing, and cross-language search inside the vault all work today.

---

Lattice Sync

More → Lattice Sync keeps any two folders in step — Desktop ↔ Documents, a project ↔ a backup drive, or a USB ↔ this PC. Each side keeps its own manifest, so changes are detected in milliseconds and only real differences move.

Pair two folders

1. Enter Location A and Location B.

2. Choose a mode:

  • ⇄ Two-way — changes flow both directions.
  • → A updates B / ← B updates A — one-way.
  • ⇉ Mirror A→B / ⇇ Mirror B→A — the target becomes an exact copy of the source. Files that exist only on the target are removed to recoverable trash, never hard-deleted.

3. Optionally add ignore patterns (comma-separated), e.g. node_modules, *.tmp, .git.

4. Click Preview changes to see exactly what would move, then Sync now.

Conflicts are preserved, never silently overwritten. Tick Auto-sync to register the pair for a background sync roughly every 90 seconds; an unplugged drive is skipped and resumes the next pass when you plug it back in. Registered pairs are listed below, where you can change mode, toggle auto, edit ignore patterns, or remove a pair in place.

---

Lattice Clipboard

More → Lattice Clipboard is a clipboard history you can search by meaning.

1. Click ▶ Enable watching to start capturing what you copy (text and copied files).

2. Copied items appear under Recent with timestamps. Secrets are filtered out before anything is stored — things that look like API keys, passwords, PEM blocks, or long base64 are never saved.

3. Search the history from the box at the top (by meaning), or from the palette with clip <words>.

4. Click 📋 Copy on any item (or a palette match) to paste it back to your clipboard.

History retention defaults to 30 days and is pruned automatically (adjust it in Settings). Capture pauses while Incognito is on.

---

Lattice Memory

Lattice Memory lets an AI agent connected to LatticeSearch remember facts and recall them by meaning across sessions — a durable memory that survives conversation resets. It's used through the AI connection (MCP tools memory_store / recall, or the CLI remember / recall), not a screen you open yourself. Stored memories are searchable alongside your clipboard captures. Memory writes are refused while Incognito is on. See Connecting an AI.

---

Lattice Report

More → Lattice Report generates a self-contained digest of what the lattice has been doing: coverage per sense (and how it changed), recent file activity, how much space is reclaimable, index freshness, and memory sessions. Click Generate report to build and open it.

---

Privacy: Incognito, forgetting searches, Settings

Incognito mode

Click the 🕶 button in the top bar to toggle Incognito. While it's on:

  • Recent searches are not recorded (on the server or locally).
  • The activity log stays silent.
  • Lattice Memory writes are refused.
  • Clipboard capture is paused.
  • The search cache is skipped and preview history isn't kept.

The connection label changes to "incognito" so you always know it's active. Turn it off to resume normal recording.

Honest scope: Incognito leaves no trace in the lattice, but it is not an anti-forensics tool — Windows itself still journals activity (USN/MFT, event logs, jump lists), and that's outside LatticeSearch's control. Also by design, deletes are still archived to Recovery even in Incognito — safety is chosen over tracelessness there.

Forgetting recent searches

  • Open the Recents page (or the recent-searches dropdown in the search bar) and click the ✕ next to any search, or Clear all.
  • A removed search enters a grace period: if you search it again within 7 days it's un-forgotten; after 7 days it's purged for good. (You can change this "forget window" in Settings.)

Settings

Open ⚙ Settings (top bar or More → Settings) to adjust:

  • Privacy — Incognito by default, the forget window (days), and clipboard retention (days).
  • Indexing — extra watched folders (live-indexed on change) and per-folder chunk granularity (fine binds small facts, coarse suits archives).
  • System — your quick-search hotkey, and whether the fast native name accelerator is active.

Click Save settings to apply.

---

Connecting an AI (MCP + CLI)

LatticeSearch can act as an AI assistant's eyes and hands into your files — meaning-search over your whole machine in milliseconds instead of blind file walks. Measured against naive grep-and-read loops, this is about 44× fewer tokens and 12× faster per task, and everything stays local.

Open AI Access (left nav, or More → AI Access — MCP + CLI). The page computes copy-paste-correct setup for your machine, each with a Copy button:

1. Claude Desktop (MCP) — paste the generated JSON into your Claude Desktop config file (the exact path is shown), then restart Claude Desktop.

2. Claude Code (one command) — run the generated claude mcp add … command in a terminal.

3. Any MCP client (Cursor, VS Code, …) — a generic MCP server entry (command + args + env).

4. CLI — works with any agent, no MCP needed — example lattice commands. Notably lattice grep narrows to the files that *mean* your query, then runs an exact grep only within them.

5. Setup prompt — a ready-made prompt you can hand your agent so it knows how to use the lattice on its own.

Through MCP or the CLI, an agent gets tools to search / ask / find files / list folders / recover, read and edit files (anchor-verified, index-synced, with safe recoverable deletes), run filesystem questions (du / find / tree / largest), find code symbols, and use Lattice Memory. You can also just click Ask Lumen → 🤖 Connect your AI for a guided walkthrough.

Power search operators (borrowed from Everything)

The instant search box understands power-user operators:

| Operator | Example | Meaning |

|---|---|---|

| !term | apple !dll | exclude — drop results containing *term* |

| a\|b | invoice\|receipt | OR — match either |

| regex: | regex:apple.*\.png | full regular-expression mode |

| in: | apple in:downloads | scope to a real directory segment (not just a substring) |

| natural dates/sizes | big pdfs from last week | size/date/type words become filters automatically |

These compose with the existing ext: size: before: after: operators.

Features

LatticeSearch — Features

Everything LatticeSearch does today, grouped by what you'd actually reach for. Every capability

below is built and verified on a real 1.66M-file machine (see LATTICESEARCH-BRIEF-2026-07-18.md

for the raw build log and measured numbers). Where a feature has a real limit, it's stated plainly.

One-line summary: instant search by name *and* meaning across your whole PC — photos, docs,

video, audio, speech, screenshots, faces — plus a full file explorer, safe file operations,

backup/dedup/recovery, an encrypted vault, and an MCP/CLI surface that lets your AI agents search

the machine. All local, all offline, on CPU (GPU auto-accelerates when present).

---

1. Search & Find

| # | Feature | What it does |

|---|---|---|

| 1 | Instant name search | Filename/path lookup over the whole drive (1.66M files here). Sub-10ms over ~1M names; with the optional Rust sidecar, 9.6–16.7ms median over 1,849,709 rows. This is the Everything-class "table stakes" tier — free-fast, always on. |

| 2 | Meaning search | Type what a file *is about* and get it back even if the words never appear in the name. Runs across every modality below through one search box; cheap tiers scan inline (~72–88ms fresh, 2–3ms cached), heavy models never block the search path. |

| 3 | Ranked, deduped results | Exact-stem > basename > path ordering (so "apple" surfaces apple.dll, not WinSxS "applet" junk); content-duplicates collapse to one hit; live category counts per query (images · docs · video · …). |

Meaning search covers every modality — all local, all CPU:

| Modality | Model | What you can find |

|---|---|---|

| Images | the lattice | "a red apple", "cartoon flame mascot" → the actual picture; image→image similarity. |

| Documents | the lattice (100+ languages) | Cross-lingual: an English query finds Japanese/German/Hindi docs. PDF/DOCX/XLSX/PPTX/MD/RTF/code/logs/ebooks/emails/subtitles/bookmarks/archives all chunked and searchable. |

| Video | the lattice frame sampling | Search scenes; results jump to the matched timestamp. Drop a still frame → find the source video. |

| Audio | the lattice | Text→sound ("bell sound", "dog barking") and sound→sound ("find similar speeches") — matches on *content*, proven with neutral filenames. |

| Speech | the lattice | Search what was said inside recordings and video soundtracks; results cue to the exact moment. |

| Screenshots / images with text | OCR (RapidOCR) | Find a screenshot by the text inside it ("runpod pricing console"). |

| Photo scenes | the lattice-2 captions | Find photos by description ("cats on a table") even with no text or tags. |

| People | insightface face clustering | Groups faces into people; browse per-person photo grids. |

| AI renders | PNG metadata parser | Search your ComfyUI/A1111 images by their generation prompt. |

| # | Feature | What it does |

|---|---|---|

| 4 | Crop / partial-image search | Index-time tiling embeds 5 crops per image (center + 4 quadrants), so a cropped fragment finds its source. Verified: a Union-Jack crop → original rank #1. *Limit:* highly symmetric/patterned images can still land at rank #2. |

| 5 | Find by example (drop a file) | Drop any image/video/audio/other file onto the search bar or drop zone → finds the exact copy (and every duplicate location), similar files, and where it lives. |

| 6 | Query operators | ext:png in:downloads size:>10mb size:<2gb before:2025 after:2024-06 parsed on the instant name path; combine freely with meaning terms. |

| 7 | Lattice Suggest ("did you mean") | Spelling corrected toward *this machine's* vocabulary (120k tokens from your filenames + doc words). "fire safty poster" → "fire safety poster" in ~12ms; correct queries get no nag. |

| 8 | Expand / Focus | Broaden (pull in neighbours of the top hits) or narrow (raise the bar) any result set; seed from a specific result to pivot the whole search onto its embedding. |

| 9 | lattice grep (semantic-narrowed grep) | Meaning narrows 1.66M files to the handful that *mean* your query, then exact the lattice runs only inside them — "grep the 8 files that matter" instead of grepping the whole drive. |

| 10 | Lumen — the built-in agent | A crystalline search-sprite (bottom-right) opens a chat wired to the on-device agent: conversational answers plus real result hits with thumbnails. Understands time/size/type ("big barcast videos from this month") and returns action deep-links — buttons that jump to Backup, Sync, People, Reclaim Space, Settings, etc. |

---

2. Browse & Explore

| # | Feature | What it does |

|---|---|---|

| 11 | Instant file explorer | Folders list from an in-memory directory index with zero disk I/O — 3–26ms for most folders vs Windows Explorer's 16–163ms. Breadcrumbs, Up, folder counts, "listed in N ms". *Limit:* lists from the snapshot; brand-new files appear via live-watch or re-scan. |

| 12 | Photos timeline | A media timeline grouped by Years / Months / Days with All / Photos / Videos / Starred filters, square thumbnails, and a ▶ badge on video. Precomputed rows load in ~168ms (down from 2.1s). |

| 13 | People (face clusters) | A People strip in Photos: click a person → their photo grid → lightbox. Faces are clustered offline; this is browse-by-person, not surveillance. |

| 14 | Knowledge Graph | A force-directed graph of your files across 7 lenses (related images, related text, largest/smallest, by colour, by type, by folder, and a live search lens). Nodes render the *actual content* — image/video thumbnails, audio waveforms, doc snippet cards — not just circles. Drag/zoom/pan, click to preview, double-click to open. |

| 15 | Media previews (in-app) | Universal lightbox for image/video/audio with HTTP Range streaming (seekable, no whole-file RAM). YouTube-style hover-scrub silent video previews in results and grids; audio plays at the matched moment; SVG renders natively. |

| 16 | View layouts | Grid · Large grid · List · Details (list + sticky preview pane), with sortable columns (name/modified/size/type). Persisted per session. |

| 17 | Rich preview panel | Hero image/video thumbnail + a metadata table (type, size+bytes, dimensions/megapixels, dates, clickable location) plus "lattice senses" — which indexes actually know this file. |

| 18 | Recents & Starred (server-side) | Stored in the lattice itself (not just localStorage), so they persist across sessions; star toggles on every row and preview; committed-search-only recents (no keystroke spam). |

---

3. Lattice Hands & lattice fs — file operations built for agents (and you)

Index-synced, instant, and *reversible* — safer than raw shell, and every write is searchable the

instant it lands. All exposed via GUI, CLI, and MCP.

| # | Feature | What it does |

|---|---|---|

| 19 | Read (read --about) | Return the whole file, or only the indexed chunks relevant to a topic — so an agent gets the 40 lines it needs, not 2,000. Graceful full-read fallback. |

| 20 | Write | Atomic write that is searchable immediately (proven: a unique filename is found by search right after writing). |

| 21 | Edit (anchor-verified) | Exact string-replace that verifies the anchor first — 409s on a missing/ambiguous anchor instead of corrupting the file. Atomic, index-synced. |

| 22 | Move / rename | O(1) same-volume rename/move — 1.14ms regardless of file size. |

| 23 | Copy | Parallel verified copy. |

| 24 | Safe delete | Archives the bytes to the recovery store and sends to the Recycle Bin — reversible, unlike a shell rm. |

| 25 | lattice fs (filesystem questions from the index) | du / find / tree / glob / largest answered from RAM — no process spawn, no disk walk, milliseconds. du on 468MB/1,062 files returns in ~0ms; find merges the live layer so files written seconds ago are found. |

| 26 | lattice sh (batch / REPL) | Run many verbs in one process. A 6-step real workflow (du, find, glob, write, read, delete) ran 22.6× faster than six PowerShell spawns (658ms vs 14,865ms) — du's recursive disk walk dominates the shell baseline. |

| 27 | Code-symbol search | Functions/classes indexed (ctags-style + embeddings): "where is the jitter latency guard" → jitter_check at server.py:132. Incremental rebuild in ~100ms. |

Per-op Lattice Hands vs a PowerShell spawn (measured): write 13.6× · read 20.1× · copy 16.3× ·

rename 18.0× · delete 5.4× (and *recoverable*, where the shell's is permanent).

---

4. Files & Space

| # | Feature | What it does |

|---|---|---|

| 28 | Reclaim Space (byte duplicates) | Same-size → sha256 to find byte-identical files; shows reclaimable MB and duplicate sets; "apply" archives to recovery first, then Recycle Bin (reversible). *Note: saves disk, not RAM.* |

| 29 | Visual Duplicates | Same picture saved twice under different names/sizes/formats, found by pixel fingerprint (dhash), not just bytes — found 6.1GB reclaimable across 120 groups on the test machine. |

| 30 | Backup | Deduplicated, zstd-compressed, integrity-verified snapshots. Measured on a 167MB corpus: 5.5× smaller than the source (vs zip 2.55×) and 6.7× faster to create than zip; a second backup of an unchanged tree is nearly free (incremental 0.38MB vs a fresh 65.4MB zip); a flipped byte is pinpointed to its blob; restores are byte-perfect. *Limit: empty dirs not preserved.* |

| 31 | Recovery (restore-by-description) | Restore deleted files by *describing* them ("document about checking smoke alarms") for up to 90 days, byte-perfect. *Honest boundary:* works only for files the app archived (protected-folder archiving + Recycle Bin) — embeddings cannot reconstruct bytes, so this is not magic un-deletion of arbitrary files. |

| 32 | Compression (index & models) | Native zstd folds the on-disk index 10.8× (212MB → 20MB, lossless); int8 quantization makes shipped models ~4× smaller. *Honest boundary:* this compresses the index and model weights, not your user files — and there is no novel lattice compressor that beats zstd/xz losslessly. |

---

5. Organize, Move & Protect

| # | Feature | What it does |

|---|---|---|

| 33 | Vault | AES-256-GCM searchable encrypted archive: files and their index are sealed; you can run cross-lingual semantic search *inside* the sealed vault. Key = scrypt(passphrase); unlock ~109ms; tampering is rejected (GCM InvalidTag). |

| 34 | Vault USB | Package a vault + a portable app + launcher onto a USB stick. A stranger sees only opaque data.bin; the passphrase unlocks and searches it from the stick. |

| 35 | Hidden vault layer | Vaulted files (and optionally their originals) are hidden from Explorer and excluded from normal results — reachable only through the vault module + passphrase. |

| 36 | Lattice Sync | Pair any two folders (USB is just one case). 5 modes: two-way, a→b, b→a, mirror-a→b, mirror-b→a; per-pair ignore patterns; conflict protection (won't clobber like robocopy /MIR); background auto-sync (~90s) that skips offline roots and resumes. No-change status check is hash-backed at ~43ms. |

| 37 | Lattice Drive | Mount L: (a watched folder) — anything dropped in is pre-indexed by construction, findable via fs in ~1ms and by search within seconds. |

| 38 | Import to Drive | Import files or whole folders (USB/camera) into L:\Imports, which is live-watched and indexed on arrival. (Distinct from the Home drop-zone, which *searches* a dropped file.) |

| 39 | Drives (multi-drive) | Enumerate and index additional/removable volumes (one index each); removable drives pair with Lattice Sync. Handles hot-swap, unplug=offline-tag, BitLocker, network-drive hazards. |

| 40 | Lattice Clipboard | Clipboard history you can search by meaning; text auto-embeds into memory; a secret filter (AWS keys, password=, PEM blocks, long base64) drops sensitive content before anything is stored; click a past entry to paste it back. |

| 41 | Lattice Memory (cross-session recall) | A private namespace where facts/notes are stored and recalled by meaning across sessions — the anti-compaction long-term memory for agents and for you. ~20ms recall at 500 entries. |

| 42 | Lattice Report | A self-contained weekly digest: index coverage + deltas, recent activity, reclaimable space, freshness, memory sessions. |

| 43 | Index Health | Coverage bars per "sense" — names, image meaning, text, sound, pixels — so you can see exactly what the lattice knows and what's still backfilling. |

| 44 | Regeneration cycle | Idle-time maintenance (03:00–05:00 when unused): condense shards, backfill docs/images/audio newest-first, refresh captions/pixel-hashes/colours/symbols, re-scan if stale — all bounded and resumable. |

---

6. AI-Agent Substrate

Turns LatticeSearch into the filesystem layer for your AI tools.

| # | Feature | What it does |

|---|---|---|

| 45 | MCP server (20 tools) | stdio JSON-RPC exposing search/ask/find_file/photos/list_folder, the full fs_* family, Lattice Hands (read/write/move/copy/delete/glob/edit), memory store/recall, and find_symbol. Drops into Claude Desktop/Code, Cursor, or any MCP agent. Proven 44× fewer tokens and 12× faster than naive grep-and-read for a 3-lookup task (1,230 tokens / 11s vs 54,465 tokens / 133s). |

| 46 | CLI (lattice) | search/find/ask/recover/photos/ls/star/open/health plus the fs, Hands, memory, clipboard, and symbol verbs; --json for scripting. |

| 47 | AI Access page | Generates copy-paste-correct configs (Claude Desktop JSON, claude mcp add one-liner, generic MCP, CLI examples, an agent setup prompt) so connecting an agent is one click. |

| 48 | Warm model host | A separate process holds the lattice/e5 (the lattice lazy) resident and serves encodes over a local socket, so the engine restarts in ~19s instead of ~60s, multiple engines can share one host, and low-RAM/netbook boxes get semantic search. |

| 49 | lattice make (build caching) | Content-addressed zstd artifact cache with an instant input fingerprint: a real 56.5s Rust build became a 57ms cache hit (~1000×), and it can restore a deleted build artifact without recompiling. |

---

7. Privacy

| # | Feature | What it does |

|---|---|---|

| 50 | Local-only, zero telemetry | Nothing leaves the machine; air-gap capable and firewall-provable. The anti-Recall. |

| 51 | Incognito mode | 🕶 toggle: no recents, no activity log, memory-store refused, clipboard capture paused, search-cache skipped, jitter labels redacted. *Honest boundary:* leaves no trace in the lattice — but the OS still journals (USN/MFT, event logs, jump lists); this is not an anti-forensics tool. Deletes are still recovery-archived by design (safety over tracelessness). |

| 52 | True-forget with grace | Removing a recent (✕) soft-deletes it; re-searching within 7 days un-forgets it; after the window it's purged for good, client mirrors included. |

| 53 | Secret filter | Clipboard capture screens out API keys, passwords, PEM blocks and long base64 before anything is stored. |

| 54 | Local API token | Every mutating endpoint (including open/reveal) requires a per-install token; foreign-origin requests are refused — no drive-by launches. |

| 55 | Cloud-placeholder safety | Online-only files (e.g. 30% of a Dropbox tree) stay name-searchable but are never hydrated/downloaded by background indexing. |

---

8. Platform

| # | Feature | What it does |

|---|---|---|

| 56 | Native Windows shell | A tiny Tauri/wry desktop app (~0.6MB exe) wraps the engine in a real window — light/dark, theme-aware. |

| 57 | Global hotkey palette | Ctrl+Alt+Space anywhere pops a frameless, always-on-top Lattice Search Bar: instant results, multimodal thumbnails, Lattice Suggest, recent searches, drag-a-file-in to content-search; ↑↓/Enter/Esc. |

| 58 | Right-click menu | In-app Dropbox-style context menu (Open, Find similar, Copy path, Rename/Move/Copy/Delete, info) and a Windows Explorer right-click integration (per-user, no admin): Instant Move / Fast Copy / Recoverable Delete / Find similar. |

| 59 | Send-To entries | Windows Send-To: Lattice Find-similar, Safe-delete, and Lattice Drive. |

| 60 | Lite / no-admin mode | --lite runs name search + instant explorer + browse with the ML models off (RAM ~1.27GB vs ~3.5GB). Snapshotting needs no admin — it indexes whatever the user can read; the fast NTFS MFT path just makes the first scan quicker. |

| 61 | Cross-platform seams | Native open/reveal and hidden-file handling on Windows/Mac/Linux; auto-device (CPU by default, CUDA auto-boost when present with graceful fallback). |

| 62 | Headless Linux / server edition | Runs as a bounded, localhost-only, token-gated service: indexed 700,588 files in 16.6s (42k files/s) at 360MB RSS, search 10–22ms. |

| 63 | Debug / monitoring console | Live request + error tail with per-endpoint timing and a latency guard that flags any search over its budget. |

---

Features documented: 63 (grouped into 8 areas), plus the 9 searchable modalities in the meaning-search table.

*Recurring honest boundary across the product:* the lattice answers from its index — milliseconds,

but as fresh as the last scan/watch tick. The name tier is live-watched; embedding tiers backfill

continuously; real execution (builds, tests, git) stays with the shell. Meaning search is

probabilistic — which is exactly why lattice grep (semantic narrow → exact match) is the pattern

wherever precision matters.

Access control

Access Control — Red Tape, Green Tape, and Work Mode

The feature that makes LatticeSearch safe to run on a work machine. You decide exactly what the

lattice is allowed to see. Nothing is scanned, indexed, served, or shown to an AI agent unless you

permit it — so confidential company data stays invisible to the engine.

This is a headline USP: most desktop search tools index *everything* by default. LatticeSearch can

be told, precisely, where it may and may not look — and it enforces that at every layer.

The two modes

Personal mode (default)

Full access to everything on the machine — except any folder you've red-taped. This is the

normal single-user experience: instant search over your whole drive, with the option to carve out a

few private folders.

Work mode

Deny by default. The lattice scans only the folders you've green-taped (explicitly

allowed). Everything else on the machine is off-limits — never scanned, never indexed, never served.

The index grows *only* where you grant access. Perfect for a work laptop that also holds client

data, HR files, or anything under confidentiality: the lattice indexes your design folder and

nothing else.

Red tape vs green tape

| | What it does | Applies in |

|---|---|---|

| 🟥 Red tape (deny) | This folder is never scanned, in any mode. | Personal and Work |

| 🟩 Green tape (allow) | This folder may be scanned. | Work mode (the allowlist) |

Red tape always wins. Even in personal mode, a red-taped folder is invisible to the engine. And in

work mode, a red-taped subfolder *inside* a green-taped area is still excluded — so you can allow

Projects\ but block Projects\ClientConfidential\ within it.

How the gate works (and why it can't be bypassed)

Every path the engine might touch — a scan root, a live-watch event, a file it's about to serve, a

search result, a CLI read/write — passes through one function, is_scannable(path):

1. The path is resolved to its real location first (realpath), so ..\..\ traversal tricks

can't sneak outside an allowed area.

2. If it's under any red-tape root → denied (both modes).

3. Personal mode → allowed (unless red-taped).

4. Work mode → allowed only if under a green-tape root.

Because *every* layer funnels through this one gate, there's no side door: the scanner won't walk

it, the watcher won't index it, the file server won't stream it, search won't return it, and the AI

agent's lattice read can't open it. Comparison is case-insensitive on Windows and boundary-safe

(so allowing C:\Work does not accidentally allow C:\WorkOther).

Agent-safe by design

When you point Claude or Codex at the lattice in work mode, the agent physically cannot see or

read anything outside your allowed folders — the engine returns nothing for off-limits paths. You

get all the speed of the lattice for your actual work, with a hard wall around everything else. That

is the B2B story: an AI file-brain your compliance team can approve, because the data boundary

is enforced by the tool, not by trusting the agent to behave.

Configuration

Stored in lattice_access.json in the engine's data directory:

{
  "mode": "work",
  "allow": ["C:\\Users\\me\\Design", "C:\\Users\\me\\Projects"],
  "deny":  ["C:\\Users\\me\\Design\\ClientConfidential"]
}

Managed from the GUI (Settings → Access): a Personal/Work toggle, a green-tape folder picker for the

allowlist, and a red-tape picker for always-off-limits folders. Changing it takes effect

immediately — the gate re-reads the config on the next operation, and the next scan reshapes the

index to match.

How this fits the engine

The lattice engine builds tiers of understanding over your files — a name index (instant

filename/path search from RAM), and optional semantic tiers (meaning search over images, documents,

audio, captions). Access control sits in front of all of it: roots_to_scan() narrows what the

indexers ever walk, and is_scannable() guards every read after that. So work mode doesn't just

hide results — it means the confidential bytes are **never loaded into the index in the first

place**. Turn work mode on before the first scan and the engine simply never learns those folders

exist.

Command line

LatticeSearch CLI (lattice)

lattice is a thin command-line client for the running LatticeSearch engine. Every verb is a

single HTTP call to the local engine (default http://127.0.0.1:8765), so answers come back from

the warm in-memory index in milliseconds — no disk walk, no model cold-start.

Launcher

There is no installed lattice shim yet; invoke the script with the engine's Python:

"C:\sd\kohya_ss\venv\Scripts\python.exe" C:\sd\latticesearch\lattice.py <verb> [args]

For brevity the rest of this doc writes that as lattice <verb>. Define a shell function/alias if

you use it often, e.g. in PowerShell:

function lattice { & "C:\sd\kohya_ss\venv\Scripts\python.exe" "C:\sd\latticesearch\lattice.py" @args }

Environment & auth

| Variable | Default | Purpose |

|---|---|---|

| LATTICE_URL | http://127.0.0.1:8765 | Which engine to talk to. |

The auth token is read automatically from ls_token.txt beside lattice.py and sent as the

X-LS-Token header — mutating verbs (write/edit/mv/cp/rm/star/open/remember/…) need it; the file

is written by the engine on first start, so no manual setup is required on the same machine.

Global flags

| Flag | Effect |

|---|---|

| --json | Emit raw JSON instead of the formatted view. Goes before the verb: lattice --json search "…". |

Exit code is 0 on success; health exits 2 if the engine is unreachable.

---

EYES — find things without walking the disk

The read side of the lattice: semantic + name search, "where does this file live", the assistant,

semantic-narrowed grep, and instant filesystem answers straight from the index.

search — semantic + name search across the whole machine

lattice search <query> [--cat all|images|video|audio|docs|code|other] [--sort rel] [--limit 15]

Fuses three tiers in parallel: ranked filename/path matches, the lattice image-meaning matches, and e5

document-meaning snippets.

$ lattice search "a red apple fruit"
# 6 files (48ms), 24 images, 8 docs
  exact   apple.py                                  C:\sd\tools\apple.py
  img 0.31  HITL_Apple.png                          C:\sd\datasets\HITL_Apple.png
  doc 0.86  fire_safety.txt: procedures for checking smoke alarms and evac

find — where does this image/video live (and what's similar)

lattice find <image_or_video_path>

Encodes the file with the lattice and looks for the exact copy (cosine > 0.999), the folders it most

lives in, and — for video — the best-matching moment.

$ lattice find C:\Users\Shadow\Desktop\photo.png
# Found the exact file (43ms)
  EXACT  C:\sd\datasets\HITL_Apple.png
  lives  0.88 12x  C:\sd\datasets\fruit

ask — the Lattice assistant (natural-language question over your files)

lattice ask <question>

A deliberate, higher-quality path: fused retrieval plus the cross-encoder reranker (which never

fires on plain search, to keep it instant). Returns a written answer and the files it used.

$ lattice ask "which document explains the evacuation plan"
The means-of-escape guidance is in the EMBER fire-safety course...
  [doc] means-of-escape.html  C:\sd\ember\content\means-of-escape.html

grep — the grep amplifier (meaning-narrow, then exact-match)

lattice grep <pattern> [--about <meaning>] [--cat all] [--files 40] [--limit 30]

Turns "grep the whole disk" (slow/impossible) into "grep the ~N files that *mean* X": the lattice

picks candidate files by meaning (--about, falling back to the pattern), then runs the lattice (or a

Python fallback) only inside them.

$ lattice grep "deploy" --about "how to deploy the ember course"
# narrowed to 8 files by meaning, grepped in 313ms, 11 matches
  C:\sd\ember\DEPLOY.md:12:hPanel upload_file then 1-click rollback

fs — instant filesystem answers from the index (no walk)

lattice fs du|largest|find|tree <dir> [pattern] [--limit 30] [--depth 2]

The lattice already holds (path, size, mtime) in RAM, so du/find/tree/largest become

lookups — ~1000× faster than a live directory walk, with bounded output.

| op | Answers | Extra args |

|---|---|---|

| du | total bytes + file count of a folder tree | — |

| largest | the N largest files under a folder | --limit |

| find | files whose name contains pattern under a folder | pattern, --limit |

| tree | folder tree with per-folder file counts | --depth |

$ lattice fs du C:\sd\ember
41.2 GB  (44,230,113,001 bytes)  18,442 files   [3ms from index]

$ lattice fs largest C:\sd --limit 3
    1.2 GB  C:\sd\models\clip\open_clip_pytorch_model.bin
    1.1 GB  C:\sd\models\reranker\model.safetensors
    590 MB  C:\sd\models\clap\pytorch_model.bin

glob — wildcard matching from the index (instant)

lattice glob <dir> <pattern> [--limit 100]

* ? wildcard file matching under a folder, answered from the index (no shell glob, no walk).

$ lattice glob C:\sd\ember "*.mjs"
37 hits [4ms from index]
  C:\sd\ember\routes\messages.mjs
  ...

ls — browse a folder from the index

lattice ls [<dir>]

Lists sub-folders and files of a directory (empty = drive roots), served from the pre-built

dir-index with zero disk I/O.

$ lattice ls C:\sd\ember
  [dir]  content
  [dir]  routes
  code    server.mjs
  docs    README.md

photos — the media timeline

lattice photos [--filter all|photos|videos|starred] [--group years|months|days]

$ lattice photos --filter photos --group months
# 49777 media files (1280ms)
  2026-07: 812 items
  2026-06: 1,140 items

---

HANDS — instant, safe, index-synced file I/O

The write side. Everything written is instantly searchable; deletes are recoverable;

same-volume moves are O(1). These are 13–20× faster than spawning a shell for the same action,

and they keep the index in sync so the next search sees the change.

read — whole file, or only the chunks about a topic

lattice read <path> [--about <topic>]

Without --about, prints the file. With --about, returns only the chunks that mean the topic —

the biggest single token saving for agents on large files.

$ lattice read C:\sd\ember\server.mjs --about "how photos are served"
[chunks about 'how photos are served' — 22ms]
---
app.get('/photos', ...) { ... }

write — atomic write, instantly searchable

lattice write <path> <content>       # content of "-" reads stdin

$ echo "release notes v34" | lattice write C:\sd\notes\v34.txt -
written 18 bytes — instantly searchable

edit — verified exact-string edit

lattice edit <path> <old> <new> [--expect 1]

Refuses ambiguous or missing anchors (no blind-edit failures), writes atomically, re-indexes. Set

--expect to the number of occurrences you intend to replace.

$ lattice edit C:\sd\config.ini "port=8000" "port=8765"
edited: 1 replacement(s) in 4.1ms

mv — O(1) same-volume move (any size)

lattice mv <src> <dst>

Same-volume moves are an instant rename regardless of file size; cross-volume falls back to a

verified copy + delete.

$ lattice mv C:\sd\a\big.mp4 C:\sd\b\big.mp4
moved via rename in 0.3ms -> C:\sd\b\big.mp4

cp — parallel verified copy

lattice cp <src> <dst>

$ lattice cp C:\sd\a C:\sd\a_backup
copied 214 files in 380ms -> C:\sd\a_backup

rm — SAFE delete (recoverable)

lattice rm <path>

Not a hard delete: the bytes are archived to the recovery store (restorable ~90 days) and sent

to the Recycle Bin. Recover with lattice recover / lattice restore.

$ lattice rm C:\sd\tmp\old.log
deleted safely (recoverable)

---

MEMORY — persistent, meaning-searchable notes

A private semantic memory store that survives sessions (and, for agents, compaction).

remember — store a fact/note

lattice remember <text> [--session <name>] [--tags <csv>]   # text of "-" reads stdin

$ lattice remember "the render server uses port 4700" --session ember
remembered (1 chunk(s), id a3f1)

recall — recall by meaning

lattice recall <query> [--session <name>] [--limit 6]

$ lattice recall "which port did the render server use"
  0.912 [ember] the render server uses port 4700

---

image understandingBOARD — searchable clipboard history

lattice clip [list|search|on|off] [query]

| Form | Effect |

|---|---|

| lattice clip / lattice clip list | Show whether capture is on + the recent captured items. |

| lattice clip search <query> | Semantic search over captured clips. |

| lattice clip on / lattice clip off | Enable / disable clipboard capture. |

Credential-looking text (passwords, tokens, API keys, PEM blocks, long base64) is filtered out and

never stored — see PRIVACY.md.

$ lattice clip search "runpod api"
  0.874 export RUNPOD_ENDPOINT=https://...

---

CODE — find symbols by name or meaning

lattice sym <query> [--limit 10]

Resolves "where is the retry logic" to file:line over the code-symbol index.

$ lattice sym "the retry logic"
  fuzzy   func   _post_with_retry  C:\sd\latticesearch\transfer.py:88

(If empty: build the symbol index with python codesym.py build --roots <dirs>.)

---

UTIL — recovery, opening, status, virtual drive, shell

recover — search deleted files

lattice recover <query>

$ lattice recover "the doc I deleted about smoke alarms"
  0.85  fire_safety.txt  (deleted 2026-07-10, RECOVERABLE)  C:\sd\...\fire_safety.txt

restore — restore a deleted file

lattice restore <path>

Restores byte-identical to ~\LatticeSearch Recovered.

$ lattice restore C:\sd\docs\fire_safety.txt
restored -> C:\Users\Shadow\LatticeSearch Recovered\fire_safety.txt

star — star / unstar a file

lattice star <path> [--off]

open — open in the default app

lattice open <path>

health — engine status

lattice health

$ lattice health
engine OK — 1,659,874 files, 16,059 images, 9,420 doc chunks

drive — the always-indexed virtual drive

lattice drive mount|unmount [--letter L]

Mounts ~\LatticeDrive as a drive letter via subst and registers it as a live-watched root:

anything dropped there is instantly name-indexed and embedded when idle. (Restart the engine once

after the first mount so the watcher picks up the new root.)

$ lattice drive mount --letter L
LATTICE DRIVE mounted: L:  ->  C:\Users\Shadow\LatticeDrive

sh — the lattice shell (many ops, one process)

lattice sh                       # interactive REPL
lattice sh "cmd; cmd; ..."       # batch, semicolon-separated

Kills the per-command process-spawn tax: many index ops run in one Python process, measured

~22.6× faster than the equivalent chain of separate shell/CLI invocations. Sub-commands:

search du largest find glob tree read write mv cp rm suggest.

$ lattice sh "du C:\sd\ember; largest C:\sd\ember 3; find C:\sd\ember server"
41.2 GB  18,442 files  [3ms]
    1.2 GB  C:\sd\ember\...
3 hits [2ms]
   C:\sd\ember\server.mjs

---

Speed at a glance

| Verb group | Win vs the naive alternative |

|---|---|

| fs / glob / ls | ~1000× vs a live directory walk (answered from the RAM index) |

| read / write / edit / mv / cp / rm | 13–20× vs spawning a shell for the same action |

| sh (chained ops) | ~22.6× vs the same ops as separate process invocations |

| search / find / ask vs grep+ls chains | 44× fewer tokens, 12× faster per task (agent benchmark) |

See MCP.md for the same capabilities as MCP tools for AI agents, and

PRIVACY.md for the local-only security model.

FAQ

LatticeSearch FAQ

Straight answers to the questions people ask most. Where a feature is still maturing, we say so.

---

Privacy and data

Is it private? Does anything leave my machine?

Yes, it's private, and no — nothing leaves your machine. LatticeSearch indexes and searches entirely locally. There is no cloud service, no account required to search, and no telemetry sending your files or queries anywhere. Zero network egress is a design goal, not an afterthought — you can confirm it with a firewall rule if you like. This is the deliberate opposite of screen-recording "recall" features: LatticeSearch indexes only what you point it at, and it keeps the results on your disk.

What does Incognito mode actually protect — and what doesn't it?

Turning on Incognito (the 🕶 button) stops LatticeSearch from recording anything about your session: no recent searches, no activity log, no clipboard capture, no memory writes, no preview history. It leaves no trace in the lattice.

Being honest about the boundary: Incognito is not an anti-forensics tool. Windows itself still journals activity outside LatticeSearch's control — the NTFS change journal (USN/MFT), event logs, jump lists, and so on. Incognito controls what *LatticeSearch* remembers, not what the operating system records. One deliberate exception: files you delete are still archived to Recovery even in Incognito, because we'd rather protect you from an accidental deletion than leave no trace.

Where is the index stored?

On your own disk, alongside the app's data. The design keeps the index under your user profile with user-only permissions and encryption at rest; the searchable-but-encrypted Vault is available for anything you want sealed behind a passphrase.

---

Hardware and requirements

Do I need a GPU, an NPU, or a fast PC?

No. LatticeSearch is CPU-first — every part of it has a CPU path, and it does not require a Copilot+ NPU the way Windows' own semantic search does. If you *have* a compatible GPU, LatticeSearch uses it automatically to speed up the one-time indexing, and it falls back to the CPU gracefully if the GPU is busy or unavailable. Either way you get the same results; the GPU only changes how fast the initial backfill runs.

Does it need an internet connection?

No. LatticeSearch is fully offline. The AI models it uses are bundled and run locally, so search works with your network unplugged.

How much RAM and disk does it use?

  • Disk: the models ship quantized to roughly 0.9 GB, and the index itself is small — the file index compresses to about 20 MB for shipping and unfolds on install. Image and document indexes are compact (an image is stored as a few hundred bytes of "meaning"). Overall footprint on disk is on the order of ~1 GB installed.
  • RAM: while running, the current build uses a few hundred MB up to a couple of GB depending on your library size and which senses are loaded. There's a Lite mode for low-RAM machines (name search + instant explorer, with the heavier meaning models turned off). The forthcoming native build brings the resident footprint down substantially. For scale: a ~500,000-file library holds its indexes in under half a gigabyte of RAM, memory-mapped.

How long does the first indexing take?

It's tiered, so you're searching by name within minutes. The meaning layers fill in afterward, in the background: images and documents within an hour or so on a typical library, and the heaviest senses (text-in-images/OCR, speech-to-text, scene captions, face grouping) can run for hours or overnight on a large collection. It's a one-time cost — after that, updates are incremental and quiet.

Will it slow down my PC or wear out my SSD?

It's built to stay out of your way. Search itself is designed to feel instant, and background indexing yields to you — the meaning models only run when you're not actively searching, and a maintenance pass runs at night when the machine is idle. On SSD wear: indexing mostly reads your files (once) rather than writing; the index it produces is small and updates incrementally as files change, so day-to-day write volume is modest. The one-time first-index does read across your library, which is normal disk activity, not a stress test.

---

Multiple users

How are different users' files kept separate on a shared PC?

LatticeSearch respects Windows permissions (ACLs). Run without administrator rights, it indexes only what your account can actually read — your own profile and files — and cannot reach other users' protected folders. So it never surfaces files you wouldn't otherwise be able to open.

Fully separate, isolated per-user indexes running side by side is on the near-term roadmap (the architecture already supports multiple engine instances sharing one model host). Today, the honest position is: it respects the OS's access controls, and for anything you want positively sealed, use the passphrase-protected Vault.

---

Deleting and recovering

If I delete a file through LatticeSearch, can I get it back?

Yes. Deletes done through the app go to the Recycle Bin *and* are archived to LatticeSearch's own recovery store. You can restore them from Deleted files — even by *describing* them rather than remembering the name — and they come back byte-identical. Recoverable files are kept for 90 days. (Recovery covers deletions that went through LatticeSearch; it can't recover files removed by unrelated tools it never saw.)

What's the "forget window"?

That's a separate thing from file recovery — it's about your recent searches. When you remove a recent search (the ✕ next to it, or Clear all), it enters a grace period: search it again within 7 days and it comes back; after 7 days it's purged permanently. You can change this window in Settings.

---

Platforms and editions

Does it run on Windows, Mac, and Linux?

Windows is the primary, shipping target — it uses Windows' fast file-system journals for near-instant, whole-drive indexing and live updates.

Mac and Linux are supported through the cross-platform native build (it uses the equivalent OS mechanisms — FSEvents on Mac, inotify on Linux — for change tracking). That build is the path to full desktop parity on those platforms.

Is there a server or NAS edition?

Yes — there's a headless build that runs without a desktop, which is what a server or NAS scenario needs. In testing it indexed 700,000+ files in about 17 seconds and answered searches in 10–22 ms while using roughly 360 MB of RAM, bound to localhost only. You reach its interface over a browser or an SSH tunnel.

---

Using it with AI

Can my AI assistant search my files through LatticeSearch?

Yes — that's a first-class feature. LatticeSearch exposes an MCP server and a CLI, so assistants like Claude (Desktop and Code), Cursor, and other agents can use it as their eyes and hands into your machine. Instead of blindly walking and reading files, the agent asks LatticeSearch for what it *means* and gets ranked results in milliseconds. Measured against naive grep-and-read loops, that's about 44× fewer tokens and 12× faster per task — and everything stays local. The AI Access page generates the exact, copy-paste setup for your machine. See the Help guide's "Connecting an AI" section for steps.

---

Pricing and licensing

What does it cost? What's the difference between Free and Pro?

LatticeSearch is a one-time purchase — no required subscription.

  • Free lets you try LatticeSearch and covers the core instant search experience.
  • Pro is a one-time $129 license that unlocks the full local product — whole-drive search across every sense, plus the toolset (Reclaim Space, Backup, Lattice Sync, Vault, AI Access, and more).
  • A per-seat Business option exists for teams, and for anyone who prefers to pay over time there's an optional subscription — but you never *have* to subscribe to keep using what you bought.

A Pro purchase is perpetual and includes a period of updates; you keep the version you have forever, and major future versions may be offered as a discounted paid upgrade. Exact tier boundaries are being finalized around launch.

How does the license work offline?

The license is verified offline — it's cryptographically signed and tied to your machine, so it keeps working with no internet connection (with a grace period if you're offline for a while). No file data or usage is sent anywhere; an online check, if it happens at all, only asks whether a license was revoked (for example after a refund).

---

Troubleshooting

The app says the engine is offline / "connected" dot is red

The search engine runs as a small local background process, and a watchdog keeps it alive — if it stops, the watchdog relaunches it automatically (it polls about once a minute and restarts after a couple of missed beats). The connection dot in the top bar turns green again once it's back. If it stays red for more than a minute or two, restart the app (or run the launcher) to bring the engine back up.

The quick-search palette is blank

The palette reloads its page every time you open it, so a blank palette is almost always a momentary state while the engine is restarting. Close it (Esc) and reopen with Ctrl+Alt+Space. If it's still blank, the engine may be mid-restart — wait a few seconds for the connection dot to go green, then try again.

My search results look stale / a new file isn't showing up

LatticeSearch serves listings and name results from its index. New files are normally picked up within seconds by the live watcher, but if something's missing:

  • Re-scan the drive from More → Drives (⚡ Index drive), which rebuilds the name index in the background.
  • The app also guards against staleness on its own — if the index hasn't been refreshed in over a day, it kicks off a background rescan at startup.
  • Remember the tiers: a brand-new file may be findable by name before its meaning has been indexed. Give the background senses a moment to catch up.

The Ctrl+Alt+Space hotkey doesn't work

Ctrl+Alt+Space is the global palette hotkey. If another application has claimed the same combination, it may win the keypress. Check the current hotkey under ⚙ Settings → System, and close or reconfigure any other tool competing for that shortcut. You can always reach the same search from the main window's search bar.