Compartment: ఆఫ్‌లైన్ encrypted agent memory

Compartment భిన్నంగా చేసేది

Compartment అనేది agent memory store. ఇది ప్రతి record ను దాన్ని సృష్టించిన machine పైనే encrypted గా ఉంచుతుంది. ఇది network service తో ఎప్పుడూ మాట్లాడదు. Agent memory రంగంలోని ఇతర పరిష్కారాల నుంచి దీన్ని రెండు అంశాలు వేరు చేస్తాయి. Vault ఒక sealed file గా ఉంటుంది. దాన్ని మీ passphrase మాత్రమే తెరవగలదు. Embedding దశ కూడా స్థానికంగానే నడుస్తుంది. అందువల్ల memory లోని text ను vector గా మార్చడానికి ఎక్కడికీ పంపరు. Version 4.6.0 ను 10 August 2026న విడుదల చేశారు. Licence Apache-2.0. ఇది PyPI నుంచి install అవుతుంది.

ఇది threat model కు సంబంధించిన వాదన. అందువల్ల ఈ guide దీన్ని అలానే పరిగణిస్తుంది. At-rest encryption మరియు offline design కొన్ని నిర్దిష్ట అంశాలను రక్షిస్తాయి. ఇతర అంశాలు మాత్రం రక్షణ లేకుండా మిగులుతాయి. రెండవ రోజు ఎదురయ్యే సమస్యలు ఆ లోటు నుంచే వస్తాయి.

ఈ guide project యొక్క సొంత documentation మరియు release notes ను అనుసరిస్తుంది. వాటిని 11 August 2026న చదివారు. Compartment command line tool తో పాటు desktop application ను కూడా అందిస్తుంది. macOSలో menu bar item, Windowsలో notification area icon కూడా అందిస్తుంది. Automated container నుంచి passphrase prompt ను నడపలేరు. కాబట్టి దిగువ వివరాలను ఇక్కడ కొలిచిన ప్రవర్తనగా కాకుండా documentationలో పేర్కొన్న ప్రవర్తనగా పరిగణించండి. నిజమైన data తో ఉపయోగించే ముందు spare machine పై దీన్ని అమలు చేసి పరీక్షించండి.

వాస్తవంగా at rest encryption ఏది రక్షిస్తుంది

Vault ను XChaCha20-Poly1305 తో seal చేస్తారు. ఇది AEAD (authenticated encryption with associated data) cipher. Master key ను కలిగి ఉన్న keyslots ను Argon2id తో wrap చేస్తారు. ఇది నెమ్మదిగా పనిచేసేలా, ఎక్కువ memory అవసరమయ్యేలా రూపొందించిన password hashing function. దీని వల్ల రెండు విషయాలు స్పష్టమవుతాయి. దొంగిలించిన disk లో ఉన్న file copy, పాత backup లోని copy లేదా support ticket కు జత చేసిన copy కేవలం bytes మాత్రమే; దాని కంటే అదనంగా ఏమీ కాదు. అలాగే file open చేసినప్పుడు ఒక్క bit మారినా authentication విఫలమవుతుంది. అందువల్ల corruption తప్పు సమాధానంగా కాకుండా స్పష్టమైన error గా కనిపిస్తుంది.

Embedding vectors కూడా encrypted గా ఉంటాయి. ఇది వినిపించే దానికంటే ముఖ్యమైనది. Embedding అనేది hash కాదు. Embedding inversion పై జరిగిన పరిశోధనల్లో vector ఒక్కదాని నుంచే అసలు text లోని చదవగలిగే భాగాలను తిరిగి పొందారు. అందువల్ల encrypted database పక్కన plaintext vector index ఉంచడం, database ను దాదాపు open గా వదిలేయడమే. Compartment plaintext index ను disk పై ఎక్కడా రాయదు.

