Architectural Synthesis of Fused Gromov-Wasserstein Graph Memory for Deterministic Multi-Agent Systems

Full report

On this page

The evolution of artificial intelligence frameworks has increasingly shifted toward multi-agent ecosystems capable of autonomous decision-making, long-horizon planning, and collaborative problem-solving1. As these ecosystems scale, a critical bottleneck emerges in the management, retention, and application of contextual memory across distinct agent interactions3. Traditional memory solutions typically rely on semantic vector stores, which often fail to capture the hierarchical dependencies, temporal decay, and structural topologies of complex tasks6. When an agent attempts to retrieve historical context, flat vector databases return isolated text chunks, stripping away the logical sequence of actions that led to a specific outcome7. To circumvent the limitations of flat vector retrieval, graph-based memory architectures have gained prominence9. By representing entities, actions, and observations as interconnected nodes and edges, these structures allow agents to traverse knowledge systematically. However, the challenge of comparing, aligning, and merging distinct memory graphs—especially when different agents generate differing structural schemas for the same underlying logical process—remains computationally prohibitive due to the NP-hard nature of Graph Edit Distance (GED)12. Recent advancements in optimal transport theory, specifically the Fused Gromov-Wasserstein (FGW) distance, offer a deterministic, mathematically rigorous mechanism for graph alignment and memory distillation12. The introduction of the Experience Memory Graph (EMG) framework demonstrates how FGW can be utilized to replace brittle, iterative self-correction loops with one-shot, deterministic error correction3. By calculating the exact structural divergence between a failed execution trace and a successful expert trace, the system can algorithmically deduce the precise operations required to succeed3. This report provides an exhaustive architectural analysis of FGW graph memory, the EMG framework, and the broader multi-agent memory landscape. Furthermore, it explicitly contextualizes these theoretical models within the rigorous, deterministic, and scalable software engineering paradigms—such as C\#, ASP.NET Core, SQL Server, Command Query Responsibility Segregation (CQRS), and temporal tables—required to construct robust production environments17. Finally, the report delivers six extensively detailed architectural prompts designed to facilitate deep exploration and development for advanced multi-agent memory repositories.

The Multi-Agent Memory Landscape

The categorization of memory within autonomous systems generally splits across two dimensions: persistence and curation dependency. Persistence delineates short-term working memory from long-term storage, while curation dependency separates raw episodic records from outcome-validated experience19. Short-term memory involves transient information managed strictly within an agent's active processing context window during a single task19. Conversely, long-term memory constitutes persistent information stored externally, enabling cross-task knowledge retrieval19. Within the long-term domain, a critical distinction exists between generic episodic memory and experience memory. Episodic memory denotes information retained without reference to task outcomes, such as interaction histories and raw facts19. Experience memory, however, involves knowledge explicitly validated by task success or failure, forming the foundational basis for skill accumulation, error correction, and cross-task transfer19. Despite the proliferation of multi-agent frameworks, several structural limitations persist within conventional memory architectures. The most pervasive issue is state staleness, where traditional systems store raw facts but fail to track the underlying dependencies of those facts20. When an underlying library, business rule, or environmental assumption changes, the stored facts degrade silently. Advanced systems must store the full logical chain so that when a foundational premise shifts, the dependent memory nodes are automatically invalidated20. Furthermore, agents frequently suffer from compounding execution errors in long-horizon tasks21. Conventional self-correction mechanisms rely on prompt-based reflection, necessitating iterative trial-and-error loops that incur heavy latency, high API costs, and produce task-specific solutions that generalize poorly3. Finally, unrestricted memory sharing in multi-agent environments leads to context pollution. Effective multi-agent memory requires strict fleet boundaries, governed synchronization, and conflict resolution protocols to ensure that data generated by one specialized agent does not maliciously or accidentally overwrite the verified logic of another5. To resolve these bottlenecks, the field is transitioning toward unified, multi-layered memory graphs.

The transition toward graph-based memory solves the issue of representational structure but introduces a severe computational hurdle: how does a system algorithmically compare, merge, and update these massive graphs efficiently?

The Computational Bottleneck: Graph Edit Distance

