Position IS Relationship - A Spatial Memory Fabric for AI Systems

Status: Early-Stage Research Prototype

ARMS is an active research project exploring spatial memory for AI systems. The architecture and primitives described below are implemented and functional, but have been validated only on small-scale synthetic benchmarks (GPT-2, <100 stored states). This is not production-ready software. Rigorous evaluation across diverse models, datasets, and real-world workloads is ongoing. Contributions and critical feedback welcome.

ARMS is a spatial memory fabric that enables AI systems to store and retrieve computed states by their native dimensional coordinates. Unlike traditional databases that require explicit relationships through foreign keys or learned topology through approximate nearest neighbor algorithms, ARMS operates on a fundamental principle: proximity defines connection.

Current AI memory approaches all lose information:

• Extended context: Expensive, doesn't scale beyond training length
• RAG retrieval: Retrieves text, requires recomputation of attention
• Vector databases: Treat all data as unstructured point clouds
• External memory: Key-value stores with explicit indexing

Traditional:  State → Project → Index → Retrieve → Reconstruct
              (lossy at each step)

ARMS:         State → Store AT coordinates → Retrieve → Inject directly
              (native representation preserved)

Everything in ARMS reduces to five operations:

use arms_core::{Arms, ArmsConfig, Point};

// Create ARMS with default config
let mut arms = Arms::new(ArmsConfig::new(768));

// Place a point in the space
let point = Point::new(vec![0.1; 768]);
let id = arms.place(point, b"my data".to_vec()).unwrap();

// Find nearby points
let query = Point::new(vec![0.1; 768]);
let neighbors = arms.near(&query, 5).unwrap();

ARMS follows a hexagonal (ports-and-adapters) architecture. The core domain contains pure math with no I/O. Ports define trait contracts. Adapters provide swappable implementations.

┌─────────────────────────────────────────────────────────────┐
│                         ARMS                                │
├─────────────────────────────────────────────────────────────┤
│  CORE (pure math, no I/O)                                   │
│    Point, Id, Blob, Proximity, Merge                        │
│                                                             │
│  PORTS (trait contracts)                                    │
│    Place, Near, Latency                                     │
│                                                             │
│  ADAPTERS (swappable implementations)                       │
│    Storage: Memory, NVMe (planned)                          │
│    Index: Flat, HAT (see arms-hat crate)                    │
│                                                             │
│  ENGINE (orchestration)                                     │
│    Arms - the main entry point                              │
└─────────────────────────────────────────────────────────────┘

ARMS functions as an artificial hippocampus for AI systems:

• arms-hat - Hierarchical Attention Tree index adapter (experimental — see HAT repo for benchmark details and limitations)

• arms-nvme - Persistent storage via memory-mapped files
• arms-distributed - Sharded storage across machines
• arms-gpu - CUDA-accelerated similarity search
• arms-py - Python bindings

Built-in proximity measures:

• Cosine - Angle between vectors (semantic similarity)
• Euclidean - Straight-line distance
• DotProduct - Raw dot product
• Manhattan - L1 distance

[dependencies]
arms-core = "0.1"

The research paper is available in the paper/ directory.

ARMS: A Spatial Memory Fabric for AI Systems Andrew Young, 2026

MIT License - see LICENSE

If you use ARMS in research, please cite:

@article{young2026arms,
  author = {Young, Andrew},
  title = {ARMS: A Spatial Memory Fabric for AI Systems},
  journal = {arXiv preprint},
  year = {2026},
  url = {https://github.com/automate-capture/arms}
}

Andrew Young - andrew@automate-capture.com