← All posts
releaseannouncementarchitecture

Remem 0.5.0: Rebuilding the foundation for reliable agent memory

·1 min read·Remem Team

Remem 0.5.0 is now available.

This release is a major step for the project. Remem has been rewritten in Go, but calling it “a rewrite” does not tell the whole story. We used the move to a new implementation to fix foundational limitations in the earlier version and to build a stronger base for the memory features we want to deliver next.

The result is a more reliable single-node service today, with a clearer path to true multi-tenancy, role-based access control, and horizontal scale in the future Enterprise edition.

Why we rebuilt Remem

The earlier Rust implementation helped prove the product direction. It showed that agents benefit from durable memories, lifecycle management, search, and relationships between memories. It also exposed a difficult tradeoff: too much of the system was tied to maintaining a custom storage foundation, which became a foundational limitation for reliability and future growth.

That made reliability work harder than it needed to be. Storage behavior, index maintenance, recovery, migrations, and higher-level memory features were too closely connected. Fixing one layer often meant reasoning about several others at the same time.

For 0.5.0, we decided to make a clean break. Go gives us a simpler operational foundation for the service, while Pebble provides the durable ordered storage primitive underneath it. Remem can now focus its own engineering effort on the things that make it a memory system: retrieval, lifecycle, relationships, tenancy, and the experience of operating it.

This is not about changing languages for its own sake. It is about putting the right boundary in the right place.

Pebble lets us focus on memory

Remem now uses Pebble for durable local storage. Pebble is a stable, embeddable storage engine for Go, with the ordered key-value behavior Remem needs for records, indexes, jobs, and metadata.

That decision removes a large amount of infrastructure that Remem would otherwise need to build and maintain itself. It also gives us a more predictable base for crash recovery, migrations, checkpoints, and repair workflows.

The benefit is not only fewer components. It is focus. Instead of building another general-purpose storage engine, we can spend that effort on making memory useful and dependable:

  • durable background jobs for lifecycle work, relationship discovery, and repairs;
  • safer migrations and pre-migration checkpoints;
  • snapshots, verification, and index rebuild workflows;
  • tenant-aware data boundaries;
  • better search and more consistent retrieval behavior.

The service remains easy to run: a Go server, one durable data directory, REST and MCP interfaces, and no separate database required for the Community deployment.

Better search and retrieval

Remem 0.5.0 keeps three retrieval modes available through the same service:

  • Semantic search for finding memories by meaning;
  • Keyword search for exact terms and text relevance;
  • Hybrid search for combining both signals.

This release improves the quality and consistency of search results, including ranking, filtering, pagination, and graph-related retrieval. Search behavior is also more explicit: callers select the search_type they need rather than depending on an ambiguous mode field.

Relationship discovery is now handled through durable jobs. When discovery is enabled, Remem can evaluate relevant candidates and create similar_to relationships without making the write request depend on a fragile in-memory queue. Applications can also create typed relationships such as related_to, caused_by, part_of, supports, and references.

This gives agents two ways to recover context: search for what matches the question, then follow the relationships that connect it to other useful memories.

More dependable day-to-day operation

The release also includes a broad set of reliability improvements. Remem now has durable job execution with leases, retries, checkpoints, and graceful shutdown behavior. Maintenance work can survive a process restart instead of depending on what happened to be in memory at the time.

Operational workflows are stronger too. Operators can inspect and repair indexes, create and verify snapshots, run migrations safely, and recover from damaged derived data without rebuilding the entire corpus by hand.

Several bugs were fixed along the way, including issues affecting writes, indexing, graph discovery, lifecycle processing, filtering, and tenant boundaries. These fixes matter because memory infrastructure is only useful if an agent can trust it after a restart, a failed job, or a growing corpus.

A foundation for multi-tenancy and scale

Remem 0.5.0 is designed for a reliable single-node deployment. It already has tenant-aware storage and request boundaries, which gives applications a way to separate memory spaces today.

That is an important foundation, but it is not the same as the full multi-tenant product we plan to offer. True Enterprise multi-tenancy needs more than a tenant identifier: organisations need users, teams, roles, permissions, auditing, and operational controls that work consistently across the service.

The next stage of Remem will build those capabilities into the Enterprise edition. Planned areas include:

  • organisation and workspace management;
  • role-based access control (RBAC);
  • tenant and resource-level permissions;
  • audit and administrative visibility;
  • horizontal scaling, replication, and high availability.

The current release establishes the data and service boundaries those features will build on. We are deliberately keeping Community focused on the complete single-node memory foundation, while Enterprise will address operating that foundation across an organisation.

Start with Remem 0.5.0

The Community release is self-hosted and free to start. Run it with Docker Compose, set REMEM_SERVER_API_KEY, and connect an application through REST or an MCP-compatible agent runtime.

It is also released under the Apache 2.0 license. We made this change so the Community build can be used as a foundation for projects built on Remem, including commercial applications, without the previous source-available service restriction. Apache 2.0 still includes its standard copyright, patent, and notice requirements; see the license for the full terms.

Terminal window
git clone https://github.com/remem-org/remem-community.git
cd remem-community
cp .env.example .env
docker compose up --build -d

The server listens on port 4545 by default. See the quickstart for the first memory and search request, or read how Remem works for the architecture and lifecycle model.

Remem 0.5.0 is the beginning of a more durable foundation: less energy spent rebuilding storage, more energy spent making agent memory reliable, useful, and ready for the next stage of scale.