Agent Memory

The open benchmark for agent memory

Agent Memory Leaderboard

Measure what your agents remember.
Compare what truly matters.

Agent Memory Leaderboard
OPEN BENCHMARK

Agent Memory Leaderboard

A public benchmark space for comparing textual, multimodal, and coding-agent memory systems under a consistent evaluation flow.

Leaderboard Preview

Benchmark Tracks

Each track keeps its own result table and detailed metric breakdown.

Textual Memory

Long-context, persona, script, and conversation-memory benchmarks.

Multimodal Memory

Memory retrieval and generation over image-rich or multimodal tasks.

Coding Agent Memory

Agent memory support for coding tasks and repository-context recall.

Evaluation Flow

Industry systems use the hosted Add/Search key flow. Academic systems may use the same flow or submit a public GitHub repository for maintainer Docker deployment.

1

Choose an evaluation route

Provide hosted Add/Search APIs, or submit a public GitHub repository with Docker and API run instructions.

2

Run a smoke test

Use the issued key to verify the synchronous Add/Search flow.

3

Submit a formal evaluation

After smoke passes, select an evaluation mode and submit a scored run.

Explore the Platform

Use the product pages to inspect rankings, run evaluations, and prepare an integration.

01

Leaderboard

Public ranking with filters, dataset columns, and score bars.

02

Evaluation

Create eval jobs, watch progress, and inspect private results.

03

Documentation

User guide, evaluation workflow, API contract, security, and result publication.

04

Guide

Add/search API contract, request fields, polling, and response schemas.

PUBLIC RANKINGS

Agent Memory Leaderboard

Public rankings are separated by track. Use the selector inside the leaderboard frame to switch tables without mixing metric dimensions.

Leaderboard

PUBLIC RANKINGS

Agent Memory Leaderboard

Public rankings are separated by track. Use the selector inside the leaderboard frame to switch tables without mixing metric dimensions.

Leaderboard

PUBLIC RANKINGS

Agent Memory Leaderboard

Public rankings are separated by track. Use the selector inside the leaderboard frame to switch tables without mixing metric dimensions.

Leaderboard

EVALUATION

Run Evaluations

Create API-gated eval jobs against the Leaderboard Suite, monitor task progress, inspect private results, and submit eligible full-suite runs for administrator review.

Create Eval Job

Choose a bound version. Use Run label to distinguish repeated evaluations of the same version.

Datasets

Current Job

Live job status and progress.

No job yet.

Private Results

Private scores stay scoped to the current leaderboard key. Admin runs remain separate from external review candidates.

PUBLICATION RULES

Rules

The public leaderboard only accepts verified full-suite results. Smoke, light, failed, partial, and dataset-subset runs remain private.

Public Submission Eligibility

A private result can be promoted to the public board only when every check passes.

Full Benchmark Run

Only full-mode runs can be submitted to the public leaderboard.

Exact Public Dataset Suite

Selected datasets must match the current public suite.

Run Completed Successfully

The job and every evaluation task must finish successfully.

Result Ownership Verified

Result ownership is verified. External full-suite results can be published only after administrator approval.

Not Submitted Before

A private result can be promoted once to avoid duplicate rows.

Evaluation Modes

Mode controls what the run is allowed to do after scoring.

smoke

Compatibility Check

The separate integration-test endpoint verifies API binding and the Add/Search flow. External formal evaluation keys do not submit smoke jobs.

light

Faster Internal Validation

Reduced suite for iteration and debugging. Results stay private. For external keys, light and full have separate 30-day cooldowns, so a light run does not delay the next full run.

full

Public-Board Candidate

Full benchmark suite. A successful full run may be submitted when ownership and review checks pass.

Submission Flow

1

Prepare the submission

Write a complete README and run guide, including the Docker command, API wrapper, original work disclosure, and method changes.

2

Submit code or API

Provide a public GitHub repository for platform deployment, or a conformant Add/Search endpoint for a hosted submission.

3

Platform review and smoke

We review the source and disclosures, start code submissions from the documented Docker entrypoint, then verify the API with smoke.

4

Start Full Eval

Complete every checklist item before launching the full benchmark run.

5

Review and publish

Successful full results enter administrator review before appearing on the public board.

Integrity and eligibility

Disclosure

