Compartment: Offline at Encrypted na Agent Memory

Ano ang naiibang ginagawa ng Compartment

Ang Compartment ay isang agent memory store na nag-e-encrypt ng bawat record sa machine na lumikha nito at hindi kailanman kumokonekta sa network service. Dalawang katangian ang naghihiwalay dito sa iba pang bahagi ng agent memory field. Ang vault ay isang sealed file na passphrase mo lamang ang makapagbubukas, at lokal na tumatakbo ang embedding step. Dahil dito, hindi kailanman ipinapadala kahit saan ang text ng memory upang gawing vector. Inilabas ang Version 4.6.0 noong 10 August 2026, Apache-2.0 ang licence nito, at nag-i-install ito mula sa PyPI.

Pahayag ito tungkol sa threat model, kaya ganoon din ito itinuturing ng guide na ito. Pinoprotektahan ng encryption at rest at offline design ang isang partikular na listahan ng mga bagay. May iba pang bagay na nananatiling lantad, at doon nagmumula ang mga problema sa ikalawang araw.

Sinusunod ng guide na ito ang sariling documentation at release notes ng proyekto, na binasa noong 11 August 2026. Nagre-release ang Compartment ng desktop application, menu bar item sa macOS, at notification area icon sa Windows, bukod pa sa command line tool nito. Hindi maaaring kontrolin mula sa automated container ang passphrase prompt. Ituring ang mga sumusunod bilang documented behaviour, hindi bilang behaviour na sinukat dito. Patakbuhin muna ito sa isang ekstrang machine bago ito pagkatiwalaan ng anumang totoong data.

Ano talaga ang pinoprotektahan ng encryption at rest

Sinet-seal ang vault gamit ang XChaCha20-Poly1305, isang AEAD (authenticated encryption with associated data) cipher. Ang keyslots na naglalaman ng master key ay bina-wrap gamit ang Argon2id, isang password hashing function na sadyang mabagal at nangangailangan ng maraming memory. Dalawang bagay ang resulta. Ang kopya ng file sa nakaw na disk, sa lumang backup, o naka-attach sa support ticket ay bytes lamang at wala nang iba. Kapag may isang bit na nabago, mabibigo ang authentication sa pagbukas ng file. Dahil dito, magiging malinaw na error ang corruption sa halip na maling sagot.

Naka-encrypt din ang embedding vectors. Mas mahalaga ito kaysa sa unang tingin. Hindi hash ang embedding. Ipinakita ng research tungkol sa embedding inversion na maaaring mabawi ang mga nababasang bahagi ng orihinal na text mula sa vector nito lamang. Kaya ang plaintext vector index na katabi ng encrypted database ay halos katumbas ng pag-iwang bukas sa database. Walang plaintext index na isinusulat ng Compartment sa disk.

Tunay na deletion ang deletion. May sariling key ang bawat record, at sinisira ng compartment forget --shred ang key na iyon. Dahil dito, hindi na made-decrypt ng sinuman ang natitirang ciphertext, kasama ka. Ihambing ito sa pag-delete ng row mula sa database file. Karaniwang nananatiling nababasa ang row sa mga free page hanggang ma-overwrite ito.

Ang offline operation ang kabilang kalahati. Walang ina-upload, kaya walang vendor account na may hawak ng iyong mga memory at walang API key na maaaring mag-leak ng mga ito.

Ano ang Hindi Pinoprotektahan ng Compartment

Nagtatapos ang claim sa boundary ng vault, at mas malapit ang boundary na iyon kaysa sa inaakala.

Binabasa ng agent ang plaintext. Nagde-decrypt ang Recall ng memory at ipinapasa ang text sa agent. Kung hosted model ang agent na iyon, ipinapadala ang memory sa model provider sa loob ng susunod na prompt, gaya ng lahat ng iba pa sa context window. Pinoprotektahan ng encryption at rest ang file. Hindi nito pinoprotektahan ang retrieval. Kaya hindi nagiging mas maluwag ang mga panuntunan sa pag-iwas na ilagay ang mga sikreto sa AI agents dahil encrypted ang store: ang password na naka-save bilang memory ay password na awtomatiko mong ipinapasingit sa prompt.

Bukas ang naka-unlock na vault sa tumatakbong machine. Malinaw itong sinasabi sa security notes ng proyekto. Habang naka-unlock ang vault, nasa RAM ang master key at working set, hindi magagarantiya ng Python na nabura ang isang buffer, at maaaring maisulat ng swap o hibernation image ang memory na iyon sa disk. Hindi kailangang basagin ng malware na tumatakbo bilang user mo ang cipher, dahil maaari nitong gamitin ang vault na naka-unlock na.

