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.

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.


