Linux Internals: How /proc/self/mem writes to unwritable memory - offlinemark

MemGPT

Memory-GPT (MemGPT) - Towards LLMs as Operating Systems - Teach LLMs to manage their own memory for unbounded context!

nanomem: An Extremely Simple, Inference-Time Memory Module

nanomem is an extremely simple, user-owned memory module that casts memory management as LLM calls / agent loops on a markdown file tree. You interact with the tree with natural language commands like nanomem add <fact>, nanomem retrieve <query>, and nanomem import <chatgpt>. As such, nanomem is by design interpretable, partitionable, portable, and versioned.

Woah. Letta vs Mem0. (For AI memory nerds)

365 votes, 55 comments. I’m an absolute AI memory nerd, and have probably read every proposal made about memory, and demoed virtually all of the…

The Memory Walled Garden

The gap between first and third party memory systems

Understanding memory management

Learn MemGPT memory management techniques for controlling LLM context windows with in-context and external storage.

mem-agent: Equipping LLM Agents with Memory Using RL

The insights and the technical report behind Mem-Agent, our 4B model for persistent memory in LLMs

A practical guide to WebAssembly memory | radu's blog

Memory in WebAssembly is one of the topics that creates confusion for newcomers, particularly for those with experience in languages with memory management features like garbage collection, such as JavaScript, Go, or Java. In this article we explore using memory in WebAssembly in various scenarios - passing JavaScript arrays to Rust and AssemblyScript modules, checking for some basic memory leaks using Valgrind, or exchanging strings between runtimes and modules using Wasmtime.

kyju.org

Horribly misusing Rust features to provide provable memory safety and tracing garbage collection for pointer soup.

Signals and Threads

Stephen Dolan works on Jane Street’s Tools and Compilers team where he focuses on the OCaml compiler. In this episode, Stephen and Ron take a trip down memory lane, discussing how to manage computer memory efficiently and safely. They consider trade-offs between reference counting and garbage collection, the surprising gains achieved by prefetching, and how new language features like local allocation and unboxed types could give OCaml users more control over their memory.

I Benchmarked OpenAI Memory vs LangMem vs Letta (MemGPT) vs Mem0 for Long-Term Memory: Here’s How They Stacked Up

145 votes, 53 comments. Lately, I’ve been testing memory systems to handle long conversations in agent setups, optimizing for: Factual consistency…

CaviraOSS/OpenMemory

Local persistent memory store for LLM applications including claude desktop, github copilot, codex, antigravity, etc.

OpenMemory - AI Memory MCP Server for Coding Agents | Mem0

With OpenMemory, add persistent, project-aware memory to Cursor, Windsurf, and VS Code agents. Store preferences, patterns, and context that get retrieved automatically.

Inference Time Memory Module | Research | Tiles

Simple inference-time memory module that treats memory management as a series of LLM calls and agent loops over a markdown-based file tree.

Tiles: take a blob's mimeType from what uploadBlob returns #11

The tiles appendix recommends `application/octet-stream` as the `mimeType` of every blob reference. On some PDS implementations that recommendation makes a tile unpublishable as soon as it contains a file whose type can be recognised from its bytes. The reference implementation (bluesky-social/atproto, packages/pds, actor-`store/blob/transactor.ts`) does two things that together cause it: - On `com.atproto.repo.uploadBlob` it sniffs the bytes and stores the blob under the type it recognises (`image/png`, `audio/wav`, `font/woff2`, ...). The type the upload declared is used only when nothing is recognised, which is the case for HTML, CSS, JavaScript and JSON. - When a record that references a newly uploaded blob is written, it compares the reference's `mimeType` with the stored type and refuses the whole write if they differ: "Referenced Mimetype does not match stored blob. Expected: image/png". So a publisher that follows the appendix and writes `application/octet-stream` everywhere succeeds for a tile made only of text, and fails at the `com.atproto.repo.putRecord` of the tile's record for any tile with an image, a sound or a font in it. appmosphe.re's publish page does exactly this and fails that way, for example with "Expected: audio/wav" for a tile carrying a WAV sample. `atile publish` does not fail, because it sniffs each file itself with the same file-type library and writes what it finds; that only works as long as its sniffing agrees with that of the implementation it publishes to. `uploadBlob` already answers with the complete blob reference, `mimeType` included. Using that reference as the resource's src is correct on every implementation: one that sniffs reports the type it stored, and one that does not reports the declared `application/octet-stream`, which is what the appendix recommended before. The content-type the tile is served with stays separate and unaffected.