Declarative ang identity ng caller. Maaaring paghigpitan ang namespaces ayon sa caller, ngunit nagmumula ang pangalan ng caller sa host process. Kaya ang host na nagsisinungaling tungkol sa pangalan nito ay nakatatanggap ng mga grant na inaangkin nito. Ang namespace permissions ay paraan ng pag-oorganisa, hindi security boundary laban sa isang hostile local program.

Hindi maaabot ng shredding ang mga kopya. Sinisira ng forget --shred ang key sa loob ng kasalukuyang file. Nananatili sa record na iyon ang backup na ginawa bago ang shred, at nabubuksan pa rin ito gamit ang passphrase noong araw na iyon.

Tinatapos ng mahinang passphrase ang usapan. Pinapamahal ng Argon2id ang bawat guess. Hindi nito maililigtas ang passphrase na nasa word list.

Mag-install ng Compartment mula sa naka-pin na release

Kailangan ng Compartment ang Python 3.11 o mas bago. Mabilis maglabas ng mga update ang project, na may tatlumpung version na sa PyPI pagsapit ng 10 August 2026. Kaya i-pin ang version sa halip na kunin kung ano ang kasalukuyang available sa araw ng installation.

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

Dapat i-print ng compartment --version ang version na iyong ni-pin. Kung compartment: command not found ang sagot ng shell, wala sa iyong PATH ang install directory. Sa karamihan ng system, ang directory na iyon ay ~/.local/bin. Iniiwasan ito ng pipx install compartment==4.6.0 at uv tool install compartment==4.6.0 sa pamamagitan ng pamamahala sa sarili nilang path.

Dalawang beses humihingi ng passphrase ang compartment init at walang ine-echo. Ang passphrase na iyon ang tanging key. Walang ginagawang password o recovery phrase ang project. Sinasadya ito: walang credential na hawak ang software na wala sa iyo.

Suriin ang resulta bago ito ikonekta sa anumang service.

compartment status

Ipinapakita ng isang maayos na vault na unlocked ito. Kung locked ang status nito, patakbuhin ang compartment unlock at ilagay ang passphrase. Nagla-lock itong muli pagkatapos ng restart dahil nakadepende ang credential na nagpapanatiling bukas dito sa isang per-boot secret. Sa macOS, ginagamit ng compartment unlock --keychain ang system keychain upang manatiling available ang credential pagkatapos ng reboot.

Kung saan talaga naka-store ang data

Ang default vault ay ~/.compartment/memory.vault. Ituro ito sa ibang lokasyon gamit ang --vault PATH sa anumang command, o gamitin ang COMPARTMENT_VAULT environment variable.

Ang file na ito ang buong store. Nagsisimula ito sa header na naglalaman ng format version at mga Argon2id keyslot, kasunod ang sealed payload, at pagkatapos ay ang mga journal entry na ina-append habang may mga bagong memory. Bawat journal entry ay may length at CRC (cyclic redundancy check) ng length na iyon, kaya nakikilala ang write na naputol dahil sa crash bilang truncated entry at hindi ito binabasa bilang data. Sa compaction, sine-serialize ang vault, nagsusulat ng temporary file, nagsasagawa ng fsync dito, at pagkatapos ay nire-rename ito sa tamang lokasyon. Dahil dito, hindi nakakakita ang reader ng kalahating naisulat na vault.

Ang mahalagang resulta: eksaktong isang path ang kailangang kopyahin ng backup script. Ang kapalit nito: hindi mo ito maaaring i-grep, at hindi mo ito maaayos gamit ang text editor. Kung gusto mo ng memory na mababasa gamit ang cat at ma-commit sa git, ang plain local memory files ng Memmy ang kabaligtarang trade-off. Parehong makatuwirang pagpipilian ang mga ito, depende kung ang kinatatakutan mo ay ninakaw na laptop o tool na nagkakaproblema.

Inaalis ng compartment uninstall ang software at iniiwan ang vault. Ibigay lamang ang --purge kapag iyon talaga ang gusto mo.

Pagsasama nito sa isang agent

Isang command ang nagse-set up ng isang supported client.

compartment integrate --list
compartment integrate claude

Para sa Claude Code, gumagawa ito ng MCP (model context protocol) server entry at PostToolUse hook sa ~/.claude/settings.json, pagkatapos munang gumawa ng backup ng file. Nag-i-install din ito ng /compartmentalize skill sa ~/.claude/skills/, at nagdaragdag ng managed block sa ~/.claude/CLAUDE.md na nagsasabi sa agent na nangingibabaw ang Compartment sa file-based memory na ginagamit nito. Kumpirmahin ang dalawang bahagi:

compartment hook status
compartment recent

Para manual na i-register ang server:

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

Ang ibang MCP-capable host ay gumagamit ng parehong server, kasama ang sarili nitong caller name.

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

