A lightweight long-term memory approach that starts from human decision records, preserves raw messages, organizes multiple retrieval views, and returns traceable evidence.

• GitHub:

  https://github.com/dlxeva/flowgrid-aml-retriever

• Leaderboard:

  https://huggingface.co/spaces/agent-memory-leaderboard/leaderboard

FlowGrid began as a single Markdown decision log.

The log recorded what judgments a project had made, what alternatives existed, why the current direction was chosen, what had been confirmed, which risks remained unresolved, and what conditions would require reassessment.

The earliest records already included decision status, project stage, decision context, the core problem, alternatives, the final choice, reasons for rejecting alternatives, risk assessments, follow-up validation, and an entry point for retrospective review. People could read the file directly, and Git could compare and track it. Even if the Agent stopped running, a person could still open the file and understand where the project stood.

As the number of projects and the amount of Agent collaboration grew, the single log encountered new problems. Decisions were scattered across sessions and files, old states could remain in the context, and new evidence might not reach the current task in time. FlowGrid subsequently added provenance tracking, temporal states, conflict preservation, and evidence retrieval. The AML branch further added user isolation.

This history shaped FlowGrid's governance philosophy: the system should help people understand how judgments were reached, while preserving the process through which those judgments changed.

FlowGrid AML Retriever condensed this approach into the challenge's prescribed Add and Search interfaces. The reader changed from a project lead to a unified answering model, and the task narrowed accordingly: preserve historical messages and return relevant, complete, traceable evidence when a question arises.

After the first challenge cycle, this branch continued evolving into the independent FlowGrid Agent Memory. AML Retriever v1.1 became the code foundation for the general-purpose core, while Add and Search remained as compatibility and challenge-adaptation layers. The new product core began handling raw events, candidate memories, confirmation states, supersession and deletion, current-state resolution, and minimal-context compilation.

FlowGrid did not take first place in any individual category. Its scores were 55.59 for explicit fact recall, 45.19 for relational and multi-hop compositional reasoning, and 51.29 for personalization and care. Temporal and event sequencing scored 21.13, and memory governance scored 27.86; these were relative weaknesses.

How did a system that, by default, uses no external model calls and relies only on the Python standard library and SQLite FTS5 make the top eight?

FlowGrid's results came from four mutually constraining choices: retain raw evidence, maintain multiple views, use complementary retrieval signals, and ensure that all derived results can be traced back to their sources.

FlowGrid AML Retriever does not generate final answers.

Add receives users, sessions, and messages, and returns success only after synchronous persistence is complete. New messages are already searchable when the interface returns successfully. Repeated request_id and user_id combinations are handled as idempotent requests, preventing network retries from writing the same memory multiple times.

Search is always restricted to one user_id and returns memory evidence ranked by relevance. The platform handles the subsequent Answer and Eval stages.

This boundary allows storage, retrieval, and answering to be inspected independently. A retrieval system needs to demonstrate which historical information it recovered and explain where that information came from.

Long conversations rarely arrive in the shape a question requires.

Some questions need only one precise fact. Others depend on two or three consecutive turns. Still others require seeing the conditions, actions, and outcomes across a conversation segment together. Retrieving only individual messages can sever pronoun references, reasons, and temporal conditions. Keeping only large summaries can dilute names, numbers, dates, and original wording.

FlowGrid preserves every raw message while building three retrieval views.

1. The single-message view locates direct statements, names, numbers, and dates.

2. The sliding-window view restores references, conditions, and supplementary explanations in adjacent dialogue turns.

3. The conversation-segment view preserves the continuous structure of local events.

These views change only the retrieval granularity. Each view retains source_message_ids, allowing it to be traced back to the raw messages that produced it. Windows and conversation segments help recall; the original records remain the evidence sources.

FlowGrid v1.0's default path uses neither embedding models nor large language model calls. It combines multiple explainable signals to address common failure points in long-conversation retrieval.

SQLite FTS5 provides basic lexical recall. English, numbers, and dates are processed as lexical units, while Chinese uses character unigrams and bigrams to supplement tokenization. It struggles with paraphrases that span large semantic distances, but reliably preserves proper nouns, numbers, dates, and the lexical surface of the original text.

