AIOZ Storage Super Intelligence Memory: Record and Recall

AIOZ Storage Super Intelligence Memory gives AI agents long-term memory through two calls: Record saves a statement, Recall retrieves it later by meaning rather than by exact wording. AIOZ's own documentation puts the core idea plainly: "you save short statements in plain language with Record, and later ask questions in plain language with Recall." No embedding model to pick, no vector index to configure, no dimension or distance metric to set up first, a memory bucket and the two calls are the entire surface. This article covers what the feature actually does, its full request and response shape, how it differs from AIOZ Storage's general-purpose vector database underneath it, and what it costs.

TL;DR:

• Two calls: Record saves a statement and returns a memoryId, Recall takes a question and returns saved statements ranked by similarity.
• AIOZ's documentation states plainly "you do not create embeddings, vector indexes, or vectors yourself," embedding happens automatically inside the feature.
• Memory runs on a memory-managed vector bucket, a bucket dedicated to memory operations, where AIOZ states "regular PutVectors and DeleteVectors calls on it are rejected."
• Pricing layers a flat per-call memory fee on top of AIOZ's existing vector database rates: $0.00005 per Record or Recall call, plus $0.04 per GB uploaded, $0.05 per GB-month stored, and $0.000002 per query.

What Super Intelligence Memory Actually Does

Building AI agent memory the conventional way means picking an embedding model, standing up a vector store, writing logic to decide what's worth keeping, and building a way to search it back out later. Super Intelligence Memory collapses that into two operations. Record takes a statement, for example "Deploys are frozen in December," and stores it. Recall takes a question, like "When can't we ship?", and returns the statements that match it by meaning, not by shared keywords. AIOZ's documentation is specific about where the usual setup work goes: "the first Record in a bucket creates the memory index for you automatically." There's no separate index-creation step before the first write.

Built on AIOZ Storage's Vector Database, Not a Separate Product

Super Intelligence Memory isn't a standalone service bolted on the side. It runs on top of AIOZ Storage's vector database feature, using a specific kind of bucket: a memory-managed vector bucket, created by setting memoryManaged to true when the bucket is made. AIOZ's documentation draws a hard line around what that bucket type is for: "a memory-managed bucket is dedicated to memory. Regular PutVectors and DeleteVectors calls on it are rejected." So a memory bucket can't be repurposed as a general vector store, and a general vector bucket can't be used for memory, the two are separate bucket types built on the same underlying vector-database engine.

That split also explains the one meaningful gap between the two layers. AIOZ Storage's general vector database documentation describes a workflow where "your documents are split into chunks and sent through an embedding model" before storage, meaning the caller supplies the embeddings. Memory-managed buckets skip that step entirely: AIOZ states "you do not create embeddings, vector indexes, or vectors yourself" for Record and Recall. Text goes in as plain statements and questions, and the embedding happens inside the feature automatically.

The Record and Recall API

Both operations are POST requests against https://vector-api.aiozstorage.network, in the us-east-1 region, signed with AWS Signature Version 4 under the service name s3vectors, the same signing protocol AWS uses to verify a request's identity and reject anything tampered with in transit or replayed more than five minutes after its timestamp. Record takes two fields:

and returns a memoryId and a createdAt Unix timestamp. Recall takes a question instead of a statement, plus two optional fields:

The response includes a found boolean and a results array, each entry carrying the original memoryId, the saved statement, a similarity score (higher means closer), and, if requested, a distance value defined as 1 - similarity. That's the same cosine-distance approach vector search generally uses to rank nearest neighbors, AWS describes it as applying "a distance function like cosine to rank results by similarity."

from super_intelligence_memory import Client

memory = Client(access_key_id=..., secret_access_key=...)

memory.record(vector_bucket_name="my-memory-bucket",
              statement="Deploys are frozen in December.")

result = memory.recall(vector_bucket_name="my-memory-bucket",
                        question="When can't we ship?",
                        limit=3)
# result.found -> True
# result.results[0].statement -> "Deploys are frozen in December."

Behavior Worth Knowing Before You Rely on It

A few details in AIOZ's documentation matter more than they might look at first glance. Recall doesn't filter out weak matches: if the bucket has any memories at all, a query returns up to limit results, even when none of them actually answers the question. The similarity score is what tells you whether a result is a real match or just the least-bad option in an otherwise empty bucket, so checking it matters more than checking found.

Writes aren't deduplicated either. AIOZ states "every successful Record creates a new memory with a new memoryId. If you send the same statement twice, you store it twice," and specifically because of that, "the SDKs do not retry Record requests automatically," to avoid a network retry silently duplicating a memory. And a Recall with genuinely nothing to match still returns a normal 200 OK with found: false, not an error, since an empty result is a valid outcome, not a failure.