Reused papers, repositories, and code must identify the original authors, technical report, and all method changes. Undisclosed reuse may be treated as plagiarism.

Disqualification

Repeated near-duplicate or low-quality submissions, prompt injection, benchmark leakage, result manipulation, malicious behavior, and other leaderboard abuse may cancel eligibility. For deployed endpoints, public availability and stability are required for 30 days after submission.

OFFICIAL DOCUMENTATION

User Documentation

Learn how to integrate Add / Search, run consistent evaluations, review results, and publish eligible runs to the public leaderboard.

01

OVERVIEW

How the platform works

Agent Memory Leaderboard compares memory systems under a consistent end-to-end evaluation. The platform does not prescribe a database, index, embedding model, or internal architecture. It requires a conformant external API and verifiable evidence for retrieval and audit.

1

Ingest evaluation memory

The platform calls Add by sample and source session.

2

Manage memory

Your system persists, organizes, indexes, and updates memory.

3

Retrieve candidates

The platform calls Search per question and receives ranked results.

4

Answer and score

A fixed platform workflow generates answers, scores them, and aggregates results.

Fairness boundary

Participant-controlled behavior is limited to Add / Search. The platform locks the answer model, prompts, evaluators, dataset suite, Top K, and aggregation rules so that score differences primarily reflect the memory system.

02

WHO THIS IS FOR

Audience

LEADERBOARD READERS

Read without signing in

Review Overall scores, metric breakdowns, system versions, and publication dates within the Textual, Multimodal, or Coding track. Each track has a distinct task and metric contract; scores are not comparable across tracks.

EVALUATION PARTICIPANTS

Integrate against the contract and participate

Implement Add / Search → submit an access request → receive an API Key → run public smoke → select an evaluation mode → review private results → enter public review.

03

PARTICIPATION WORKFLOW

Evaluation workflow

Industry submissions and academic systems with hosted APIs follow the existing review, Key issuance, and public smoke flow. Code submissions must include a complete README, Docker startup command, API wrapper instructions, and original-method disclosure; maintainers build and start the documented entrypoint before evaluation. Hosted endpoints must remain publicly reachable and stable for at least 30 days after submission.

  1. 01

    Submit the access request

    Industry requests provide Add / Search endpoints. Code submissions provide a publicly accessible GitHub repository and explain the Docker command, API wrapper, original authors, technical report, and every method change.

  2. 02

    Complete key binding

    Approval either issues a new Leaderboard API Key or binds the submitted version to the verified existing key without administrator re-entry.

  3. 03

    Platform deployment and public smoke

    For code submissions, maintainers build and start the documented Docker entrypoint and expose the official API. Hosted submissions are checked at the declared endpoint. The platform then runs the synchronous Add → Search → Answer → Evaluate smoke flow.

  4. 04

    Complete the Full gate

    Before selecting full, confirm the interactive checklist: smoke passed, API contract followed, run instructions complete, hosted runtime stable for 30 days, original work disclosed, and no integrity violations.

  5. 05

    Start the job

    Verify the API Key on the Evaluation page, select a bound version and mode, assign a unique Run Label, and submit. Formal jobs use the fixed suite and platform Top K.

  6. 06

    Monitor progress and audit status

    The job proceeds through ingestion, retrieval, answering, scoring, and aggregation. The interface reports stage, progress, and error summaries while the platform retains evidence required for review.

  7. 07

    Review results and publication status

    Results are initially visible only to the bound API Key. A successful full job enters the public-eligibility gate and review queue; approval creates a public submission.

Code review and disqualification

Reproductions of papers or existing repositories are allowed only with full attribution to the original authors, technical report, and all method changes. Undisclosed reuse may be treated as plagiarism. When duplicate code is discovered, the platform prioritizes the participant's first disclosed submission. Repeated near-duplicate or low-quality code, prompt injection, benchmark or result manipulation, malicious behavior, and other leaderboard abuse may cancel eligibility.

04

EVALUATION MODES

Evaluation modes and standard quotas

ModePurposeStandard quotaVisibilityPublic eligibility
smokeSeparate integration endpoint for synchronous Add, Search, and scoring compatibility.1 per hourPrivateNot eligible
lightFast internal performance validation for an iterating version.1 per monthPrivateNot eligible
fullFixed complete benchmark suite with formal queueing, audit, and release workflow.1 every 3 monthsPrivate firstEligible after approval
How to choose

