The problem BrainDance solves

Traditional web2 content-sharing models force creators, KOLs, to distribute static media through centralized platforms. Subscribers consume these materials passively, with no trustless way to verify or interact with them beyond what the platform permits. Moreover, most AI-driven experiences rely on monolithic, often proprietary memory systems (e.g., RAG-based solutions) that are closed off to user control and lack robust privacy mechanisms.
BrainDance changes this dynamic through a memory layer (Mem0) that combines large language models (LLMs) with vector-based storage. Mem0 extracts and processes key information from user interactions, then stores it semantically for efficient retrieval. This enables AI assistants to learn continuously, connecting past context with new user queries for more relevant, adaptive responses.
By encrypting these “memory snapshots” and minting them as ERC1155 tokens, DreamDance gives each user or creator full sovereignty over their data. It taps into Lit Protocol for encryption/decryption management, ensuring that only token holders with valid credentials—validated via Self Protocol to confirm appropriate age and non-sanctioned status—can decrypt the stored memories.
Through DreamDance, creators can share tokenized memories (e.g., knowledge capsules, personal experiences, or AI-trained contexts) with their community. Subscribers, in turn, are not just passive recipients; they can “talk” to these memories via any LLM that supports vector-based retrieval, leading to deeper, AI-facilitated insights. This system overcomes the limits of centralized content hosting by distributing control, monetization, and AI capabilities directly to the participants.

User Interaction and Data Flow

1. Memory Generation & Extraction:
   A user generates content, which is processed through an LLM to extract key details or semantic vectors. This “memory snapshot” is then ready for tokenization.
2. Encryption & Storage:
   The snapshot (along with the vectors) is encrypted via Lit Protocol.
   The encrypted data is uploaded to Arweave for tamper-resistant storage.
3. Token Minting (ERC1155):
   The user mints/batchMint ERC1155 tokens pointing to the encrypted Arweave content. Multiple copies or “editions” can exist for broad distribution, or unique tokens can be minted for highly exclusive memories.
   The token URI references the Arweave link and essential encryption metadata needed for decryption.
4. Compliance Check (self protocol):
   Self Protocol is used to ensure the user meets age requirements and is not from a sanctioned region. This prevents unauthorized or legally restricted content access without revealing sensitive personal data.
5. Ownership & Access:
   Holding the ERC1155 token grants the ability to decrypt the memory snapshot. Lit Protocol enforces access control, re-encrypting or redistributing keys when tokens transfer.
6. AI Interaction:
   Because each memory is vectorized, authorized subscribers can query it through an LLM, effectively “conversing” with the content rather than merely viewing it. This might involve cross-referencing multiple memories, generating new insights, and answering questions.
7. Transfer & Monetization:
   Token owners can trade or gift their ERC1155 tokens on any open marketplace. The new owner automatically acquires decryption rights, ensuring a truly trustless model of content exchange.

The project architecture and development process

Our solution has two main components, 1. BrainDance Console – A user interface for creating, uploading, and consuming tokenized memory snapshots (Python based); and 2. Memory Handler – A module handling encryption, decryption, and access checks via Lit Protocol, Self Protocol, and token ownership (Javascript+ React).
Witht the Memory Handler, users encrypt their data with Lit Protocol and store it on Arweave permanently. They must meet two criteria—an age check (verified through Self Protocol’s zero-knowledge proofs) and specific token ownership—before Lit Protocol releases the decryption key. Once authorized, the data is decrypted locally and can be restored on the BrainDance Console for AI-driven use cases (e.g., reloading into a vector database).

Core Functionality

• Memory Creation & Upload
  BrainDance Console allows users to generate memory snapshot and upload them.
  The Memory Handler encrypts these files and writes them to Arweave.
• Access Control
  Self Protocol validates the user’s age or non-sanctioned status.
  Verification of specific token ownership.
  Lit Protocol enforces both conditions together.
• Data Retrieval & Consumption
  Users who pass both checks download and decrypt the file with Lit Protocol’s keys.
  The decrypted content is then re-ingested or interacted with via AI models.

Key Technologies

• Lit Protocol for policy-driven encryption/decryption.
• Self Protocol for zero-knowledge identity verification (age, sanctions).
• Arweave for permanent, decentralized file storage.
• ERC-20, 721, 1155 contract for token-based access.
• BrainDance Console for creating and consuming memories.
• Memory Handler for orchestrating cryptographic operations and compliance checks.

Product Integrations

