Local Intelligence.

What Local Intelligence does.

Local Intelligence (LI) gives you semantic search and pattern surfacing over your own writing — find an entry by what it's about, not just by its words. The main user-visible affordance is ⌘K ("find by meaning"), plus the ability for reflections to cross-reference past writing when something rhymes.

Behind it: each journal entry, reflection, and inbound message is broken into ~1,200-character chunks. Each chunk is embedded by a small model that runs inside the app on your machine — no separate service, no network — returning a numerical embedding vector. Vectors live in memory only. When you search, your query is embedded the same way and compared against the in-memory vectors.

The models it runs on.

Local Intelligence is two small, standard, open models working together — not one black box:

• An embedding model (nomic-embed-text) turns each chunk of your writing into a vector so search can match by meaning. It builds and answers the semantic index.
• A chat model (Qwen3-4B, Apache-2.0) composes the reflections — Reading, Ask, Patterns, Mirror, Signal — grounded in the passages the embedder retrieves, with citations back to your own words.

Both are ordinary open-weight models running in-process through an embedded llama.cpp runtime — the same weight files you could download and inspect yourself. The two jobs stay separate, retrieval and generation, so each piece does one thing and the runtime is swappable by design. Neither needs the network once the weights are on disk.

What stays on this device.

By design:

• Every query you type into ⌘K (semantic search).
• Every embedding vector LI produces.
• Every chunk of journal text the embedding model sees.

Nothing in that list leaves the machine. The model runs inside the app itself — it is not a network service and has no endpoint to redirect, so there is no URL, setting, or environment variable that could point it at a remote server. Embedding and reflection happen as in-process calls; there is no HTTP request for the AI to carry your text anywhere.

The model weights are downloaded once, on first run, from models.thehumanlayer.co — a one-way download, and nothing of yours is uploaded. After that, Local Intelligence needs no network at all.

What gets wiped when you lock the vault.

When you lock (manually with ⌘⌥⇧, or via auto-lock):

• The in-memory semantic index is dropped — the app releases its only reference, so it is deallocated at once.
• Every embedded chunk is zeroized as it is dropped: both the chunk text and its embedding vector are overwritten in RAM before the memory is freed, using Rust's standard zeroize crate.
• Regression tests guard both behaviors, so a future refactor can't silently break the contract.

On unlock, the index rebuilds from scratch — there is no on-disk cache that could survive a lock cycle.

What we cannot fully protect against.

These are real limitations. They aren't bugs in LI; they're properties of the operating environment that no application can fully control.

macOS memory swap

Under heavy memory pressure, macOS may write pages of RAM to disk in a swap file. Our wiping logic runs when we drop the data — but if macOS already swapped a page before that, the bytes can persist on disk briefly.

Active memory while unlocked

While the vault is open, your journal text and embeddings are in your machine's RAM. An attacker with physical access to your unlocked machine — or one who has compromised your user account — can read that memory.

Defenses:

• Lock the vault when you step away (⌘⌥⇧).
• Set auto-lock in Settings to a value you trust (15 minutes is the default we suggest).
• Configure macOS to require password immediately on screensaver/sleep (System Settings → Lock Screen).

Pasting into other AI tools

The model lives inside Human Layer, so there is no shared local service for another app to read — nothing else can see the app's AI traffic or your journal. But if you manually copy journal text into a separate AI tool, what happens to it there is governed by that tool's privacy contract, not ours.

Recommended companion protections.

A short checklist:

1. Turn on FileVault (System Settings → Privacy & Security → FileVault). Protects swap and at-rest data.
2. Configure macOS to require password immediately on screensaver/sleep (System Settings → Lock Screen).
3. Use auto-lock in Human Layer Settings so the vault locks itself when you step away.
4. Don't paste sensitive journal text into third-party AI tools — Human Layer keeps everything local; other tools may not.
5. Use the in-app ⌘⌥⇧ hotkey to lock instantly when you need to.

For paranoid users — deeper cleanup checklist.

We've intentionally kept LI's "Forget index / Purge" action focused: it clears the in-memory index immediately and removes the LI configuration from your vault. After that, LI is in the same state as if you had never enabled it.

We deliberately do not reach into other applications' data — that would be invasive and brittle. If you want to scrub adjacent surfaces, you can do these yourself:

• The downloaded model weights (about 3 GB) live in Human Layer's Application Support folder. They are generic model files and contain none of your journal data; removing the app and its Application Support data deletes them.

For people who want to verify.

The cryptographic core — encryption, the vault format, and sync — is open source at github.com/joey9prints/hl-core, with a FORMAT.md and SECURITY.md you can read and a test suite you can run. The app itself is proprietary, so the privacy claims that live in the app rather than the core are verified a different way: by watching the network.

Spot-check the AI yourself: run a network monitor such as Little Snitch and confirm that using Local Intelligence produces no outbound traffic. The one exception is the one-time model download on first run (models.thehumanlayer.co); after that, nothing. The app ships a machine-readable Internet Access Policy declaring exactly the calls it makes.

Last reviewed: v0.3.23. Reach out if you find anything that doesn't match what's documented here — that's a bug we want to hear about. Email joe@thehumanlayer.co.