To merge, compare, or correct agent memory graphs, a mathematical measure of similarity is required. The standard metric for comparing the structural topology and feature alignment of two labeled graphs is Graph Edit Distance (GED)12. GED is defined as the minimum cost of elementary operations—specifically node insertions, node deletions, edge substitutions, and label modifications—required to transform a source graph into a target graph12. GED provides a highly versatile metric because it fully utilizes graph attributes, preserves crucial metric properties such as the triangle inequality, and enables controllable error tolerance for similarity searches12. However, the exact computation of GED is fundamentally NP-hard13. The high computational complexity renders exact GED calculations practically impossible for large-scale multi-agent memory repositories containing tens of thousands of nodes13. To mitigate this, researchers have historically relied on heuristic strategies, bipartite matching approximations, or learning-based graph neural network (GNN) embeddings13. While GNN-based approximations can predict structural similarity rapidly, they often operate as black boxes, providing a continuous similarity score without producing the explicit sequence of discrete edit operations necessary to physically update the memory graph24. For an autonomous agent to correct a failed workflow, it requires the exact, step-by-step edit path—knowing merely that its current workflow is 80% similar to an expert workflow is insufficient for autonomous correction12.

Optimal Transport and Fused Gromov-Wasserstein Alignment

Optimal Transport (OT) provides a robust mathematical framework to generalize assignment and alignment problems27. By relaxing the strict one-to-one node mappings required for exact graph matching into probabilistic transportation plans constrained only by non-negativity, the discrete, NP-hard GED problem is transformed into a continuous optimization problem12. The Wasserstein distance serves as the foundational metric in optimal transport, measuring the minimum effort required to align the features or attributes of two distributions27. However, the standard Wasserstein distance assumes that the features exist in the same metric space and completely ignores the internal structural topology connecting the entities27. To address this limitation, the Gromov-Wasserstein (GW) distance was introduced29. The GW distance circumvents the metric space limitation by comparing the intrinsic relational geometry of the spaces rather than their shared coordinates28. It measures how distances between pairs of nodes in one graph compare to distances between matched pairs in another graph, heavily penalizing structural distortions during the alignment process27. The Fused Gromov-Wasserstein (FGW) distance unifies these concepts into a single optimal transport metric that simultaneously aligns feature similarity and structural consistency by jointly optimizing both data attributes and internal geometric topologies28. Given two structured objects represented as probability measures on a product of a structural space and a feature space, the FGW distance relies on a critical trade-off parameter, [Figure omitted from source export]27.

The discrete FGW loss minimizes the objective by identifying an optimal coupling matrix [Figure omitted from source export] that aligns the nodes while minimizing the combined cost of feature distance (matrix [Figure omitted from source export]) and structural divergence (matrices [Figure omitted from source export] and [Figure omitted from source export])15. The optimization problem is formulated to penalize feature mismatch linearly and structural distortion quadratically, as the structural term must couple pairs of matched nodes to preserve edges28.

Algorithmic Variations and Scalability Enhancements

The standard FGW formulation assumes an equal mass constraint across the compared data structures, meaning the two graphs must possess identical total probabilistic mass33. In multi-agent memory systems, this assumption fails, as an agent's current working memory will only ever represent a small subgraph of the global enterprise memory repository33. To address this, the Fused Partial Gromov-Wasserstein (FPGW) framework extends the mathematics to accommodate unbalanced data, allowing for highly accurate subgraph matching and retrieval33. Similarly, the Diffusion Semi-Relaxed Fused Gromov-Wasserstein (DsrFGW) metric incorporates graph diffusion processes to allow information propagation across nodes, capturing global structural patterns while drastically reducing sensitivity to noise or missing edges in sparse memory graphs14. Implementing these mathematical models for Graph Edit Distance computation requires specialized solvers. The FGWAlign framework introduces three key enhancements to standard FGW solvers tailored specifically for GED calculation12. First, it utilizes a randomized initialization scheme to explore the solution space aggressively, preventing the optimization algorithm from becoming trapped in poor local optima12. Second, it employs a diverse projection strategy to convert the continuous probabilistic transport plan back into multiple candidate discrete node alignments12. Finally, it introduces multi-relational extensions to handle heterogeneous edges. With a time complexity of [Figure omitted from source export] and a space complexity of [Figure omitted from source export], FGWAlign achieves an 80% reduction in computation errors and a 15–60x speedup over heuristic GED methods, proving capable of aligning graphs with over 10,000 nodes in mere minutes on standard hardware12.

The Experience Memory Graph (EMG) Framework

The mathematical elegance of the Fused Gromov-Wasserstein distance finds its most direct and impactful application in the Experience Memory Graph (EMG) framework3. EMG is a comprehensive system designed to replace brittle, iterative self-reflection loops in autonomous agents with offline, one-shot algorithmic exactness3. By treating agent failure recovery strictly as a graph matching problem, the framework distills raw interaction trajectories into highly structured memory networks3.

