Every agent session starts the same way: glob, grep, read, read, read — thousands of tokens burned rediscovering a filesystem it forgot the moment the last session ended. LatticeSearch replaces that blind exploration with a persistent, semantic index of the whole machine, exposed to agents through MCP and a CLI. Measured on real tasks: 44× fewer tokens, 12× faster.
All figures measured against real baselines on a 1.8M-file Windows machine — details in the table below. No extrapolations.
An agent that greps a drive reads everything to find anything. An agent with a lattice asks for what the files mean and receives ranked paths in milliseconds — then reads only the chunks that matter. The difference compounds across every session your team runs.
| Task | With LatticeSearch | Naive agent baseline | Measured gain |
|---|---|---|---|
| Find 3 files by meaning (one task, end-to-end) | 1,230 tokens · 11 s | 54,465 tokens · 133 s (grep-and-read) | 44× tokens, 12× time |
| File operations (write / read / copy / rename) | index-synced, atomic, recoverable | one PowerShell spawn per op | 13.6–20.1× |
| 6-step shell workflow as one batch | 658 ms (lattice sh) | 14,865 ms (six shell spawns) | 22.6× |
| Filesystem questions: du / find / tree / largest | answered from the in-RAM index | recursive disk walk per question | milliseconds vs seconds |
| Rebuild after cache hit (lattice-make) | 57 ms | 56.5 s full build | ~1000× |
| Mass rebuild, clean-rebuild case | measured against the same project's clean rebuild | 503× | |
MCP server — 20 toolsSearch, ask, find-file, list-folder, the full fs family (du/find/tree/glob/largest), safe file ops (read/write/edit/move/copy/recoverable delete), memory store/recall, and code-symbol lookup. Drops into Claude Desktop, Claude Code, Cursor, or any MCP-capable agent.
lattice CLIEvery capability as a shell verb with --json output for scripting: search, grep-by-meaning, read-about (only the relevant chunks of a big file), fs questions, batched workflows via lattice sh.
A separate process keeps the core meaning models resident (heavier ones load on demand) and serves them over a local socket — engines restart in ~19 s instead of ~60 s, and multiple engine instances share one host.
Persistent working state for agent sessions, including cross-session memory: agents store decisions and facts as they work and recall them by meaning next session, instead of re-deriving everything.
lattice-make build cacheA content-addressed artifact cache with instant input fingerprinting. Cache hits serve in milliseconds and can restore a deleted build artifact without recompiling.
Agents inherit the machine's access control. Red-taped folders — HR, client work, secrets — are invisible to the MCP server and the CLI, and Work mode limits an agent to only the folders you've green-taped. The engine refuses an off-limits path before any tool runs: governance the agent can't prompt its way around.
The lattice CLI, the MCP server, and the docs ship open-source under Apache-2.0 on GitHub. The engine and desktop app stay proprietary — your integrations build on the open layer.
The in-app AI Access page generates copy-paste-correct configs for your exact machine — Claude Desktop JSON, a Claude Code one-liner, generic MCP config, and CLI examples. It looks like this.
Everything runs over stdio on your machine. No API keys, no network, no data leaving the box.
claude mcp add latticesearch -- lattice mcpClaude Desktop — claude_desktop_config.json
{
"mcpServers": {
"latticesearch": {
"command": "lattice",
"args": ["mcp"]
}
}
}
Or drive it from any script
lattice search "the retry logic in the upload service" lattice fs du C:\projects # answered from RAM, no disk walk lattice read big.log --about "OOM errors" # only the relevant chunks lattice remember "staging DB moved to port 5433" # recall next session
A pilot is a one-week, no-cost proof on your hardware and your real tasks — not a demo on ours. You bring one developer workstation or build server, your agent stack, and a handful of tasks your team actually runs. We do the rest and hand you a before/after you can trust.
We set up the lattice on one machine (offline; name search is live within minutes, meaning layers backfill in the background) and record a baseline: token spend and task time on your real file-finding, file-reading and build tasks the way your agents do them today.
We connect the lattice to your agents over MCP and the CLI, and set access control with you — red-tape confidential repos, or lock the whole machine to Work mode — so the pilot never touches anything it shouldn't. The meaning index finishes in the background.
Your team re-runs the same tasks, now with agents using the lattice as their file brain. We capture tokens, wall-clock time, and build-cache hits on identical workloads — a true apples-to-apples comparison.
You get a side-by-side: tokens saved, time saved, and dollars saved on your workloads, plus where it helped most and any limits we hit. If the numbers don't hold on your hardware, you'll know within the week — no obligation.
Tell us your team size, your agent stack (Claude Code / Cursor / other), and what you'd like to measure. We'll set up the pilot and run the before/after with you.
Book a pilot — email us