Gumamit ng magkakaibang --caller value para sa bawat host. Ito ang label na itinatala ng audit log at ang key na ginagamit sa pagsusulat ng namespace grants. Kaya kung iisa ang pangalan, mawawalan ng silbi ang dalawang ito.

Kung nakapagsulat na ang Claude Code ng mga fact sa sarili nitong memory files, ipinapakita ng compartment import-claude --dry-run kung ano ang ililipat bago magsimula ang paglilipat. Basahin muna ang mga iniingatan ng Claude Code sa memory files nito, dahil kapag nag-import ng isang taong mga tala sa isang bagong vault, mapupuno ang memory store ng mga bagay na hindi naman dapat iningatan ng sinuman.

Gaano kabilis ang local vault

Ito ang mga figure na inilalathala ng project para sa vault na pang-personal na laki. Galing ang mga ito sa documentation nito, hindi sa aktuwal na run dito.

[
  {
    "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
  }
]

Ang pag-store ng isang memory ay tinatayang 40 ms, at ang vector search sa dalawampung libong record ay 0.68 ms para sa 95th percentile. Arithmetic ang batayan ng argumento ng project sa pagpapanatili ng memory nang local: madalas ay mas mahal ang isang network round trip papunta sa hosted memory API kaysa sa median na 11.6 ms ng buong hybrid search dito.

Dalawang detalye sa design ang nagpapaliwanag sa mga search figure. Kapag mas kaunti sa dalawampung libong record, ikinukumpara ng Compartment ang query sa bawat vector. Dahil dito, eksakto ang recall bilang bahagi mismo ng proseso, hindi approximate. Kapag lumampas dito, lumilipat ito sa HNSW (hierarchical navigable small world), isang approximate index na ipinagpapalit ang kaunting recall para sa mas mabilis na search. Itinatala rin ng vault ang SHA-256 hash ng embedding model at tumatangging magbukas gamit ang ibang model. Maaaring ikumpara ang mga vector mula sa dalawang magkaibang model nang walang lumilitaw na error, ngunit walang saysay ang mga score na ibinabalik.

Mga Backup, at ang copy na mabubuksan mo pa sa susunod na taon

Ang naka-lock na vault ay isang portable file, kaya copy lang ang paglipat nito.

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

I-lock muna ito. Kapag nag-copy habang nagsusulat ang agent, maaaring makuha ang journal entry sa kalagitnaan ng append. Bagama't hinahayaan ng CRC framing na laktawan ng reader ang trailing fragment na iyon, mawawala ang memory na nasa loob nito. Sinaselyuhan ng compartment lock --sign ang file gamit ang Ed25519 manifest, kaya mabe-verify ng receiving machine na buo itong dumating nang hindi kailangang hawakan ang passphrase.

Dahil sealed na ang file, katanggap-tanggap na paglagyan nito ang ordinary cloud storage. Dito direktang napapakinabangan ang encryption at rest: walang memory na nakikita ang backup target.

Dalawang babala. Hindi naaabot ng shredding ang mga backup, kaya ang record na crypto-shredded mo ngayon ay mananatiling readable sa copy noong nakaraang linggo para sa sinumang may passphrase noong nakaraang linggo. At isinusulat ng compartment export --plaintext ang buong vault nang walang encryption. Tamang tool ito para sa migration sa ibang system, pero maling file itong iwan sa ~/Downloads.

Kaunti lang ang itabing copies at lagyan ang mga ito ng petsa. Nagiging liability ang memory store kapag walang nagpu-prune nito. Iyan ang dahilan sa kung bakit tahimik na nilalason ng lumang agent memories ang retrieval.

Pangangasiwa ng key, rotation, at second factor

compartment rekey
compartment 2fa enable
compartment 2fa status

Binabago ng rekey ang passphrase sa pamamagitan ng muling pag-seal ng master key sa keyslot ng kasalukuyang file. Nananatili ang lumang passphrase sa mga lumang kopya dahil na-seal ang mga byte na iyon bago ang pagbabago, at walang prosesong bumabalik upang i-edit ang mga ito. I-rotate din ang mga kopya, o tanggapin na mabubuksan pa rin ng retiradong passphrase ang ilang file.

Nagdagdag ang 2fa enable ng keyfile bilang second factor. Pinagsasama ito sa passphrase habang ginagawa ang key, kaya kailangan ang pareho upang mabuksan ang vault. Nangangahulugan din ito na dumoble ang bilang ng mga bagay na maaaring mawala. Itago ang keyfile sa ibang machine, hindi sa machine na naglalaman ng vault.