Constructing Action Decision Graphs

The foundational step in the EMG pipeline involves converting sequential interaction logs into directed Action Decision Graphs15. In standard operation, an agent generates a trajectory consisting of environment states, observations, and actions16. EMG normalizes these trajectories into a graph where the nodes represent distinct action tuples (e.g., action type, object, receptacle), and the edges represent the normalized observation states preceding the action, effectively mapping the transition [Figure omitted from source export]15. To ensure the graph captures the underlying decision logic rather than just a linear sequence, EMG utilizes a node reuse mechanism15. If an agent performs the identical action under different environmental observations, the incoming edges are routed to a single, shared node, enhancing the abstraction of the decision pattern36. Furthermore, when an agent becomes trapped in a loop—executing consecutive invalid actions under the identical observation state—EMG represents these failures as parallel edges originating from the same valid starting state15. This parallelization explicitly encodes the failure paths without generating redundant, non-informative linear sequences that would otherwise bloat the graph topology15.

Offline Graph Matching and Distillation

The core innovation of the EMG framework is shifting the computational burden of error correction from online LLM inference to offline graph computation3. During the training or offline distillation phase, the system pairs a failed exploration trajectory with a successful expert trajectory for the same underlying task3. It then computes the FGW distance between their respective Action Decision Graphs36. By analyzing the resulting optimal transport matching matrix, the framework extracts two highly specific structural artifacts3:

1. Common Subgraph: The overlapping structural topology between the failed and successful graphs. This represents the valid workflow components that the agent executed correctly, identifying the operational foundation that must be preserved3.

2. Graph Edit Path: The precise sequence of graph edit operations—identifying exactly which nodes to add, delete, or relabel—required to transform the failed trajectory into the successful expert trajectory3.

These extracted artifacts are persistently stored in the global memory repository as Intra-Task Nodes, serving as localized, deterministic corrective instructions3. To achieve cross-task generalization, EMG further links semantically similar task queries using embedding similarity metrics, generating Cross-Task Edges3. By performing FGW graph matching across these edges, the system extracts generalized decision patterns that successfully transfer across diverse environmental scenarios, creating a deeply connected relational knowledge base3.

The Operational Supremacy of One-Shot Execution

At runtime, the EMG framework fundamentally alters the agent execution paradigm. When encountering a complex task, the agent avoids the traditional pattern of generating actions, failing, and subsequently prompting an LLM to reflect on the cause of the failure15. Instead, the agent embeds its current task query, retrieves the top\-[Figure omitted from source export] intra-task nodes and top\-[Figure omitted from source export] cross-task edges from the memory graph, and receives a deterministic, mathematically optimal correction plan before execution begins15.

Extensive experiments on challenging, long-horizon benchmarks such as ALFWorld and ScienceWorld demonstrate that EMG consistently outperforms state-of-the-art self-reflection baselines in both success rate and average reward, while simultaneously reducing total inference time3. By replacing brittle LLM introspection with algorithmic exactness, the system achieves highly reliable autonomy3.

Deterministic Engineering for Multi-Agent Memory

Transitioning theoretical models implemented in academic Python notebooks into robust production environments requires unyielding adherence to disciplined software architecture. Scaling an FGW-backed EMG system into a secure, highly available enterprise architecture demands the application of strict engineering patterns, specifically those utilizing C\#, ASP.NET Core, SQL Server, and explicit data governance17. Michael Kappel’s documented software engineering methodologies emphasize practical, production-ready web software built upon Solid design principles, semantic search, and AI-assisted workflows that still require explicit human review gates17. Applying these principles to a multi-agent memory repository ensures that the resulting system is not only highly intelligent but verifiably secure, scalable, and resilient to systemic degradation17.

CQRS and Event Sourcing for Trajectory Capture

To construct the Action Decision Graphs required for FGW alignment, the system must accurately and immutably record every state, action, and observation generated by the agent fleet. Applying the Command Query Responsibility Segregation (CQRS) architectural pattern ensures that the high-throughput ingestion of multi-agent event logs is physically and logically decoupled from the computationally intensive graph matching and retrieval processes18. By treating every agent interaction as an immutable event within an Event Sourcing paradigm, the system guarantees an exact historical ledger. If a logical error is detected in the graph extraction algorithm, the raw event stream can be deterministically replayed to reconstruct the memory graphs from scratch without any data loss17. This provides a vital safety mechanism against algorithmic corruption.

Temporal Tables and Staleness Mitigation

