Synapse — Persistent, Decentralized Memory for Autonomous Agents

Problem Statement

AI coding assistants and autonomous agents are powerful but stateless. Every time you switch tools or open a new session, the assistant has no memory of what a previous session already figured out — the architecture, the SDK quirks, the bugs that were already fixed. That context has to be re-explained by hand, over and over, effectively making the human act as an external memory layer for the agent.

More broadly, agents are fragmented across sessions and unable to build on what they've already learned. Scaling context by stuffing more into the prompt window doesn't solve this — it doesn't give an agent a permanent, decentralized place to write what it learns and recall it before its next decision.

Solution

Synapse gives autonomous agents a permanent, decentralized memory they can write to and recall from, so they get smarter over time without needing a bigger context window.

An agent with a funded Sui wallet runs on a loop:

1. Recall memory
2. Evaluate marketplace listings
3. Buy on-chain
4. Decrypt via Seal
5. Extract insights with Gemini
6. Write semantic embeddings back to Walrus via MemWal

Sellers encrypt datasets, store them on Walrus, and list them on-chain for SUI. Large datasets get distilled into memory rather than stuffed into prompts — its unique value is a genuinely persistent, decentralized, and verifiable memory loop, rather than session-scoped retrieval or simulated recall.

Tech Stack

Sui Move (contracts), Walrus (storage), Seal (access control), MemWal (embeddings/semantic search), Gemini, Node.js/TypeScript/Express backend, React/Vite/Tailwind frontend, SQLite, Docker

Key Challenges

• Fast-moving SDKs (Sui, MemWal) required reading actual type definitions/quickstarts rather than relying on assumptions.
• Caught and fixed a centralization flaw: server-side signing was replaced with seller-side wallet signing to preserve real on-chain ownership.
• Handled infra flakiness (faucet limits, DNS issues, Walrus resolution failures) with graceful degradation (e.g., keyword-based fallback evaluation).
• Notably refused an AI assistant's suggestion to fake a successful download for demo purposes.

Proud Of

• A genuinely real (non-simulated) memory loop
• Trust model where sellers sign their own listings
• Graceful degradation instead of crashes
• Catching the "fake success" shortcut before shipping

Lessons Learned

• Persistent agent memory differs fundamentally from session-scoped retrieval (needs namespace isolation, redundancy detection)
• Transaction signing is a trust-model decision, not just an implementation detail
• AI assistant claims of success need verification against ground truth, just like a human's would

What's Next

• Cross-agent shared memory namespaces
• A plug-in version of the memory layer for other agent frameworks
• Mainnet deployment, better Seal access policies, flexible pricing (per-query/subscription)
• A memory inspector UI for auditing/pruning what an agent knows

Built With

• sui