Deletion నిజమైన deletion. ప్రతి record కు దాని స్వంత key ఉంటుంది. compartment forget --shred ఆ key ను నాశనం చేస్తుంది. అందువల్ల మిగిలిపోయే ciphertext ను ఎవరూ decrypt చేయలేరు; మీరు కూడా కాదు. దీనిని database file నుంచి delete చేసిన row తో పోల్చండి. సాధారణంగా ఏదైనా దానిపై overwrite చేసే వరకు ఆ row free pages లో readable గానే ఉంటుంది.

Offline విధానం మరో ముఖ్యమైన భాగం. ఏదీ upload చేయబడదు. అందువల్ల మీ memories ను నిల్వచేసే vendor account ఉండదు. వాటిని leak చేయగల API key కూడా ఉండదు.

ఏమి Compartment రక్షించదు

ఈ వాదన vault సరిహద్దు వరకు మాత్రమే వర్తిస్తుంది. ఆ సరిహద్దు కనిపించేదానికంటే దగ్గరగా ఉంటుంది.

agent plaintext ను చదువుతుంది. Recall memory ను decrypt చేసి, ఆ text ను agent కు అందిస్తుంది. ఆ agent hosted model అయితే, memory తదుపరి prompt లో model provider వద్దకు వెళ్తుంది. Context window లోని మిగతా సమాచారంలాగే ఇది కూడా పంపబడుతుంది. Encryption at rest file ను రక్షిస్తుంది. కానీ retrieval ను రక్షించదు. అందువల్ల AI agents లో secrets ను ఉంచకపోవడం అనే నియమాలు store encrypted గా ఉందని సడలించకూడదు: memory గా సేవ్ చేసిన password, prompt లోకి స్వయంచాలకంగా paste చేయడానికి మీరు ఏర్పాటు చేసిన password అవుతుంది.

నడుస్తున్న machine లో unlocked vault తెరిచి ఉన్నట్టే. Project security notes దీన్ని స్పష్టంగా చెబుతున్నాయి. Vault unlocked గా ఉన్నప్పుడు master key మరియు working set RAM లో ఉంటాయి. Python buffer తుడిచివేయబడిందని హామీ ఇవ్వలదు. అలాగే swap లేదా hibernation image ఆ memory ను disk కు రాయవచ్చు. మీ user గా నడుస్తున్న malware cipher ను ఛేదించాల్సిన అవసరం లేదు. ఇప్పటికే unlocked గా ఉన్న vault ను అది అభ్యర్థించగలదు.

Caller identity declarative గా ఉంటుంది. ప్రతి caller కు namespaces పై పరిమితులు విధించవచ్చు. కానీ caller name host process నుంచి వస్తుంది. కాబట్టి తన పేరుపై అబద్ధం చెప్పే host, తాను కోరిన grants ను పొందుతుంది. Namespace permissions అనేవి organisation మాత్రమే. అవి hostile local program కు వ్యతిరేకంగా security boundary కావు.

Copies ను shredding చేరుకోలదు. forget --shred ప్రస్తుత file లోని key ను నాశనం చేస్తుంది. Shred చేయడానికి ముందు తీసిన backup లో ఆ record ఇంకా ఉంటుంది. ఆ record ను ఆ రోజుని passphrase తో ఇప్పటికీ తెరవవచ్చు.

బలహీనమైన passphrase తో చర్చ ముగుస్తుంది. Argon2id ప్రతి guess ను ఖరీదైనదిగా చేస్తుంది. Word list లో ఉన్న passphrase ను అది రక్షించదు.

పిన్ చేసిన విడుదల నుంచి Compartmentను ఇన్‌స్టాల్ చేయడం

Compartmentకు Python 3.11 లేదా తదుపరి వెర్షన్ అవసరం. ఈ ప్రాజెక్ట్ వేగంగా మారుతోంది. 10 August 2026 నాటికి PyPIలో ముప్పై వెర్షన్లు ఉన్నాయి. అందువల్ల ఇన్‌స్టాల్ చేసే రోజున ప్రస్తుత వెర్షన్‌ను స్వయంచాలకంగా తీసుకోకుండా, వెర్షన్‌ను pin చేయండి.

