Perseus

Perseus is a memory and context layer for AI agents, built by Perseus Computing LLC, that tries to fix a mundane and expensive habit. An agent with no memory layer reloads its entire working set on every turn, meaning all its tools, the whole history, and every document, and the model gets billed for every token every time. Perseus resolves the workspace into verified facts before the context window opens, then retrieves only the memory a given task actually needs.

It ships as two products that sit on one layer. The first is the Perseus context engine, installed with pip install perseus-ctx, which resolves live state from git, services, tests, and the workspace into verified facts before a session opens, so agents don't burn turns re-orienting themselves. It exposes 33 MCP tools that resolve state at call time. The published numbers come from a 200-request live A/B where average prompt size fell from 488 tokens to 27, a 94 percent cut, with the tool manifest shrinking from 171 advertised schemas to 57 because each tool gets advertised once instead of three times under aliases. The site reports zero milliseconds of added P99 latency. The claim underneath all of it is that most of what an agent re-reads on each turn was never relevant to the task in front of it, and that resolving state once, up front, is simply cheaper than rediscovering it on every call.

The second product is Perseus Vault, a persistent encrypted memory engine that arrives as a single Rust binary of roughly eight megabytes, installed through a shell script. There's no Docker, no Postgres, and no cloud service behind it, which is the whole point. It exposes more than 55 MCP tools and works with any MCP host. Recall is hybrid, combining full-text search through FTS5 with dense embeddings and reciprocal rank fusion, and the embeddings ship inside the binary so it still works offline. Vault scores 73.8 percent on LongMemEval QA against the official harness, compared to 63.8 for Zep and 49.0 for Mem0. The one-file posture is doing real work here. Anything that needs Docker and a Postgres instance turns into a deployment negotiation, while a single binary is just a file you copy, which is often the difference between memory a team actually adopts and memory a team keeps meaning to adopt.

Vault exists because of a specific failure its creator, Thomas Connally, wrote about. A 2,000-note Obsidian vault stopped working as agent memory once it got large. Search degraded to unusable, the agent started hallucinating file contents, and context windows filled with irrelevant markdown. The diagnosis was that note-taking apps organize content for people to read, not for machines to retrieve, and that agents need structured machine-readable memory instead of human prose. On that hybrid recall, Vault reports 91.7 percent Recall@1 where keyword-only search managed 4.2 percent. It also does importance weighting, temporal decay, content-aware deduplication, and bi-temporal history, so you can ask what was true and when it was true. Those extras matter more than the list makes them sound. Weighting and decay keep a throwaway note from March from carrying the same force as a standing architectural decision, and dedup stops one fact from being stored twenty times over in slightly different words.

The security and sovereignty posture is where Perseus separates itself from the hosted memory services it competes with. Everything runs on your machine. Records are encrypted with AES-256-GCM at rest, there's an immutable crypto-chained audit journal, and the project advertises zero telemetry, no API keys, and no cloud calls at all. It's MIT licensed rather than GPL or AGPL, which the site points out means no copyleft and no lock-in. There's an SBOM per EO 14028, alignment with the NIST AI RMF, and an EAR99 classification, which together tell you exactly who this is courting, namely regulated, air-gapped, classified, and sovereign deployments that hosted tools can't legally reach. Zero telemetry is also the rare claim that's cheap for a buyer to verify, and the local-first design means there's no service sitting in the middle that could quietly start collecting later on.

It's worth being clear-eyed about the numbers. The benchmarks are measured on named hardware with rerunnable scripts, and the site is unusually careful to distinguish those from its value calculator, which lets you plug in fleet size and model tier to estimate token savings and is explicitly labeled an illustrative economic model rather than a measured result for your workload. That labeling is a good sign in a category where inflated savings claims are routine, though the token-savings framing still excludes output tokens and infrastructure.

Perseus is free and open source under MIT, with both products on GitHub under the Perseus-Computing-LLC organization and the context engine on PyPI. There's no subscription tier and no hosted service to sign up for, because a hosted service would defeat the local-first premise. A provisional patent is pending on the approach. The natural fit is anyone running a fleet of agents where token spend has become a real line item, or anyone who needs durable agent memory inside a boundary that nothing is allowed to leave. If you've watched an agent re-read the same notebook on every call and quietly resented the bill, this is the layer aimed squarely at that.