Engramora – Long-Term Memory for AI Agents

Project Overview

Engramora is an independently developed software project by Merdan IT Solutions, focused on persistent memory for AI agents. The platform provides a separate memory layer where agents can store structured knowledge and context and retrieve it later.

The project combines the development of a proprietary Long-Term Memory (LTM) core with API integration, developer tools, and practical validation. Engramora.nl serves as the project's public information hub.

My role covers system design and the development of the memory core, integration layer, and testing software. The focus is on reliable storage, context-aware Recall, and a clear separation between the language model, the agent, and its memory.

Project status: active development and internal validation. The core Storage and Recall functionality has been implemented. The Cloud service, public developer access, and additional applications are undergoing further preparation and validation.

1. Background and Objectives

For long-running tasks, an AI agent needs information beyond the context of a single model call. This includes earlier findings, project agreements, and knowledge gathered during research. Without a separate memory system, the application must repeatedly supply or reconstruct this information.

Engramora is developing a reusable memory layer for this purpose. An agent can record relevant information and retrieve specific memories during a subsequent task. The application then determines which results to pass to the language model.

The objective is continuity: agents should be able to build on earlier information, even after a working session ends or the application restarts.

2. Architecture and Responsibilities

The architecture distinguishes three main components:

ComponentResponsibilityAI agentExecute tasks, process sources, and determine which information to store or retrieve.Language modelInterpret information, reason, and generate responses or structured content.Engramora LTMPersistently store structured memory and make it available through Recall.

This separation allows agent logic and model integration to evolve around a dedicated memory contract. Engramora is designed as infrastructure that can serve different applications.

The memory layer does not modify model weights. It is an external system that the application explicitly queries.

3. Structured Memory

Engramora works with structured memory records called patterns. The integration specifies the content to be stored and its associated features and context.

For example, an application can record knowledge about a software project together with relevant topics and project context. When a related question arises later, this structure can help retrieve appropriate memory information.

Key design principles include:

• Explicit input contracts for memory storage.
• Preservation of relevant context alongside stored information.
• Separation between information processing by the agent and storage by LTM.
• Consistent data formats across different clients.

The quality of the supplied memory still depends on the application. The agent or integration layer is responsible for selecting and structuring useful information.

4. Storage and Reliability

The proprietary Storage core handles persistent memory storage. Development focuses on predictable write behaviour, consistent processing, and recovery after interruptions.

The integration layer distinguishes between submitting a write request and establishing its final status. This matters when a network connection drops or a client receives no response.

A stable write identifier supports safely resubmitting the same request. Retrying a request must not silently create duplicate records. Internal validation therefore covers repeated requests, status checks, and recovery behaviour alongside normal write operations.

Reliability is thus part of the memory contract between client and server.

5. Recall and Context Use

Recall is the function through which an application retrieves previously stored memory. The current integration uses structured query inputs, including features and context.

The typical workflow consists of four steps:

1. The agent determines which information the current task requires.
2. The integration layer constructs a structured Recall request.
3. Engramora returns memory results within the authorised memory space.
4. The application selects the information to use in its next model call.

This approach gives developers control over when memory is queried and which information the language model receives. Recall and text generation remain separate parts of the workflow.

6. API, Authorisation, and Data Isolation

The API layer connects applications to the memory core. Current development covers initialisation, writing, write status, Recall, and access to authorised resource information.

Data isolation is central to the design. For each relevant operation, the server must verify that the token has access to the requested agent and memory space. Filtering in the user interface alone is insufficient.

Internal integration tests have verified, among other checks, that two separately authorised accounts cannot access each other's memory resources, write status, or Recall operations. These access controls are enforced on the server.

Access is limited by the token's authorisation scope; a client does not receive a platform-wide overview of all agents.

7. AgentLab as a Development and Testing Environment

Alongside the memory core, Engramora AgentLab is being developed as a desktop environment for testing agents that use LTM. The initial implementation uses C# and Avalonia.

AgentLab brings memory integration closer to actual agent use. Its development direction includes goal-driven tasks, information processing, structured memory storage, and reuse of previously recorded knowledge.

An important validation scenario covers the complete workflow: an agent gathers information, processes it with a model, writes useful results to LTM, and retrieves them later. Further development also focuses on task scheduling and clear execution results.

Future clients written in other programming languages must follow the same functional contracts and API formats. The user interface and implementation technology may vary by platform.

8. Scalability and Internal Validation

Engramora has undergone internal testing with memory datasets of up to 100 million patterns. These tests support further analysis of Recall, memory usage, and behaviour with larger datasets.

A benchmark result is meaningful only when its conditions are understood. Dataset size, hardware, cache state, and the distinction between Recall-only testing and a complete write-and-read cycle determine how a measurement should be interpreted.

Internal scale tests therefore do not constitute a general guarantee of Cloud performance. Further validation focuses on reproducible scenarios, concurrent requests, error handling, and actual agent use. Measurements include throughput, response-time distributions, and correctness.

9. Public Integration and Proprietary Core Technology

The publication strategy distinguishes developer tools from the proprietary core technology.

Following deployment and validation of the Cloud environment, the plan is to make SDK materials, API examples, and testing software publicly available. This will allow developers to evaluate the integration and run the documented test scenarios themselves.

The source code of the LTM core and Cloud API server remains private. Public documentation focuses on interface usage, observable system behaviour, and reproducible validation.

10. Future Development

The next steps are to complete the integration layer, continue validation with AgentLab, and make the Cloud service available through a controlled rollout.

The longer-term roadmap includes:

• Memory transfer between supported devices and platforms.
• Additional clients using the same memory contracts.
• A separate compatibility layer for other memory interfaces.
• Further optimisation of storage, resource usage, and concurrent processing.

These capabilities will be developed and validated incrementally. They describe the project's future direction rather than features already available in the product.

Technical Significance

Engramora brings together system design, persistent storage, API development, authorisation, and performance testing in one independently developed infrastructure project. The technical challenge lies in combining persistent memory with a practical, verifiable integration contract for AI agents.

Through this project, I am building a memory foundation that enables applications to carry accumulated knowledge forward and support long-running tasks.