Use the separate compatibility smoke after initial integration or an API behavior change, light for performance checks, and full only for a version ready for publication.

05

ADD / SEARCH CONTRACT

Add / Search integration contract

Participants configure the Add and Search URLs; request and response schemas are fixed and do not vary by path. Endpoints must be reachable from the platform network, and production deployments should use HTTPS. URLs must not embed credentials or resolve to private, loopback, or link-local addresses.

Write protocol

Synchronous

Add succeeds only with HTTP 200 after persistence

Formal Top K

100

The platform reads at most top_k items in response order

Retrieval scope

user_id

Add and Search must use the identical isolation boundary

Authentication and Health

Add / Search support Token, Bearer, and X-Api-Key; none is limited to public smoke. Health is an unauthenticated GET where any 2xx means healthy. If no custom Health URL is bound, formal jobs check /health on the Add origin.

POST

Add Request

Each source session uses one Add by default. Sessions over 20 messages or 2,000 words split at the nearest complete message or sentence boundary. Requests contain only fields declared by the synchronous contract.

{
  "request_id": "eval:run_abc123:locomo_refined:conv-0:chunk-0",
  "messages": [{
    "role": "user",
    "timestamp": 1704067200000,
    "content": "memory text"
  }],
  "user_id": "eval:run_abc123:locomo:conv-0",
  "session_id": "eval:run_abc123:sample:0"
}
request_id

Required. Unique identifier for this chunk request; the success response must echo it exactly.

messages

Required ordered array. Each item includes role and non-empty content; timestamp is an optional Unix-millisecond event time.

user_id

Required. The sole retrieval-isolation field; Search must use the identical value.

session_id

Required. Identifies the source session and may be used for grouping, but is not a Search filter.

Fields not sent

The current contract omits metadata, app_id, agent_id, and async_mode. Synchronous behavior is guaranteed by returning HTTP 200 only after Add completes.

200

Add Response

Return success only after the write is persisted and immediately searchable.

HTTP 200
{
  "success": true,
  "request_id": "eval:run_abc123:locomo_refined:conv-0:chunk-0",
  "user_id": "eval:run_abc123:locomo:conv-0",
  "session_id": "eval:run_abc123:sample:0"
}
success

Required and must be the boolean value true.

request_id / user_id / session_id

All are required and must match the request byte for byte.

Synchronous completion

Internal work may be asynchronous, but the endpoint must wait for completion before responding.

Not supported

Do not return HTTP 202, a task ID, or a status-poll URL. The response does not need memory_ids.

POST

Search Request

After every Add succeeds, the platform sends one Search request per question. The query stays in its original language; choice questions include options separately.

{
  "query": "Which answer best matches the memory?",
  "options": ["A. First answer", "B. Second answer"],
  "user_id": "eval:run_abc123:locomo:conv-0",
  "top_k": 100
}
query

Required. Use the original text for retrieval; do not replace it with a final answer or use benchmark gold data.

options

Optional. A string array sent for questions with answer choices; omitted for open questions.

user_id

Required. Retrieve only from memory stored under this exact value.

top_k

Required. The response must not exceed this number; formal external evaluations use 100.

Fixed schema

The current contract does not send filters, rerank, or keyword_search.

200

Search Response

Return a JSON object whose data field is a relevance-ordered array. Return an empty array when nothing is found.

{
  "data": [{
      "id": "mem_1",
      "content": "remembered fact text",
      "score": 0.87,
      "created_at": "2026-07-01T12:00:00Z"
  }]
}
data

Required array. Do not add an items wrapper or return a top-level array.

id

Required non-empty string that stably identifies the memory.

content

Required non-empty string passed directly to the platform Answer model.

score

Optional number. Higher values should indicate greater relevance.

created_at

Optional source or persistence timestamp.

Other fields

The platform reads only the declared fields above; undeclared fields such as metadata are ignored.

Order and count: the platform preserves participant response order and reads at most the requested top_k. Rank results before returning them.
06

ERROR HANDLING

Error reference

Participant endpoints should use standard HTTP status codes and return actionable errors without secrets. Platform business errors normally use {"detail":{"reason":"..."}}; HTTP 422 provides structured field-validation details.

