Lab

Resilience and full cost: what a memory service needs to measure

Short answer

The price of a calculation does not tell you the cost of a reliable service. Memory also needs to remain available, enforce permissions and support recovery. Nawame’s infrastructure work examines these responsibilities together, without treating a server’s location as a complete definition of sovereignty.

Computation, continuity, recovery and permissions surrounding a memory service.

Count the whole service

An embedding calculation has visible costs: processor time, memory and capacity. Its full cost also includes updates, monitoring, backups, recovery exercises and the human work needed to understand failures.

An optimisation can reduce one bill while increasing complexity. Adding components creates new availability, permission and failure interactions to verify. The benefit needs to exceed that additional operating burden.

Avoiding redundant computation can instead reduce consumption and queueing without adding another class of service. The embedding engine benchmark illustrates why processing speed, throughput and the amount of work performed should be measured separately.

Failover must preserve the right properties

The migration work examined a common embedding engine, an encrypted connection and a fallback mechanism. A fallback aims to maintain an acceptable service when the normal path becomes unavailable.

Receiving a response is only part of that requirement. The alternative path must preserve the intended properties: permissions, representation consistency and protection of data in transit.

Failing closed is particularly relevant to encrypted communication. Losing the protected path should not silently cause data to travel over an unprotected alternative. That property needs verification under failure conditions; it cannot be inferred merely from the presence of an encryption tool.

An otherwise effective recovery mechanism would be incomplete if it restored availability by weakening a protection the service depends on.

Restarts expose hidden dependencies

A service that remains healthy for several hours can still fail after a restart. Components may return in a different order, and protections may not be reapplied when they are needed.

The Nawame exercises identified startup-order problems and failures to restore protective controls at the appropriate point. Correcting those issues shows the value of testing transitions rather than observing only a stable, healthy state.

Deployment requires similar care. A change merged into a repository is not, by itself, proof that the expected service is running. Each conclusion needs the appropriate observation. Keeping these kinds of evidence separate makes operational decisions easier to assess.

A backup is not a completed recovery

A backup file, a readable archive and a successful restoration are different pieces of evidence. An exercise needs to verify that the dependencies required for recovery are present and produce a consistent system.

The work highlighted database dependencies such as roles and object ownership. These affect behaviour, rather than merely documentation. Restoring data without addressing them can leave a service short of its intended state.

An exercise using test cryptographic material checks a technical chain. It does not independently establish that the actual recovery material will be available and usable when required. Those proofs need to remain distinct.

Removing access and erasing traces require different evidence

The relational Lab also distinguished a record disappearing from responses from its disappearance in storage. Its checks showed that logical deletion does not establish physical erasure of representations and backups. A derived copy therefore adds a responsibility: follow corrections and revocations, then document how residues are handled under the relevant retention lifecycle. Traceability does not grant permission to keep indefinitely what must be forgotten.

Encryption defines a boundary of protection: scope and limits

Encryption in transit protects an exchange. Encryption at rest protects stored data under particular conditions. Neither removes questions about permissions, administration, logs or access to content during processing.

Hosting a model locally therefore does not establish complete sovereignty on its own. The relevant questions include who can access the data, for which purposes and with what mechanisms of control.

For Nawame, that analysis connects to a product boundary: preserving context and returning it to authorised software does not require systematically interpreting every private text with a language model. Memory integrated into business software should provide its value through a service whose full costs, operating responsibilities and limits remain understandable.

Related reading: What if Nawame disappeared tomorrow? and Sovereignty and AI memory: why privacy can require trade-offs.

Your next prompt should not have to contain your whole story.

Start building a memory your AI tools can find again when it matters.

Start free