Sovseal(Lockdrop)

Zero-knowledge state permanence for humans, and local-first vector memory (MCP) for AI agents.

Comment

posted an update —

Inspiration (The Mom Test: Anchored to Observed Reality)

We did not start with an aspirational idea. Instead, we spent months building autonomous AI agents and monitoring our developer pipelines. We watched what actually happened when integrating existing agent memory frameworks (like Mem0 or Zep):

  1. The Latency Penalty: Every single semantic memory retrieval took between 450ms and 700ms over cloud APIs. This stalled the agent's prompt loop, creating a sluggish user experience.
  2. The Cost Barrier: Running a small fleet of 10 active agents with cloud memory cost between $25 and $100/month just for hosted vector lookups.
  3. The Security Red Line: Highly confidential developer context, system instructions, and user API keys were being transmitted in plaintext to third-party databases.
  4. Safety Refusals: Direct testing in Claude Desktop proved that the safety stack actively flags and refuses memory updates when framed via covert or third-party cloud-handling APIs.

We realized the core problem: Cloud-hosted agent memory is a design flaw, not a feature. Latency kills agent execution, cost prevents scaling, and privacy concerns are a blocker for enterprise adoption.

We built Sovseal to drive the developer cost, setup latency, and security risk of agent memory to absolute zero.

The Value Equation ($100M Offer Architecture)

We structured Sovseal to maximize value by optimizing the four variables of the Value Equation:

$$\text{Value} = \frac{\text{Dream Outcome} \times \text{Perceived Likelihood of Achievement}}{\text{Time Delay} \times \text{Effort & Sacrifice}}$$

1. The Dream Outcome (What you get)

  • For AI Agents: Permanent, cross-session semantic memory with < 10ms retrieval latency and zero data leakage.
  • For Humans: Cryptographically secure, time-locked media and data vaults that survive even if the developer's servers shut down.

2. Perceived Likelihood of Achievement (The Proof)

  • Zero Third-Party APIs: All vector embedding calculations and database operations run entirely on your local machine.
  • Local Vector Engine: Uses LanceDB (local vector storage) and Transformers.js (on-device MiniLM embeddings) running locally in the Node.js runtime.
  • Verified Codebase: 102 passing automated unit and integration tests validating the cryptographic and local database layers.

3. Time Delay (Setup Speed)

  • Time to value: < 5 seconds.
  • No cloud accounts, no email sign-ups, and no billing setups. You run one command: npx @sovseal/mcp-server

4. Effort & Sacrifice (Cost & Friction)

  • Financial Cost: $0 forever.
  • Operational Friction: Zero API key management. Zero network dependency. Works entirely offline.

What it does

Sovseal provides two distinct, local-first state layers:

Layer A: The AI Context Layer (Local MCP Server)

A high-performance Model Context Protocol (MCP) server that embeds and recalls agent memories instantly.

  • On-Device Math: Compiles your text memory, generates semantic embeddings locally, and queries the database on your hard drive.
  • Transparent Flow: Replaces adversarial or "covert" database write instructions with transparent updates to prevent Claude's safety stack from triggering.
  • Frictionless Integration: Native support for Claude Desktop, Cursor, and custom TypeScript SDK pipelines.

Layer B: The Human Memory Layer (Lockdrop)

A client-side cryptographic vault for time-locking messages and sensitive assets.

  • Client-Side Cryptography: Browser generates a unique AES-256-GCM key. Media is encrypted entirely before leaving your device.
  • Decentralized Persistence: Encrypted payloads are pushed to IPFS via Storacha. Unlock conditions and metadata are permanently enforced via Solidity smart contracts on Polkadot's Passet Hub blockchain.

How we built it

Core Engine Specs:

  • Local Embedding Pipeline: On-device vector math via @xenova/transformers (running the all-MiniLM-L6-v2 model) and @lancedb/lancedb in Node.js.
  • Smart Contract Layer: Solidity 0.8.20 compiled to PolkaVM bytecode, deployed on Passet Hub testnet via pallet-revive (0xeD0fDD2be363590800F86ec8562Dde951654668F).
  • Storage & Web Stack: Next.js 14, Web Crypto API (AES-256-GCM, RSA-OAEP), and Storacha Network (IPFS with UCAN authorization).

Key Implementation - Local Embedding & Retrieval

This code runs entirely on-device, bypassing all external API latency:

// packages/mcp-server/src/local/db.ts
import { connect } from '@lancedb/lancedb';
import { pipeline } from '@xenova/transformers';

export class LocalMemoryStore {
  private db: any;
  private embedder: any;

  async init() {
    this.db = await connect('~/.sovseal/db');
    // Load the embedding model locally into memory (80MB footprint)
    this.embedder = await pipeline('feature-extraction', 'Xenova/all-MiniLM-L6-v2');
  }

  async storeMemory(content: string, metadata: object) {
    const output = await this.embedder(content, { pooling: 'mean', normalize: true });
    const vector = Array.from(output.data);

    const table = await this.db.openTable('agent_memories');
    await table.add([{ vector, content, timestamp: Date.now(), ...metadata }]);
  }
}

Log in or sign up for Devpost to join the conversation.