Error Handling

Errors come back as JSON with a __type field naming the error class:

{
  "__type": "ValidationException",
  "message": "limit must be between 1 and 100"
}

Access itself runs through the same macaroon-based access grants as the rest of AIOZ Storage: an access key ID and secret access key created in the dashboard, then used to sign every request.

SDKs

Official clients exist for three languages, each generated to work directly against the Record/Recall API:

go get github.com/AIOZStorage/super-intelligence-memory-go     # Go 1.25+, package "superintelligencememory"
npm install @aiozstorage/super-intelligence-memory              # JavaScript/TypeScript
pip install super-intelligence-memory                            # Python 3.10+, import as super_intelligence_memory

What It Costs

AIOZ's billing documentation layers memory pricing directly on top of the existing vector-database rates, rather than pricing memory as a separate product:

• Memory operation fee: $0.00005 per Record or Recall call, in addition to the vector fees below
• Vector upload: $0.04 per GB uploaded
• Vector storage: $0.05 per GB-month, charged hourly
• Query: $0.000002 per query
• Data returned: $0.01 per GB, with the first 512 KB per query free
• Data searched: tiered from $0.0000028 down to $0.0000002 per GB, depending on how many vectors are in the index

That structure means a Record call is billed for both the flat memory fee and the underlying vector upload and storage it triggers, and a Recall call is billed for the memory fee plus the query and data-searched costs. There's no separate free tier or bundled monthly plan described for memory specifically, it follows the same pay-as-you-go shape as the rest of AIOZ Storage's billing.

Frequently Asked Questions

What is AIOZ Storage Super Intelligence Memory?
A feature that gives AI agents long-term memory through two calls: Record saves a statement in plain language, and Recall retrieves saved statements that match a question by meaning, without the caller managing embeddings or a vector index directly.

How is Super Intelligence Memory different from AIOZ Storage's vector database?
It runs on top of the vector database, using a memory-managed bucket type that automatically generates embeddings for you. AIOZ's general vector database requires the caller to generate embeddings and send vectors directly; memory-managed buckets don't accept those raw vector operations at all.

Does Recall filter out bad matches?
No. If the bucket has any memories, Recall returns up to limit results regardless of how relevant they are, so check the similarity score on each result rather than assuming every returned statement is a real answer.

What happens if I call Record with the same statement twice?
It's stored twice, as two separate memories with different memoryId values. AIOZ Storage doesn't deduplicate Record calls, which is also why the SDKs don't automatically retry a failed Record request.

What is the maximum length for a statement or question?
32 KB (32,768 bytes) for both the statement field in Record and the question field in Recall.

What does Super Intelligence Memory cost?
A flat $0.00005 per Record or Recall call, on top of AIOZ's existing vector database rates: $0.04 per GB uploaded, $0.05 per GB-month stored, and $0.000002 per query, with the first 512 KB of data returned per query free.

What SDKs are available for Super Intelligence Memory?
Official clients for Go, JavaScript/TypeScript, and Python, each installable from their standard package managers and built directly against the Record and Recall API.

Related Reading

• AIOZ Storage Access Control: Macaroons and Access Grants - the access-key and signing model Super Intelligence Memory authenticates every request with.
• What Is Retrieval-Augmented Generation (RAG)? Explained - the broader pattern of grounding an LLM's answer in retrieved content, one of the use cases memory serves.
• What Is an Embedding Model? How AI Turns Text Into Vectors - the underlying mechanism Super Intelligence Memory runs automatically so callers don't have to.
• What Is MCP Server? AI Agent Storage Access Explained - a different AI-agent integration path into AIOZ Storage, tool-calling rather than a direct memory API.
• How AIOZ Storage Pricing Works - the general object-storage pricing model Super Intelligence Memory's billing sits alongside.
• AIOZ Storage Developer Platform: SDKs, CLI, and Migration Guides - the rest of AIOZ Storage's SDK ecosystem Super Intelligence Memory's clients join.
• Vector Database vs Agent Memory on AIOZ Storage: A Guide - when to use the vector database and when to use Memory.
• AIOZ Storage llms.txt: Docs Built for Super Intelligence - the machine-readable docs files AIOZ publishes for coding assistants and retrieval tools.

References

• AIOZ Storage Docs: Super Intelligence Memory
• AIOZ Storage Docs: Vector Database Cost, Use Cases and Next Steps
• AIOZ Storage Docs: Billing
• AWS: What Is a Vector Database?
• AWS: Signature Version 4 for API Requests