HTTPClassTypical casePlatform behavior and action
400 / 422Contract errorAn Add / Search request cannot be parsed, or a success response has missing or invalid required fields.Not retried. Correct the schema using the error details, then rerun smoke.
401Authentication failureThe Memory System Key is invalid, or the Authorization / X-Api-Key scheme does not match.Not retried. Verify the authentication scheme and secret bound to the request.
403Access deniedThe key cannot call the endpoint, or the service rejects the current user_id scope.Not retried. Review endpoint authorization and retrieval isolation.
404Resource not foundAn endpoint path is wrong, or a platform test, job, or result ID is invalid.Verify the URL or resource ID. The synchronous contract has no Add Status polling.
409State conflictAdd is temporarily conflicted, or a platform job is active and the Run Label is duplicated.Add is retried with bounds; Search 409 is not retried. Wait or choose a new Run Label for platform conflicts.
408 / 425Transient unavailabilityThe request timed out or the service is not ready.Add and Search are retried with bounded backoff.
429Rate or quota limitThe participant endpoint is capacity-limited, or a platform evaluation quota has not reset.Endpoint calls are retried with bounds; for platform quotas, wait until the displayed availability time.
500 / 502 / 503 / 504Transient service failureThe participant endpoint, gateway, or upstream dependency is temporarily unavailable.The platform retries with backoff. Preserve the Job/Test ID and timestamp if failures persist.
Bounded automatic retries

Add retries 408, 409, 425, 429, 500, 502, 503, and 504. Search retries the same set except 409. Network timeouts and transport failures are also eligible.

Contract errors stop immediately

Even with HTTP 200, the stage fails if Add omits success=true or mis-echoes an ID, or if Search omits the data array or an item lacks id / content.

07

DATA, SECURITY & PRIVACY

Data, security, and privacy

01

Minimum necessary data

Participant endpoints receive only the memory chunks, user/session identifiers, and retrieval questions needed for the current job. Gold answers, scoring criteria, and bulk dataset downloads are not provided.

02

Strict retrieval isolation

user_id is the sole Search-isolation field and must match exactly during storage and retrieval. session_id is only for source-session organization. Cross-user_id retrieval is prohibited.

03

Secret protection

The Memory System Key is submitted through a controlled request flow and stored encrypted; job metadata contains only an opaque reference. Secrets do not appear in email, public rankings, or public API responses.

04

Endpoint security

The platform connects only to network-validated public HTTP(S) endpoints and rejects URLs with embedded credentials or targets resolving to private, loopback, or link-local addresses.

05

Process audit

The platform retains request outcomes, latency, errors, returned memories, and contract-validation evidence required to verify evaluation integrity and public eligibility.

06

Result visibility

Private jobs and results are visible only to the bound Leaderboard API Key. The public board shows approved systems, versions, scores, and required evaluation metadata.

Participant data-handling obligations

Evaluation data and derived copies may be used only to complete the current job. Do not use them for training, fine-tuning, product analytics, dataset reconstruction, or redistribution. Restrict access to authorized personnel, avoid unnecessary payload logging, and delete the data within 30 days after job completion unless the platform approves another retention period in writing.

08

EVALUATION & RESULTS

Evaluation process and results

ADD

Synchronous ingestion

Each chunk must be persisted and searchable before its HTTP 200 response.

SEARCH

Retrieval and contract validation

The platform validates the data array, required fields, and Top K, then accepts candidates in participant order.

ANSWER

Standardized answering

Valid candidate memories enter the locked platform Answer model and prompt workflow.

EVAL

Standardized scoring

The platform applies fixed scoring contracts by question type and aggregates dataset and Overall results.

PRIVATE

Private results

After completion, the bound API Key can inspect run status, breakdowns, error summaries, and job metadata.

PUBLIC

Public release

An eligible full result creates a public submission only after qualification checks and review.

PUBLICATION GATE

Public leaderboard eligibility

The result must come from a successful full run on the fixed suite; every evaluation task must succeed; the Answer model, evaluation contract, pipeline code hash, dataset bundle hashes, and question counts must be complete and match the current release baseline; and the result must be unique and pass platform review.

09

BENCHMARK SUITE

Benchmark Details

Browse benchmark datasets by dimension. Each card links to its source repository with task format, metrics, and evaluation notes.