Once candidates enter ranking, the system separately computes signals for original-text substrings, term coverage, entities, numbers, dates, answer options, time, and adjacent context. Options in multiple-choice questions can also participate in retrieval, providing additional clues for names, places, and candidate facts.

BM25 rankings and deterministic feature rankings then enter weighted reciprocal rank fusion. Fusion operates on ranks, avoiding direct comparisons between raw scores on different scales. Views with identical content and evidence fully covered by other results are deduplicated, leaving room for more independent sources.

The final returned results include content, scores, time, view types, raw message IDs, and evidence markers. The downstream model receives a set of verifiable historical evidence.

Suppose a user first says that the release date is August 10. A few days later, they add that the release has been moved to August 14 because testing needs four more days.

The user subsequently asks for the current release date.

The single-message view can find both dates separately. The sliding-window view can put the new date together with the reason for the delay. Temporal signals identify which message came later. Provenance fields preserve the source of each statement.

The difficult part is confirming that the later statement really updates the earlier one. Another later message about the same project might simply be an unrelated mention.

Post-challenge controlled experiments using the v1.0 default retriever as the baseline tried more aggressive downweighting of old values. This improved some temporal questions but hurt overall MRR, so it was not included in the default version. The failure was specific: relying only on topic similarity and a later timestamp caused the system to mistake some unrelated new messages for state updates.

Post-challenge v1.1 added guarded state-update reranking. The query must have temporal intent, the two pieces of evidence must be highly related, and the newer message must explicitly express a modification, correction, postponement, or invalidation. Only when all three conditions hold does the system slightly raise the new evidence and lower the old evidence. The old message remains preserved and searchable.

This mechanism handles only a small class of clearly bounded updates. When the conditions are not sufficient, the system keeps the original ranking.

AML tests whether a memory system can provide enough evidence for an answering model. FlowGrid's original task was broader: when people must take responsibility for a judgment, the system also needs to present the current state, historical changes, sources of conflicts, and the reasons for adopting particular evidence.

For a unified answering model, seeing both old and new timestamped records may already be enough to infer the current state. For a project lead, however, one hundred raw records are still one hundred documents to reread. People also need to know which account is currently adopted, who changed it and when, why the old account is still preserved, whether conflicts have been resolved, and how to restore the context after an incorrect judgment.

FlowGrid therefore preserves conflicts and historical states primarily for human auditing and decision-making. In the AML branch, this governance philosophy must also face a more direct test: can it improve the evidence set and ranking ultimately returned?

The leaderboard offers a valuable reminder. Some systems have no explicit governance mechanism, yet earn higher governance scores. The number of internally stored state labels does not establish that the answering model received better evidence. Even if an old value drops a few places, it may continue to influence the answer as long as it remains in the Top K.

FlowGrid addresses this by narrowing the scope of governance rules and using paired experiments to determine whether a rule enters the default path. Each mechanism must explain which type of error it fixes, whether it harms other queries, and whether it actually changes the returned results. Without such evidence, the mechanism remains disabled.

The score of 43.98 and 8th place apply only to the officially evaluated v1.0.

The AML Add/Search adapter in the public FlowGrid Agent Memory repository is version v1.1.0. Its guarded state-update reranking has not received a new official leaderboard score. The repository's numbers come from deterministic synthetic evaluations for version comparisons and cannot be converted into a new AML overall score.

In local paired experiments using classic, medium, and mixed settings, three fixed seeds, and top_k 100, the v1.0 baseline achieved Recall@20 of 0.9948, Recall@100 of 1.0000, and MRR of 0.6728. With v1.1's guarded state updates, Recall@20 and Recall@100 remained unchanged, while MRR reached 0.6948.

More aggressive temporal weights could raise MRR to approximately 0.7040, but reduced one seed's Recall@20 from 0.9870 to 0.9844. v1.1 did not adopt those parameters. High recall is the system's primary goal, and it is unwilling to trade recall stability for small gains at the top of the ranking.