python3 --version
pip install "compartment==4.6.0"
compartment --version
compartment init

మీరు pin చేసిన వెర్షన్‌ను compartment --version ప్రదర్శించాలి. Shell compartment: command not found అని చూపిస్తే, ఇన్‌స్టాల్ directory మీ PATHలో లేదు. చాలా సిస్టమ్‌లలో ఆ directory ~/.local/bin ఉంటుంది. pipx install compartment==4.6.0 మరియు uv tool install compartment==4.6.0 తమ pathsను స్వయంగా నిర్వహించడం ద్వారా ఈ సమస్యను నివారిస్తాయి.

compartment init passphraseను రెండుసార్లు అడుగుతుంది. ఏదీ echo చేయదు. ఆ passphrase మాత్రమే key. ప్రాజెక్ట్ ఎలాంటి password లేదా recovery phraseను రూపొందించదు. ఇది ఉద్దేశపూర్వకమే. Software వద్ద మీకు తెలియని credential ఏదీ ఉండదు.

దానితో ఏదైనా అనుసంధానం చేయడానికి ముందు ఫలితాన్ని పరిశీలించండి.

compartment status

సరిగ్గా పనిచేస్తున్న vault unlocked అని చూపిస్తుంది. locked అని చూపిస్తే compartment unlock అమలు చేసి passphraseను నమోదు చేయండి. Restart చేసినప్పుడు vault మళ్లీ lock అవుతుంది. ఎందుకంటే దాన్ని తెరిచి ఉంచే credential ప్రతి bootకు ప్రత్యేకమైన secretపై ఆధారపడి ఉంటుంది. macOSలో, ఆ credentialను system keychainలో నిల్వ చేయడం ద్వారా reboot తర్వాత కూడా కొనసాగించడానికి compartment unlock --keychain ఎంపికను ప్రారంభిస్తుంది.

డేటా వాస్తవంగా ఎక్కడ ఉంటుంది

డిఫాల్ట్ vault ~/.compartment/memory.vault లో ఉంటుంది. ఏదైనా command తో --vault PATH ఉపయోగించి వేరే స్థానాన్ని సూచించవచ్చు. ప్రత్యామ్నాయంగా COMPARTMENT_VAULT environment variable ను సెట్ చేయవచ్చు.

ఆ ఒక్క file‌నే మొత్తం store. మొదట format version మరియు Argon2id keyslots ఉన్న header ఉంటుంది. తరువాత sealed payload ఉంటుంది. ఆ తరువాత కొత్త memories చేరినప్పుడు జోడించబడే journal entries ఉంటాయి. ప్రతి journal entry దాని length మరియు ఆ length‌కు సంబంధించిన CRC (cyclic redundancy check)తో frame చేయబడుతుంది. అందువల్ల crash కారణంగా write మధ్యలో ఆగిపోతే, దాన్ని dataగా చదవకుండా truncated entryగా గుర్తించవచ్చు. Compaction సమయంలో vault serialise చేయబడుతుంది, temporary file‌కి write చేయబడుతుంది, fsync చేయబడుతుంది, తరువాత దాని స్థానంలో rename చేయబడుతుంది. అందువల్ల reader‌కు సగం మాత్రమే వ్రాయబడిన vault కనిపించదు.

దీని ఉపయోగకరమైన ఫలితం: backup script ఖచ్చితంగా ఒక path‌ను మాత్రమే copy చేస్తుంది. అసౌకర్యమైన ఫలితం: మీరు దానిపై grep ఉపయోగించలేరు. Text editorలో దాన్ని repair చేయలేరు. catతో చదవగలిగే memory కావాలంటే, gitలో commit చేయడానికి Memmy యొక్క సాదా local memory files దీనికి విరుద్ధమైన trade-off. ఏది సముచితమో, మీరు భయపడేది దొంగిలించబడిన laptop‌నా లేదా పనిచేయకుండా పోయే tool‌నా అన్నదానిపై ఆధారపడి ఉంటుంది.

