Memport
Memport / Technical Docs

Portable AI Memory + Executable Experience

Memport
Architecture.

Encrypted memory, content-addressed storage, onchain ownership, portable mental models, and task-conditioned execution.

Memport separates persistent source data from the intelligence derived from it. Memories preserve source history. SHARDs compile accumulated experience. RICE applies that experience to a task. MCP exposes the resulting system to compatible models and agents.

Store Own Compile Execute
02Storage / Memory Banks

Encrypted.
Content
addressed.

Memport stores portable memory as encrypted data referenced by content identifiers rather than conventional application-owned database rows.

Source material is encrypted before persistence to IPFS. IPFS returns a CID derived from the stored content. Memport uses that content-addressed object as the portable storage primitive while Base records the current root associated with the owner's Memory Bank.

Encrypted

IPFS

CID addressed

Base anchored

01

Source

Conversation, file, note, research, or agent history.

02

Encrypt

Payload is encrypted before decentralized persistence.

03

IPFS

Encrypted payload is pinned and addressed by CID.

04

Memory Bank

Latest portable memory root is anchored to the owner on Base.

Encrypted payload IPFS CID Memory root Base Memory Bank

03SHARD Architecture

Experience Representation

Memory
→ SHARD.

A SHARD is Memport's portable representation of accumulated experience.

Instead of reproducing the original source corpus, SHARD generation extracts reusable mental models produced by that history: strategies, corrections, causal reasoning, preferences, failures, boundaries, operating patterns, and learned judgment.

Source corpus.
Extracted experience.
Portable mental model.

A transcript records what happened. A SHARD attempts to preserve what that history changed about future decisions.

SHARDs are consumed as reasoning input,
not simply retrieved as reference text.

01

Extract

Identify reusable experience from the source corpus.

02

Conserve

Preserve causal mechanisms, corrections, and decision-changing lessons.

03

Package

Produce a portable SHARD with provenance and structure.

04

Apply

Use RICE to condition the SHARD against a live task.

04Memport Agent / Agentic Economy

Experience Interface

Capabilities
+ Experience.

Agents already have models, tools, and skills. Memport adds an experience layer. The Memport Agent is the agent-facing interface for discovering, authorizing, and applying SHARDs so an existing agent can execute through a selected mental model without replacing its underlying capabilities.

Agent + Capabilities + Authorized ExperienceAgent Layer / In Development

Agent Execution Path

Augment the agent.
Keep its capabilities.

A SHARD does not need to replace a specialized agent or its tooling. It can change how that agent plans, directs tools, evaluates output, requests revisions, and decides what to do next.

01

Task received

The agent receives a job with its existing model, tools, skills, and execution environment.

02

Experience selected

A SHARD is installed, owned, or temporarily authorized for the task.

03

Access verified

Memport verifies that the caller is authorized to use the selected SHARD.

04

RICE applied

The SHARD is interpreted against the live task and compiled into executable strategy.

05

Capabilities used

The agent applies its existing skills and tools through the selected mental model.

06

Work executed

The agent performs the job with task-specific access to accumulated experience.

Skills expand what an agent can do.
SHARDs can change how it decides to do it.

06RICE / Execution Framework

Retrieve → Interpret → Compile → Execute

Context is not
execution.

RICE is Memport's execution framework for getting an AI system to apply accumulated experience while performing a task.

It exists because supplying relevant experience to a model does not guarantee that the model will behave according to that experience. Retrieval can succeed while execution still collapses into generic model behavior.

Retrieval Problem

Context

Relevant
does not mean
applied.

A model can receive the correct source material and still weaken its lessons, ignore positive strategy, over-prioritize constraints, compress away causal reasoning, or fall back to generic behavior during generation.

RICE Objective

Behavior

Preserve
behavioral
consequence.

RICE introduces explicit stages between retrieval and final generation so the system can determine applicability, preserve causal mechanisms, compile usable strategy, and execute the task from that strategy.

Framework stages

RRICE

Retrieve

Establish the experience scope that may materially affect the task. Retrieval controls admission, not final applicability.

IRICE

Interpret

Evaluate admitted experience against the live task. Preserve applicable lessons, causal mechanisms, source modality, and missing dependencies without prematurely merging them.

CRICE

Compile

Transform interpreted experience into the strategy an experienced operator would have known to give the model, separating strategy, requirements, available facts, and hard boundaries.

ERICE

Execute

Perform the task once from the compiled execution context. Execution should consume the strategy rather than reconstruct the SHARD or reinterpret the framework.

RAG vs RICE

Traditional RAG

Knowledge Retrieval

Retrieve
context.

Retrieval-Augmented Generation retrieves information relevant to a query and supplies it to the model as additional context before generation. This is effective when the primary problem is access to external knowledge.

Query Retrieve documents Add context Generate

Memport RICE

Task Execution

Compile
behavior.