These experiments support only a limited conclusion: under the current local synthetic protocol, explicit update semantics can reduce the collateral damage caused by crude temporal reranking. They do not establish that the same gains will appear on the official hidden data.

FlowGrid did not rely on a single decisive model component. It reduced several common errors.

Raw messages are preserved in full, so summarization or fact extraction does not lose details during writing.

Messages, windows, and conversation segments provide three recall scales, creating more matchable surfaces even when a question is paraphrased.

Chinese character fragments, entities, numbers, dates, and options supplement FTS5's basic lexical capabilities.

Each derived view is bound to its raw messages, allowing returned results to be verified and all data for a user to be deleted completely.

The default path has no third-party Python dependencies or external model calls. Add, Search, idempotency, user isolation, and synchronous read-after-write searchability can all be reproduced deterministically.

Its costs are equally clear. Purely lexical approaches have limited ability to handle paraphrases across large semantic distances, especially paraphrased temporal expressions. SQLite suits a single-node implementation and cannot directly serve as a distributed memory service. Soft reranking can improve evidence order but cannot replace complete state judgment.

Eighth place shows that this lightweight evidence-retrieval route was competitive on the first-cycle leaderboard. It does not establish that complex memory governance has been solved.

The first-cycle score demonstrated the competitiveness of the evidence-retrieval foundation, while exposing the limits of handling only Add and Search. The main post-challenge development direction has shifted to general-purpose FlowGrid Agent Memory. The AML interfaces remain for compatibility and future public evaluations.

The general-purpose core divides memory into three layers.

The first layer consists of immutable raw events. It preserves interactions that actually occurred and their provenance.

The second layer consists of candidate memories proposed by rules or models. Candidate, inferred, and unknown states cannot automatically be promoted to facts already confirmed by the user.

The third layer consists of the current state confirmed by a user, responsible person, or authorized policy. Superseded, rejected, and deleted content does not reenter ordinary continuation, but can still be traced in an authorized audit mode.

The Current State Resolver determines the currently valid state. The Context Compiler compiles a minimal context package according to the task, scope, permissions, and token budget. Models can assist extraction, but the governance core still requires provenance anchors and restricts model outputs to the candidate state.

The main evidence goal for the next stage is improved continuation in long-term real-world tasks. Future public AML cycles remain an external validation target, but challenge rules belong only in the adapter and evaluation configuration. Any challenge-related improvement must also pass FlowGrid's governance invariants, avoiding turning the general-purpose core into question-type rules for leaderboard performance.

FlowGrid began with a Markdown decision log written for people, gradually gaining structured states, provenance tracking, conflict preservation, and evidence retrieval. AML Retriever adapted these methods into the prescribed Add and Search interfaces. FlowGrid Agent Memory then brought the retrieval foundation validated in the challenge back to a general-purpose product, continuing to address current state, authorization boundaries, and minimal context.

Eighth place shows that it can already retrieve a competitive set of historical evidence for the answering model. Its weaker temporal and governance scores identify the issues that the next stage needs to address.

Long-term memory needs to answer four questions: what does this information say, where does it come from, what changed afterward, and why does the current judgment adopt it?

FlowGrid aims to keep these questions recorded and open to human reexamination at all times.

• Project Team: Artificial Idiocy Research Institute

• Project Lead: Du Lingxiao

• Background: Independent researcher; game publishing

FlowGrid is a local-first open-source project initiated by Du Lingxiao. It explores how people and Agents can share readable, traceable, recoverable project states in long-term projects. FlowGrid AML Retriever was jointly developed by the project lead and AI collaborators. The project lead is responsible for problem definition, system boundaries, experimental trade-offs, version acceptance, and public reporting.

Du Lingxiao currently develops human–AI collaboration projects such as FlowGrid and Canvas Prompt, and operates the personal technology-content site Artificial Idiocy Research Institute.

• Personal Website: https://aizhiz.com/

• GitHub: https://github.com/dlxeva

• X: https://x.com/dlxeva

• Contact Email: [email protected]