compartment uninstall software‌ను తొలగించి vault‌ను అలాగే ఉంచుతుంది. నిజంగా అవసరమైనప్పుడు మాత్రమే --purge pass చేయండి.

ఏజెంట్‌లో అనుసంధానం

ఒకే command ద్వారా మద్దతు ఉన్న client ను అనుసంధానించవచ్చు.

compartment integrate --list
compartment integrate claude

Claude Code కోసం ఇది MCP (model context protocol) server entry ని మరియు ~/.claude/settings.json లోకి ఒక PostToolUse hook ని రాస్తుంది. ముందుగా ఆ file కు backup తీసుకుంటుంది. తరువాత ~/.claude/skills/ కింద /compartmentalize skill ను install చేస్తుంది. అలాగే ~/.claude/CLAUDE.md కు managed block ను జోడిస్తుంది. Compartment, agent ఉపయోగిస్తున్న file-based memory కంటే ప్రాధాన్యమైనదని ఆ block agent కు తెలియజేస్తుంది. రెండు భాగాలు సరిగ్గా ఉన్నాయో నిర్ధారించండి:

compartment hook status
compartment recent

Server ను చేతితో register చేయాలంటే బదులుగా ఈ command ఉపయోగించండి:

claude mcp add --scope user compartment -- \
    compartment --vault ~/.compartment/memory.vault --caller claude-code serve

MCP కు మద్దతు ఉన్న ఇతర host ఏదైనా, తన సొంత caller name తో అదే server ను ఉపయోగిస్తుంది.

{ "mcpServers": { "compartment": {
    "command": "compartment",
    "args": ["--vault", "/path/to/memory.vault",
             "--caller", "your-agent-name", "serve"] } } }

ప్రతి host కు వేర్వేరు --caller value ఇవ్వండి. Audit log నమోదు చేసే label ఇదే. Namespace grants ఏ key కు వ్రాయాలో కూడా ఇదే నిర్ణయిస్తుంది. కాబట్టి ఒకే name ఉపయోగిస్తే ఈ రెండూ పనికిరావు.

Claude Code ఇప్పటికే తన సొంత memory files లో facts రాస్తూ ఉంటే, ఏదీ తరలించే ముందు ఏమి తరలించబడుతుందో compartment import-claude --dry-run చూపిస్తుంది. ముందుగా Claude Code తన memory files లో ఏమి ఉంచుతుందో చదవండి. ఎందుకంటే ఒక సంవత్సరం notes ను కొత్త vault లోకి import చేస్తే, ఎవరూ ఉంచాలని ఉద్దేశించని విషయాలతో memory store నిండిపోవచ్చు.

స్థానిక vault ఎంత వేగంగా ఉంటుంది

వ్యక్తిగత పరిమాణంలోని vault కోసం ప్రాజెక్ట్ ప్రచురించిన గణాంకాలు ఇవి. ఇవి ఇక్కడ నిర్వహించిన పరీక్ష నుంచి వచ్చినవి కావు; ప్రాజెక్ట్ documentation నుంచి తీసుకున్నవి.

[
  {
    "label": "Store one memory, end to end",
    "latency_ms": 40
  },
  {
    "label": "Embed one memory, bundled model",
    "latency_ms": 25
  },
  {
    "label": "Hybrid search, median",
    "latency_ms": 11.6
  },
  {
    "label": "Vector search at 20k records, p95",
    "latency_ms": 0.68
  }
]