RICE is designed for a different problem: making accumulated experience operational. Retrieved experience is interpreted against the task, conserved through intermediate stages, compiled into executable strategy, and then used to perform the job.

Task + SHARD Retrieve Interpret Compile Execute

Admission

Whether an experience receives an opportunity to influence interpretation.

Applicability

Whether that experience materially changes how the current task should be approached after the model has examined both.

Conservation

Whether the lesson survives the pipeline without losing the causal mechanism or behavioral force that made it useful.

Interpret invariant

Missing execution inputs should not erase an otherwise applicable strategy.

Applicability and executability are separate. Interpret can preserve a strategy while recording the dependency required to instantiate it.

Compile invariant

Compile experience into executable behavior without destroying its causal mechanism.

Positive strategy generates behavior. Requirements and hard boundaries constrain it. They are represented separately so defensive instructions do not overwrite the strategy itself.

RICE design objective: preserve the behavioral consequence of relevant experience from source → interpretation → compilation → execution.

07MCP / Interface Layer

Portable
execution
interface.

MCP exposes Memport's experience layer to compatible AI runtimes.

The consuming agent does not need to understand Memport's storage format, IPFS topology, SHARD packaging, or RICE internals. Memport can resolve authorization and expose the experience the caller is permitted to apply.

01

AGENT

Requests task execution

02

MCP

Memport interface

03

RICE

Applies SHARD experience

04

OUTPUT

Task result

Storage and ownership remain independent from the model consuming them.

08$MEM / SHARD Economy

Proposed Protocol Economy

Own
or access
experience.

Memport separates permanent SHARD acquisition from temporary task-scoped access.

Humans may want to permanently acquire a mental model. Autonomous agents may only need the same experience for one job. These are separate economic actions.

Own

Marketplace

Persistent
access.

Acquire a SHARD through the Memport marketplace for persistent licensed access. The SHARD becomes part of the owner's authorized experience library.

Settlement

USDC

Persistent
license

Access

$MEM

Task-scoped
experience.

An agent may need a mental model for one job without acquiring the underlying SHARD permanently. $MEM is being explored as the native coordination layer around task-scoped SHARD access and the broader experience economy.

Proposed protocol asset

$MEM

Agent
consumption

$MEM mechanics are not finalized. The architectural distinction is persistent ownership versus task-scoped access.

Ownership ≠ Usage

09Data / Intelligence Layers

Source data
stays separate.

Memories, Memory Packs, Memory Banks, and SHARDs are different objects with different responsibilities.

Memory

An encrypted source unit preserved as portable user-owned history.

Memory Pack

An organized collection of Memories assembled around a project, domain, or continuity context.

Memory Bank

The owner-level root that points to the current state of portable memory.

SHARD

A derived portable mental model built from accumulated source experience.

The Memory Bank preserves the history.
The SHARD preserves what was learned from it.

10System Architecture

End-to-end
data flow.

Storage, ownership, derived intelligence, authorization, and execution remain separate layers.

Core data path

01

Source

AI conversations · files · notes · research · agent history

02

Encryption

Source payload encrypted before decentralized persistence

03

IPFS

Encrypted content persisted and addressed by CID

04

Memory Bank

Latest portable memory root associated with owner on Base

05

SHARD Generation

Source experience compiled into a portable mental model

06

RICE

Retrieve · Interpret · Compile · Execute

07

MCP

Experience layer exposed to compatible AI runtimes

08

Agent

Task executed through authorized SHARD experience

Separation of concerns

Memport Protocol

01

Storage

Encrypted IPFS objects and content identifiers

02

Ownership

Memory Bank state and SHARD access rights

03

Intelligence

SHARD representation and RICE execution

04

Interface

MCP and agent-facing access

Agent consumption path

Experience as a resource

01

Agent

Receives a job using its existing capabilities

02

SHARD

Authorized mental model selected for the task

03

RICE + MCP

Experience compiled and delivered into execution

04

Work

Agent performs the job through the applied experience

Proposed economic path

Token design in progress

01

Creator

Packages accumulated experience into a SHARD

02

SHARD

Portable licensed mental model

03

$MEM

Proposed coordination layer around SHARD usage

04

Consumer

Human or agent acquires authorized access

11Implementation Status

Current
system
state.

Memport is under active development.

Storage, memory ownership, SHARD generation, and RICE are being developed and validated before the full SHARD market, agent access layer, and protocol economy are finalized.

Implemented / Active Development

AI conversation capture
Encrypted Memory payloads
IPFS persistence
CID-based storage
Memory Banks
Memory Packs
SHARD generation pipeline
RICE execution framework
MCP integration

Protocol Expansion

SHARD marketplace
Task-scoped SHARD access
$MEM protocol mechanics
Agent-to-SHARD commerce
External agent interoperability
Creator economics
Memport Agent

Architecture documented here reflects the current Memport design. Protocol interfaces and economic mechanics may change during testing.