Sovseal(Lockdrop)

Boby Barack posted an update — May 27, 2026 12:22 PM EDT

Inspiration

We didn't start with a grand vision for AI; we started by scratching our own itch.

While building autonomous AI agents over the last few months, we hit a wall. Every time we wanted our agents to remember context across sessions, we had to send their memory to centralized cloud vector databases like Zep or Mem0.

Watching our own pipelines, we saw three massive problems:

1. The Latency Penalty: Every single memory retrieve took around 500ms over the cloud, completely stalling the agent's prompt loop.
2. The Cost: Running a small fleet of agents with memory cost us $25-$100/month just for hosted vector lookups.
3. The Privacy Block: Claude's safety stack actively flagged and refused to process memory updates when we tried to send sensitive context or API keys to third-party databases.

Cloud-hosted agent memory felt like a design flaw. Latency was killing execution, cost was preventing scaling, and privacy was a blocker. We realized we needed to build a fully local alternative.

---

What it does

We took our battle-tested cryptographic infrastructure and expanded it. Sovseal now provides two distinct, local-first state layers:

1. The AI Context Layer (Local MCP Server)

A Model Context Protocol (MCP) server that gives your AI agents instant, local semantic memory.

• < 10ms Latency: Embeds and recalls agent memories instantly by running the vector math entirely on your machine.
• $0 Server Costs: Because the compute is local, there are no API keys to manage and no monthly bills to pay.
• Safety Aligned: We engineered the prompt framework to be fully transparent, completely bypassing the safety refusals triggered by covert cloud-syncing.

2. The Human Memory Layer (Lockdrop)

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

• Mathematical Guarantees: Media is encrypted with AES-256-GCM before it ever leaves your device.
• Decentralized Persistence: Encrypted payloads live on IPFS via Storacha, with unlock times permanently enforced by Solidity smart contracts on the 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, and Storacha Network.

Key Implementation - Local Embedding & Retrieval

To completely bypass cloud latency, we built the embedding pipeline to run locally within the Node.js runtime.

// 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.

Boby Barack posted an update — May 27, 2026 12:20 PM EDT

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.

Boby Barack started this project — Nov 16, 2025 03:44 PM EST

Leave feedback in the comments!

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