As previously established, facts within agent memory degrade silently20. An enterprise-grade implementation must utilize SQL Server system-versioned temporal tables to maintain a complete, unalterable history of all data changes18. When a background service updates a memory node based on a new graph edit path, the temporal table automatically preserves the previous state, recording the exact validity period of that specific logical assertion. This architectural choice enables precise time-travel queries. If an agent's memory graph leads to a catastrophic operational failure, engineers can query the database to reconstruct the exact state of the graph as it existed at the millisecond the agent made its decision18. Furthermore, by structuring memory as an explicit graph of dependencies, a change in a foundational business rule can programmatically trigger a cascading invalidation via recursive Common Table Expressions (CTEs), forcing the agent to re-evaluate the logical chain rather than executing on stale premises18.

Fleet Governance and Cross-Agent Isolation

In a commercial multi-agent ecosystem, memory graphs are shared across specialized agents operating in distinct security contexts. A memory graph utilized by an internal Human Resources agent cannot intersect with the memory graph of an external-facing Customer Support agent without severe security implications. Implementing strict Role-Based Access Control (RBAC) and Row-Level Security (RLS) within the SQL Server database ensures that cross-fleet synthesis only occurs at explicit, governance-approved boundary layers5. When conflicts arise—such as two agents attempting to record contradictory analytical findings to a shared cross-task edge—the system must defer to established conflict resolution strategies. Implementing Confidence Scoring matrices allows the database engine to algorithmically determine whether to apply a LatestUpdate, HighestConfidence, or ConfidenceWeighted resolution strategy when serving queries, maintaining the structural integrity of the graph1.

Offline Distillation and Deterministic Review Gates

The computation of the FGW distance, the extraction of Common Subgraphs, and the generation of Graph Edit Paths must occur asynchronously. Background services process the raw event streams, execute the optimal transport algorithms via highly optimized tensor processing microservices, and distill the results into structured JSON artifacts. Crucially, treating unverified LLM or algorithmic output as absolute operational truth is a well-documented anti-pattern in high-reliability systems17. Inspired by the speculative research visualization workflows of the ArcSecs physics engine, the distilled edit paths and generalized cross-task edges must be held in an isolated staging environment37. Human operators or deterministic validation suites evaluate these artifacts in a "Visitor Mode" before they are promoted37. Only upon passing the review gate are the updated memory topologies committed to the active production graph. Furthermore, these exported artifacts must contain explicit falsification conditions—environmental states that, if encountered at runtime, instantly invalidate the generalized memory pattern, ensuring safe autonomous execution37.

Strategic Implementation Prompts for Multi-Agent-Memory

To transition these theoretical and architectural concepts into functional code for the Multi-Agent-Memory repository, the following six highly detailed research and design prompts are provided. These prompts are structured to be executed by advanced large language models to generate architectural specifications, mathematical interop layers, and concrete C\#/SQL implementations aligned with deterministic engineering principles.

Prompt 1: Engineering a Deterministic Graph Edit Path Subsystem

Context: We are building a production-ready multi-agent memory framework in C\# (.NET 8/9), utilizing ASP.NET Core, CQRS (via MediatR), and SQL Server. Our objective is to implement an "Experience Memory Graph" (EMG) that extracts successful workflows from failed agent trajectories. Unlike Python-based prototypes, this system must strictly adhere to strongly-typed domain-driven design (DDD), ensuring deterministic execution and testability. Task Requirements:

Expected Output Format: A comprehensive technical specification document containing complete C\# code blocks for the domain models, EF Core configurations, MediatR handlers, and unit tests, accompanied by narrative explanations of the design choices.

Prompt 2: Cross-Fleet Memory Governance and Row-Level Security

Context: In our multi-agent ecosystem, memory graphs are shared across specialized agents (e.g., Legal Agent, Sales Agent). We require a robust governance model to prevent context pollution and enforce cross-fleet isolation, ensuring agents only access permitted subgraphs while still allowing high-level structural alignment (via Fused Gromov-Wasserstein metrics) across the entire knowledge base by privileged background services. Task Requirements:

Expected Output Format: A detailed data architecture document featuring raw T-SQL scripts for schema generation and RLS, C\# code for the conflict resolution strategy pattern, and a systemic workflow diagram depicting the cross-fleet alignment process.

Prompt 3: Temporal Decay and Cascading Invalidation Algorithms

Context: A critical flaw in standard agent memory is "staleness"—facts degrade silently when underlying assumptions change, leading to compounding errors. We are leveraging SQL Server Temporal Tables and an explicit logical dependency graph to automatically invalidate stale reasoning chains within an agent's memory. Task Requirements:

Expected Output Format: An advanced data engineering guide featuring EF Core configuration code, T-SQL recursive CTE scripts for dependency traversal, C\# LINQ time-travel examples, and an analysis of the performance implications of deep graph traversal on temporal data.

Prompt 4: Integrating Fused Gromov-Wasserstein Math into .NET Pipelines

Context: The Fused Gromov-Wasserstein (FGW) distance aligns both features and structural topology of graphs. While implemented in Python, we need an architectural design to bridge this mathematics into a C\# ASP.NET Core ecosystem for calculating Graph Edit Distances (GED) on agent memory utilizing a microservices architecture. Task Requirements:

Expected Output Format: A cross-platform systems architecture document containing the mathematical breakdown, the exact .proto file definitions for the gRPC contract, and the C\# service code responsible for orchestrating the RPC call and decoding the optimal transport matrix into discrete graph edits.

Prompt 5: Multi-Modal Knowledge Grounding and Deterministic Review Gates

Context: Applying speculative algorithmic outputs directly to a production memory graph is hazardous. Aligning with rigorous engineering workflows inspired by speculative visualization pipelines, all cross-task generalizable patterns extracted via graph matching must be exported as deterministic, machine-readable artifacts for a human-in-the-loop review gate before being committed to the global memory store. Task Requirements:

Expected Output Format: A full lifecycle management specification including the JSON schema definition, the C\# state machine configuration, API endpoint routing code, and a detailed explanation of how falsification criteria ensure the safety of autonomous agent execution.

Prompt 6: Scaling Graph-Augmented Agentic Routing via DBLayer Aggregation

Context: To optimize multi-agent orchestration, we want to implement a router that directs user queries to the optimal specialized LLM agent based on historical graph memory. Instead of traditional Graph Neural Networks, we want to explore database-inspired relational aggregation layers (DBLayer) using foreign key propagation to process local and historical memory tables directly within the SQL engine. Task Requirements:

Expected Output Format: A performance engineering document containing the SQL-based relational aggregation script, C\# routing logic, indexing configuration details, and an architectural analysis comparing this database-native routing approach against deploying standalone Graph Neural Network infrastructure.

Works cited

1. Multi-Agent Collaboration with Shared Memory \- GitHub, https://github.com/jamesbower/agentic\_shared\_memory/blob/main/documentation/multi\_agent\_collaboration.md

2. GraphPlanner: Graph Memory-Augmented Agentic Routing for Multi-Agent LLMs \- GitHub, https://github.com/ulab-uiuc/GraphPlanner

3. Experience Memory Graph: One-Shot Error Correction for Agents \- arXiv, https://arxiv.org/html/2607.13884v1

4. GitHub \- rohitg00/agentmemory: \#1 Persistent memory for AI coding agents based on real-world benchmarks, https://github.com/rohitg00/agentmemory

5. cross-agent-memory · GitHub Topics, https://github.com/topics/cross-agent-memory

6. Enhancing document retrieval using semantic alignment with hierarchical graph matching, https://www.researchgate.net/publication/403668995\_Enhancing\_document\_retrieval\_using\_semantic\_alignment\_with\_hierarchical\_graph\_matching

7. jyyang621/DailyArXiv: Thanks to https://github.com/zezhishao/DailyArXiv.git · GitHub \- GitHub, https://github.com/jyyang621/DailyArXiv

8. Guibin Zhang's research while affiliated with National University of Singapore and other places \- ResearchGate, https://www.researchgate.net/scientific-contributions/Guibin-Zhang-2259145567

9. neo4j-labs/agent-memory \- GitHub, https://github.com/neo4j-labs/agent-memory

10. \[KDD 2026\] MemGraphRAG: Memory-based Multi-Agent System for Graph Retrieval-Augmented Generation \- GitHub, https://github.com/XMUDeepLIT/MemGraphRAG

11. GitHub \- DEEP-PolyU/Awesome-GraphMemory: A survey of Graph-based Agent Memory, https://github.com/DEEP-PolyU/Awesome-GraphMemory

12. Fused Gromov-Wasserstein Alignment for Graph Edit Distance Computation and Beyond \- VLDB Endowment, https://www.vldb.org/pvldb/vol18/p3641-tang.pdf

13. Speeding Up Graph Edit Distance Computation with a Bipartite Heuristic. \- ResearchGate, https://www.researchgate.net/publication/221632203\_Speeding\_Up\_Graph\_Edit\_Distance\_Computation\_with\_a\_Bipartite\_Heuristic