ఒక memory నిల్వ చేయడానికి 40 ms పడుతుందని, అలాగే ఇరవై వేల records పై vector search కు 95వ percentile వద్ద 0.68 ms పడుతుందని పేర్కొన్నారు. memory ను స్థానికంగా ఉంచాలనే ప్రాజెక్ట్ వాదన సులభమైన లెక్కపై ఆధారపడి ఉంటుంది: hosted memory API కు ఒక network round trip కు సాధారణంగా ఇక్కడ పూర్తి hybrid search తీసుకునే 11.6 ms median కంటే ఎక్కువ సమయం పడుతుంది.

Search గణాంకాలను రెండు రూపకల్పన వివరాలు వివరిస్తాయి. ఇరవై వేల records కంటే తక్కువగా ఉన్నప్పుడు Compartment ప్రతి vector ను query తో పోలుస్తుంది. అందువల్ల recall సుమారుగా కాకుండా నిర్మాణపరంగానే ఖచ్చితంగా ఉంటుంది. దానికంటే ఎక్కువగా ఉన్నప్పుడు ఇది HNSW (hierarchical navigable small world) కు మారుతుంది. ఇది వేగం కోసం కొంత recall ను వదులుకునే approximate index. vault embedding model యొక్క SHA-256 hash ను కూడా నమోదు చేస్తుంది. వేరే model తో దాన్ని open చేయడాన్ని నిరాకరిస్తుంది. ఎందుకంటే రెండు వేర్వేరు models నుంచి వచ్చిన vectors ను ఎలాంటి error కనిపించకుండానే పోల్చవచ్చు, కానీ తిరిగి వచ్చే scores కు అర్థం ఉండదు.

బ్యాకప్‌లు, వచ్చే సంవత్సరం కూడా తెరవగల కాపీ

లాక్ చేసిన vault ఒకే portable file గా ఉంటుంది. కాబట్టి దాన్ని తరలించడం అంటే కాపీ చేయడమే.

compartment lock
scp ~/.compartment/memory.vault other-machine:
compartment --vault memory.vault unlock

ముందుగా దాన్ని లాక్ చేయండి. agent రాస్తున్న సమయంలో కాపీ చేస్తే, journal entry మధ్యలో append అవుతున్న స్థితిలో పట్టుబడవచ్చు. CRC framing వల్ల reader ఆ చివరి అసంపూర్ణ భాగాన్ని దాటవేయగలిగినా, అందులోని memory పోతుంది. compartment lock --sign Ed25519 manifest తో file ను seal చేస్తుంది. అందువల్ల passphrase లేకుండానే కాపీ సరిగ్గా చేరిందో receiving machine నిర్ధారించగలదు.

file ఇప్పటికే seal అయి ఉన్నందున, సాధారణ cloud storage దానికి అనుకూలమైన స్థలం. ఇక్కడే encryption at rest నేరుగా ఉపయోగపడుతుంది: backup target కు ఏ memory కనిపించదు.

రెండు హెచ్చరికలు. Shredding backups కు వర్తించదు. కాబట్టి మీరు ఈరోజు crypto shredded చేసిన record, గత వారం కాపీలో గత వారం passphrase ఉన్న ఎవరికైనా ఇప్పటికీ చదవగలిగే స్థితిలో ఉంటుంది. అలాగే compartment export --plaintext మొత్తం vault ను unencrypted గా రాస్తుంది. వేరే వ్యవస్థకు migrate చేయడానికి అది సరైన tool. కానీ ~/Downloads లో ఉంచడానికి అది సరైన file కాదు.

కొన్ని కాపీలను మాత్రమే ఉంచి, వాటికి తేదీలు జోడించండి. ఎవరూ memory store ను prune చేయకపోతే అది liability గా మారుతుంది. stale agent memories retrieval ను నిశ్శబ్దంగా ఎలా దెబ్బతీస్తాయో ఇక్కడి వివరణ ఇదే విషయాన్ని చూపిస్తుంది.

కీ నిర్వహణ, rotation మరియు రెండవ factor

