TLDR
I built a working memory organ for AI called 2 dimensional glyph memory, or 2DGM. It stores knowledge as fixed width glyphs inside fixed geometry pages with a tiny manifest for durability. It reopens deterministically, survives crashes, and lets a small model recall very large knowledge. This is the missing storage layer that turns clever models into reliable systems.
What I have already built
I created a compact on disk format that packs each glyph into a precise number of bits and lays them out on page grids. Pages fill in row major order.
I use an append only write path that advances a cursor across the page, then rolls to the next page when full.
A manifest records total glyphs, current page, and cursor. Readers trust the manifest and never guess.
A preview tool renders a page as a small image so you can eyeball what is on disk in seconds.
Crash recovery is deterministic. If the process is killed during an append, reopen continues from the last committed state.
I am not publishing header fields, packing order, or the checksum method. Those are implementation details that make the system work the way it does.
Why this matters for AGI
Modern models are powerful but their memory is fragile. Tokens come and go. Context windows drift. External databases add latency and non determinism. 2DGM fixes that at the root.
Deterministic reopen means an agent can pause and resume with the same state every time.
Glyph native storage matches how my models think. No retokenization on read.
Fast sequential scans let a compact policy model rebuild a long narrative quickly.
A simple failure model keeps alignment practical. You can audit what was written and when.
AGI is not just larger networks. It is memory you can trust.
Proof that it works
These checks pass today on my hardware.
-
Round trip
Write a known sequence of glyphs, read it back, and compare bit for bit. -
Forced rollover
Fill the end of a page, roll to a fresh page, and read across the boundary. -
Crash drill
Interrupt during append, reopen, and continue from the last valid cursor. Pages remain intact. -
Visual sanity
Preview images show the expected bit patterns for test sequences. This gives instant human verification.
I track throughput, read latency, and overhead, but I am not publishing numbers yet. The point here is function, not a benchmark derby.
How this leads to AGI in practice
Stable long term memory
Agents can build durable memories that do not drift when reopened.
Live compression
Structured knowledge can be compressed into glyphs once and reused across tasks without expensive retokenization.
Small checkpoints with big recall
A compact policy model can consult very large knowledge because the memory organ is optimized for that pattern.
Auditability
A clear write path and a manifest allow full inspection. This supports safety work and reproducibility.
Composable organs
You can pair 2DGM with a reasoning module, a retrieval module, or a planner. Each organ does one job well.
What I am building next
Snapshots and restore for rapid context swaps between tasks or users.
Read only export that maps pages directly into training or inference buffers.
Cold page compaction once real workloads demand it. This is optional and will not change the public contract.
Evaluation packs
Black box tests and previews that anyone can run to verify function without seeing internals.
What I will not share
Internal packing order
Header layout
Write protocol details
Locking specifics
These elements are how it works. The public contract below is sufficient for discussion and evaluation.
Public contract for anyone evaluating
Fixed geometry per page
Fixed width glyphs
Append only
Cursor always points to the next free slot
Manifest is authoritative
Integrity checks cover only written regions
Read ranges and preview are supported
Where this is going
My goal is a deterministic AI stack with a real memory organ. 2DGM gives me that substrate. From here I can
Train smaller policy models that rely on 2DGM for recall.
Build private companions that open the same memory every time.
Offer specialized agents that keep their own compressed knowledge without leaking data.