Self Protocol (Mobile Client & Playground)
Mobile Client: Used for generating zero-knowledge proofs that confirm a user’s age or compliance with non-sanctioned criteria, all while preserving personal privacy.
Playground: Provides an environment to test these proofs before integrating them into our production flow, ensuring smooth user verification in the BrainDance Console.

Celo Network (Alfajores Testnet)
Our token smart contracts are deployed on the Celo testnet, allowing cost-effective experimentation with token gating and on-chain ownership checks. It ensures fast transactions and low fees while maintaining EVM compatibility.

Lit Protocol SDK
Integrates into the Memory Handler to encrypt and decrypt memory snapshots. The SDK enforces our access control logic, releasing keys only to users who meet both Self Protocol verification and NFT ownership checks.

Mem0 SDK
Powers the AI-driven context layer. It handles vector embeddings and retrieval for our memory snapshots, enabling persistent, contextual recall when users interact with BrainDance.

Lit Testnet
We rely on the Lit Protocol testnet for staging and validating encryption policies. This environment ensures that all Lit-based logic—such as key provisioning and condition checks—functions properly before going live.

DeepSeek API + Qdrant Vector DB
Allows advanced semantic or AI-based indexing for our snapshots. DeepSeek enriches stored memories with deeper contextual search and retrieval capabilities, improving the user’s AI-driven experience.

Key differentiators and uniqueness of the project

DreamDance elevates content sharing into a new frontier of interactive AI experiences. By leveraging Mem0’s memory-centric architecture, creators keep control of their data, subscribers gain meaningful ownership and deeper interactions, and the entire ecosystem benefits from a decentralized, resilient infrastructure built on the principles of Web3.

1. Persistent Context
   Marrying LLMs with vector-based storage, DreamDance ensures AI can maintain a continuous learning arc, recalling previous interactions to enhance future conversations with up-to-date context.
2. Web3 Data Sovereignty
   Encrypted memories live on Arweave and are accessible only to ERC1155 token holders. Creators fully own their content; subscribers verify authenticity and ownership on-chain. Ideally, we would like to use trustable decentralized vectorized storage. The infrastructure is yet to be developed.
3. Granular Subscription Model
   Instead of generic “follows” or “likes,” DreamDance users gain real, on-chain ownership of the KOL’s memory snapshots. This token-based membership fosters deeper engagement and direct creator-subscriber relationships.
4. Enhanced AI Interactions
   Subscribers aren’t limited to static content. They can leverage LLMs to query memories, ask questions, and combine knowledge from different tokens for richer, context-sensitive responses
5. Scalable Multi-Tier Access
   Unlike single-edition NFTs, ERC1155 tokens allow for fractional distribution or tiered releases (e.g., “Limited Edition” memory tokens vs. general-access tokens). Each can reference unique encryption and vectors.
6. Privacy & Compliance
   Lit Protocol handles secure encryption/decryption flows, while Self Protocol safeguards legal and ethical requirements. All of this happens without doxxing user data.
7. Future-Ready Architecture
   We tokenizing the memory rather than the entire AI model—makes it interoperable with a wide range of LLMs and decentralized inference solutions, keeping the door open for ongoing innovation.

Trade-offs and shortcuts while building

During our development phase, we made several key decisions and quick compromises to ensure functionality under tight deadlines:

Generic Self-Protocol Integration

• We opted to invoke Self Protocol from our off-chain logic rather than implementing a fully customized, on-chain verification workflow. This simplified development but introduces reliance on off-chain calls.
• Planned Improvement: We aim to create a dedicated smart contract on the Celo network that directly interfaces with Self Protocol for on-chain verifications, reducing the need for intermediate steps.

Minimal Arweave Logic Without Proxy Re-Encryption

• We initially stored encrypted snapshots on Arweave in a straightforward manner. However, we recognized that proxy re-encryption could grant granular re-encryption capabilities when ownership changes or policies update.
• Planned Improvement: Implement proxy re-encryption to allow dynamic access revocation or delegation without needing to re-upload content.

Centralized Vector DB Storage

• Due to time constraints, our user embeddings and vector index were partly managed off-chain for faster prototyping.
• Planned Improvement: We want to encrypt user vector DBs on-chain where feasible, or explore decentralized storage solutions that seamlessly integrate with Mem0 while preserving performance.

Overall, these choices allowed us to demonstrate a functioning proof of concept. With more time, we plan to refine the architecture for stronger on-chain verification, dynamic encryption controls, and fully decentralized vector storage.

Additional Features

Everything was built during the hackathon