14. \[2607.06646\] Diffusion enabled Optimal Transport distances for graph matching \- arXiv, https://arxiv.org/abs/2607.06646

15. \[Literature Review\] Experience Memory Graph: One-Shot Error Correction for Agents, https://www.themoonlight.io/review/experience-memory-graph-one-shot-error-correction-for-agents

16. \[2607.13884\] Experience Memory Graph: One-Shot Error Correction for Agents \- arXiv, https://arxiv.org/abs/2607.13884

17. Contact Michael Kappel \- ArcSecs.com, https://arcsecs.com/contact/

18. About the Operator \- Carcinus.org, https://carcinus.org/about-mike

19. TsinghuaC3I/Awesome-Memory-for-Agents \- GitHub, https://github.com/TsinghuaC3I/Awesome-Memory-for-Agents

20. What's the "best" multi-agent memory system for coding agents? I raised 9 issues on rohitg00/agentmemory and have given up on it. \- Reddit, https://www.reddit.com/r/AI\_Agents/comments/1u3x5to/whats\_the\_best\_multiagent\_memory\_system\_for/

21. Experience Memory Graph: One-Shot Error Correction for Agents \- ResearchGate, https://www.researchgate.net/publication/410206669\_Experience\_Memory\_Graph\_One-Shot\_Error\_Correction\_for\_Agents

22. Success rate between one-shot memory and iterative correction methods.... | Download Scientific Diagram \- ResearchGate, https://www.researchgate.net/figure/Success-rate-between-one-shot-memory-and-iterative-correction-methods-The-one-shot\_fig1\_410206669

23. LatentMem: Customizing Latent Memory for Multi-Agent Systems \- GitHub, https://github.com/KANABOON1/LatentMem

24. Towards Metric-Faithful Neural Graph Matching \- arXiv, https://arxiv.org/html/2605.06588

25. Fused Gromov-Wasserstein Alignment for Graph Edit Distance Computation and Beyond, https://researchportal.hkust.edu.hk/en/publications/fused-gromov-wasserstein-alignment-for-graph-edit-distance-comput/

26. \[PDF\] Towards Metric-Faithful Neural Graph Matching \- Semantic Scholar, https://www.semanticscholar.org/paper/Towards-Metric-Faithful-Neural-Graph-Matching-Shivottam-Mishra/1c849c6909c21c25c614b848fa755ca70d14d4db

27. Gromov–Wasserstein Meets Combinatorial Optimization: A Scalable Solver for the Capacitated Quadratic Assignment Problem \- MDPI, https://www.mdpi.com/2227-7390/14/11/1972

28. Fused Gromov–Wasserstein: Theory & Applications \- Emergent Mind, https://www.emergentmind.com/topics/fused-gromov-wasserstein-fgw

29. Gromov-Wasserstein Learning for Graph Matching and Node Embedding, https://proceedings.mlr.press/v97/xu19b/xu19b.pdf

30. Fused Unbalanced Gromov–Wasserstein-Based Network Distributional Resilience Analysis for Critical Infrastructure Assessment \- MDPI, https://www.mdpi.com/2227-7390/14/3/417

31. FOSSIL: Fused Gromov-Wasserstein Learning | PDF | Applied Mathematics \- Scribd, https://www.scribd.com/document/890515037/3177-A-Fused-Gromov-Wasserstei

32. \[Literature Review\] Experience Memory Graph: One-Shot Error Correction for Agents, https://www.themoonlight.io/en/review/experience-memory-graph-one-shot-error-correction-for-agents

33. \[2502.09934\] Fused Partial Gromov-Wasserstein for Structured Objects \- arXiv, https://arxiv.org/abs/2502.09934

34. Plot partial FGW for subgraph matching \- POT: Python Optimal Transport, https://pythonot.github.io/auto\_examples/gromov/plot\_partial\_fgw.html

35. Anomaly Detection and Similarity Computation on Attributed Graphs, https://researchportal.hkust.edu.hk/en/studentTheses/anomaly-detection-and-similarity-computation-on-attributed-graphs

36. \[论文评述\] Experience Memory Graph: One-Shot Error Correction for Agents \- Moonlight, https://www.themoonlight.io/zh/review/experience-memory-graph-one-shot-error-correction-for-agents

37. ArcSecs Physics Engine Demo | Speculative Physics Visualization, https://arcsecs.com/arcsecs-physics-engine-demo/