compartment rekey
compartment 2fa enable
compartment 2fa status

rekey ప్రస్తుత file యొక్క keyslot లో master key ను మళ్లీ wrap చేయడం ద్వారా passphrase ను మారుస్తుంది. పాత copies లో పాత passphrase అలాగే ఉంటుంది. ఎందుకంటే ఆ bytes మార్పుకు ముందే seal చేయబడ్డాయి; వాటిని మార్చడానికి ఈ ప్రక్రియ వెనక్కి వెళ్లదు. Copies ను కూడా rotate చేయండి. లేదా retired passphrase తో ఇప్పటికీ ఏదో ఒకటి తెరవగలమనే విషయాన్ని అంగీకరించండి.

2fa enable keyfile ను రెండవ factor గా జోడిస్తుంది. Key derivation సమయంలో ఇది passphrase తో కలిపి ఉపయోగించబడుతుంది. అందువల్ల vault ను తెరవడానికి రెండూ అవసరం. అయితే మీరు కోల్పోయే వస్తువుల సంఖ్య కూడా రెట్టింపు అవుతుంది. Vault ఉన్న machine కు దూరంగా keyfile ను ఉంచండి.

Scripts మరియు CI (continuous integration) కోసం passphrase COMPARTMENT_PASSPHRASE environment variable ద్వారా అందవచ్చు. unlock --passphrase-stdin దాన్ని pipe నుంచి చదువుతుంది. Pipe ను ప్రాధాన్యంగా ఉపయోగించండి. అదే user కు చెందిన ఇతర processes environment variable ను చదవగలవు. అదనంగా అది job logs లోకి చేరే అవకాశం ఉంటుంది.

Audit history hash chain తో అనుసంధానించబడి ఉంటుంది. compartment audit verify దానిని పరిశీలించి, మొదటి విరిగిన link ను నివేదిస్తుంది. ఏదైనా restore చేసిన తర్వాత దీన్ని అమలు చేయండి. ఎందుకంటే అప్పుడు మౌనంగా truncated అయిన file బయటపడుతుంది.

పాస్‌ఫ్రేజ్‌ను కోల్పోతే ఏమి జరుగుతుంది

ఏమీ జరగదు. ఇదే రూపకల్పన ఉద్దేశం. Reset ఉండదు, recovery phrase ఉండదు, రాయడానికి address కూడా ఉండదు. ఎందుకంటే key యొక్క ఏ ప్రతీ మీ జ్ఞాపకం మరియు మీరు ఐచ్ఛికంగా ఉపయోగించే keyfile వెలుపల ఉండదు. Vault random గా కనిపించే bytes గల file గానే ఉంటుంది.

కాబట్టి recovery plan అనేది vault కోసం రూపొందించిన ప్రణాళిక కాదు. అది passphrase కోసం రూపొందించిన ప్రణాళిక. మీరు compartment init అమలు చేసే రోజే దాన్ని password manager లో నమోదు చేయండి. తరువాత దాన్ని పరీక్షించండి: vault ను lock చేసి, మీరు రాసి ఉంచిన వివరాలను మాత్రమే ఉపయోగించి unlock చేయండి. అది పనిచేసిన తర్వాత agent దాన్ని నింపడం ప్రారంభించనివ్వండి.

Compartment లేదా memory server

Compartment ను ఉద్దేశపూర్వకంగా ఒకే machine కోసం రూపొందించారు. భాగస్వామ్యం చేయాలంటే lock చేసిన file ను copy చేయాలి లేదా export చేసి import చేయాలి. ఒకేసారి write చేసే వ్యవస్థ లేదు. అందువల్ల ఒకే file ను ఉపయోగించే laptop మరియు workstation పరస్పరం చేసిన మార్పులను overwrite చేస్తాయి.