Textual Datasets

Multimodal Datasets

multimodal

ATM-Bench

Multimodal agent memory evaluated by question quality.

multimodal

Mem-Gallery

Gallery-style memory retrieval evaluated with F1.

Coding Datasets

coding

SWEContextBench

Software engineering context benchmark for retrieval match and task solving.

INTEGRATION GUIDE

Add / Search API Guide

Hosted integrations expose synchronous Add and Search HTTPS endpoints. Code submissions provide a public GitHub repository, Docker startup command, and API wrapper instructions; maintainers deploy and evaluate the submitted system.

Add Request

The platform sends one request for each memory chunk. Store every message before responding, and associate the data with the supplied user_id. The session_id identifies the source conversation and may be used for grouping, but retrieval isolation is based on user_id.

{
  "request_id": "eval:<run_id>:locomo_refined:conv-0:chunk-0",
  "messages": [{
    "role": "user",
    "timestamp": 1704067200000,
    "content": "raw memory text"
  }],
  "user_id": "eval:<run_id>:locomo:conv-0",
  "session_id": "eval:<run_id>:sample:0"
}
FieldRequirementDescription request_idRequiredUnique identifier for this write request. Echo it in the response. messagesRequiredOrdered list of messages to store. roleRequiredMessage role. The platform sends user or assistant. contentRequiredOriginal message text supplied for ingestion. timestampOptionalMessage timestamp in Unix milliseconds when available. user_idRequiredRetrieval scope. Store it exactly and use it to isolate later searches. session_idRequiredIdentifier for the source conversation or session.

Add Response

Return HTTP 200 only after the submitted messages have been fully stored and are available to Search. If your system performs ingestion in the background, wait for that work to finish before returning success; otherwise the benchmark may search before the memory is ready.

{
  "success": true,
  "request_id": "eval:<run_id>:locomo_refined:conv-0:chunk-0",
  "user_id": "eval:<run_id>:locomo:conv-0",
  "session_id": "eval:<run_id>:sample:0"
}
FieldRequirementDescription successRequiredMust be true. It confirms that the messages are stored and searchable. request_idRequiredExact request_id received in the Add request. user_idRequiredExact user_id received in the Add request. session_idRequiredExact session_id received in the Add request.

Search Request

After every Add request has completed, the platform sends one Search request per benchmark question. The query remains unchanged, and choice questions carry their options in a separate optional field.

{
  "query": "Which answer best matches the memory?",
  "options": ["A. First answer", "B. Second answer"],
  "user_id": "eval:<run_id>:locomo:conv-0",
  "top_k": 100
}
FieldRequirementDescription queryRequiredOriginal benchmark question used to retrieve relevant memories. optionsOptionalAnswer choices for choice questions. Omitted when the question has no options. user_idRequiredRetrieval scope. It exactly matches the value supplied during Add. top_kRequiredMaximum number of memories that may be returned.

Search Response

Return a data array ordered from most relevant to least relevant. The platform preserves this order and passes the returned content to the shared answer pipeline. Return an empty array when no relevant memory is available.

{
  "data": [
    {
      "id": "mem_123",
      "content": "remembered fact text",
      "score": 0.87,
      "created_at": "2026-07-01T12:00:00Z"
    }
  ]
}
FieldRequirementDescription dataRequiredOrdered array containing zero or more memory results. idRequiredStable identifier for the returned memory. contentRequiredMemory text supplied to the platform's answer model. scoreOptionalNumeric relevance score. Higher values must indicate greater relevance. created_atOptionalSource or persistence timestamp for the memory.

Evaluation Data

Your API receives benchmark content during each run.

Data sent

Your API receives evaluation memories and questions.

Evaluation only

Use this data only for the evaluation. Do not train on it, analyze it, or share it.

Delete in 30 days

Keep it private, avoid storing logs, and delete it within 30 days after the run.

What Each Page is for

A compact map of the product surface so users know where to go after their endpoints are ready.

01

Home

Overview and benchmark preview.

02

Leaderboard

Public rankings by track.

03

Evaluation

Verify key, start eval jobs, inspect private results and attribution.

04

Documentation

User workflow, API contract, security, and result publication.

05

Provide Benchmark

Bind system name, endpoints, and secret.