Para sa mga script at CI (continuous integration), maaaring ipasa ang passphrase sa pamamagitan ng environment variable na COMPARTMENT_PASSPHRASE, at binabasa ito ng unlock --passphrase-stdin mula sa pipe. Mas mainam ang pipe. Nabubura ng ibang process na pagmamay-ari ng parehong user ang laman ng environment variable, at madalas din itong napupunta sa job logs.

Hash-chained ang audit history. Tinitingnan ito ng compartment audit verify at iniuulat ang unang sirang link. Patakbuhin ito pagkatapos ng anumang restore dahil dito lumalabas ang file na tahimik na na-truncate.

Ano ang mangyayari kapag nawala mo ang passphrase

Walang mangyayari, at iyon ang disenyo. Walang reset, walang recovery phrase, at walang address na maaaring sulatan, dahil walang kopya ng key sa labas ng iyong memory at optional na keyfile. Mananatiling file ng mga byte na mukhang random ang vault.

Kaya ang recovery plan ay hindi para sa vault. Para ito sa passphrase. Itala ito sa isang password manager sa araw na patakbuhin mo ang compartment init. Pagkatapos, subukan ito: i-lock ang vault, i-unlock ito gamit lamang ang isinulat mo, at hayaan ang isang agent na magsimulang mag-fill nito kapag gumana na iyon.

Compartment o isang memory server

Ang Compartment ay idinisenyo para sa iisang machine. Nangangahulugan ang pagbabahagi ng pagkopya sa naka-lock na file, o pag-export at pag-import nito. Walang sabay-sabay na writer, kaya kapag itinuro ng laptop at workstation ang iisang file, mao-overwrite ng isa ang mga pagbabago ng isa pa.

Kapag kailangang gamitin ng maraming machine ang parehong memory nang sabay-sabay, server problem na ito. Sinasagot ito ng isang self-hosted na Mem0 memory server sa isang VPS: isang endpoint, maraming client, at memory na nananatili kahit hindi na ginagamit ang laptop. Kailangang malinaw ang kapalit nito. Nagpapatakbo ang server na iyon ng process na maaaring magbasa ng data na ini-store nito, kaya kasama na sa threat model mo ang VPS at lahat ng makakaabot sa API nito.

Pumili batay sa aktuwal na pagkawala na inaalala mo. Kung ninakaw na laptop o vendor na nagbabasa ng iyong notes ang banta, mas matibay na sagot ang encrypted local vault. Kung agent na nakakalimot ng lahat kapag lumipat ka ng machine ang problema, server ang kailangan.

FAQ

Ano ang aktuwal na pinoprotektahan ng encryption ng Compartment?

Pinoprotektahan nito ang file. Sini-seal ang vault gamit ang XChaCha20-Poly1305, bina-wrap ang mga keyslot nito gamit ang Argon2id, at ine-encrypt din ang embedding vectors. Kaya kapag nanakaw ang disk o lumang backup, mga byte lamang na walang mabasang laman ang makukuha. Hindi nito pinoprotektahan ang naka-unlock na vault sa tumatakbong machine, dahil nasa RAM ang master key habang bukas ang vault. Hindi rin nito kinokontrol kung ano ang gagawin ng agent sa memory kapag ibinalik ito ng recall bilang plaintext.

Kung offline ang Compartment, pribado ba ang mga memory ko mula sa model provider?

Hanggang sa ma-recall lamang ang mga ito. Nagaganap ang pag-store at paghahanap nang walang network, at lokal na tumatakbo ang embedding model, kaya walang lumalabas sa machine habang nagsusulat. Sa oras ng pagbasa, tumatanggap ang agent ng plaintext. Kung hosted model ang agent, pumapasok ang memory sa prompt at ipinapadala sa provider gaya ng iba pang laman ng context window. Huwag kailanman mag-store ng credential bilang memory.

Ano ang mangyayari kung mawala ko ang passphrase ng Compartment?

Hindi na mare-recover ang vault, sinadya ito. Walang ginagawang seed o recovery phrase ang Compartment, at wala itong hawak na credential na hindi mo hawak, kaya walang ire-reset. Ilagay ang passphrase sa password manager, itago ang anumang 2FA keyfile sa labas ng machine na nagso-store ng vault, at tiyaking maa-unlock mo ang isang kopya bago maglaman ang vault ng anumang ayaw mong mawala.

Maaari bang mag-share ang dalawang machine ng iisang Compartment vault?

Hindi nang sabay. Ang naka-lock na vault ay isang portable file, at ang dokumentadong paraan ay i-lock ito, kopyahin, at pagkatapos ay i-unlock sa kabilang machine gamit ang --vault. Walang concurrent access, kaya mawawala ang mga memory kapag dalawang machine ang sumulat sa iisang file. Magpatakbo ng memory server kapag kailangan mo iyon.