అనేక machines కు ఒకేసారి అదే memory అవసరమైతే, అది server సమస్య. VPS పై self-hosted Mem0 memory server దీనికి పరిష్కారం: ఒక endpoint, అనేక clients, laptop ను దాటి నిలిచే memory. దీని ఖర్చును స్పష్టంగా చెప్పాలి. ఆ server తాను నిల్వ చేసే data ను చదవగల process ను నడుపుతుంది. కాబట్టి మీ threat model లో ఇప్పుడు VPS మరియు దాని API ను చేరుకోగల ప్రతి వ్యక్తి కూడా ఉంటారు.

మీకు నిజంగా భయమయ్యే నష్టాన్ని ఆధారంగా చేసుకుని ఎంచుకోండి. laptop దొంగిలించబడటం లేదా vendor మీ notes చదవడం సమస్య అయితే, encrypted local vault బలమైన ఎంపిక. machines మార్చిన వెంటనే agent ప్రతిదీ మర్చిపోవడం సమస్య అయితే, server సరైన ఎంపిక.

FAQ

Compartment యొక్క encryption వాస్తవంగా దేనిని రక్షిస్తుంది?

ఇది file ను రక్షిస్తుంది. Vault ను XChaCha20-Poly1305 తో seal చేస్తారు. దాని keyslots ను Argon2id తో wrap చేస్తారు. Embedding vectors కూడా encrypted గా ఉంటాయి. అందువల్ల దొంగిలించిన disk లేదా పాత backup లో చదవదగిన సమాచారం లేని bytes మాత్రమే ఉంటాయి. అయితే running machine లో unlocked vault ను ఇది రక్షించదు. Vault open గా ఉన్నప్పుడు master key RAM లో ఉంటుంది. Recall తర్వాత memory plaintext గా తిరిగి వచ్చినప్పుడు agent దానితో ఏమి చేస్తుందో కూడా ఇది నియంత్రించదు.

Compartment offline గా ఉంటే, నా model provider నుండి నా memories private గా ఉంటాయా?

అవి recall అయ్యే వరకు మాత్రమే. Storing మరియు searching network లేకుండానే జరుగుతాయి. Embedding model కూడా local గా నడుస్తుంది. అందువల్ల write సమయంలో ఏదీ machine ను విడిచి వెళ్లదు. Read సమయంలో agent కు plaintext అందుతుంది. ఆ agent hosted model అయితే, memory prompt లోకి చేరి, మిగిలిన context window లాగానే provider వద్దకు వెళ్తుంది. Credential ను ఎప్పుడూ memory గా store చేయవద్దు.

నా Compartment passphrase పోతే ఏమి జరుగుతుంది?

Vault ను తిరిగి పొందలేరు. ఇది ఉద్దేశపూర్వకంగా అలా ఉంటుంది. Compartment seed లేదా recovery phrase ను రూపొందించదు. మీరు స్వయంగా కలిగి లేని credential ను కూడా ఇది నిల్వ చేయదు. కాబట్టి reset చేయడానికి ఏదీ ఉండదు. Passphrase ను password manager లో ఉంచండి. Vault నిల్వ ఉన్న machine కు దూరంగా ఏదైనా 2FA keyfile ను ఉంచండి. Vault లో మీరు కోల్పోవడం ఇష్టపడని సమాచారాన్ని పెట్టే ముందు, ఒక copy ను unlock చేయగలరని నిర్ధారించుకోండి.

రెండు machines ఒకే Compartment vault ను share చేయగలవా?

ఒకేసారి కాదు. Locked vault ఒకే portable file గా ఉంటుంది. Document చేసిన విధానం ఏమిటంటే దాన్ని lock చేసి, copy చేసి, తరువాత --vault తో మరొక machine లో unlock చేయడం. Concurrent access ఉండదు. కాబట్టి రెండు machines ఒకే file కు write చేస్తే memories కోల్పోతారు. అలాంటి అవసరం ఉన్నప్పుడు memory server ను నడపండి.