meraki
every other project on this page assumes memory helps. AIOS runs on it, Creative OS ships on it, Memory Infrastructure records it. Meraki refused the assumption. a correction goes in as immutable evidence, a narrow rule gets proposed, nothing activates until a person approves it, and the next run gets compared against the no memory baseline. if the delta didnt show the system didnt get to exist.
it was built for real. a monorepo, an engine, adapters, tests. archived when the evaluation wouldnt converge. the codebase is still open, the github mark at the top of this page takes you there.
what it is
an evidence → guidance → evaluation → rollback engine
scoped retrieval: subject, project, task type, mode
deterministic packs: identical state + task → byte identical canonical json + sha-256
an archived experiment you can read end to end
what it is not
a model. it sits beside them
an agent framework. it sits beside those too
rag. recall finds old facts, meraki decided which corrections should become rules
self rewriting memory. candidates do nothing until approved
the thesis
a correction is evidence not a rule. "dont call this seamless" proves one result missed one standard. it doesnt prove a permanent preference for every future task. most memory systems skip that distinction and let one frustrated edit become a silent permanent rule.
meraki kept the correction with the task that produced it, proposed the smallest plausible change, waited for approval, and applied it only where its scope matched. the next relevant result became a test of that change.
the pipeline
the four arm comparison
one task four arms. baseline runs bare, the control. raw memory stuffs everything in, the naive version. meraki runs the selective scoped loop. ablated runs meraki minus the specific rule being tested, the arm that asks whether this rule, specifically, earned its place.
the arms run the same tasks in the same order and the verdicts land in an evaluation ledger nobody including me can edit after the fact. a good looking output is not evidence. the comparison is the only question.
the architecture
built as a real monorepo, dependency direction deliberate. applications depend on packages, never sideways. @meraki/core owns the learning behavior: evidence, guidance, learning, profile, runtime. @meraki/contracts is generated from the canonical json schema, never edited by hand. @meraki/auth verifies signed jwts and derives tenant, subject and actor from verified claims, never caller selected headers. @meraki/storage-local persists with atomic file replacement.
the invariants are the design. evidence is immutable. candidates dont touch behavior before approval. identical state and task context produce byte identical rfc 8785 canonical packs with sha-256 hashes so a run is reproducible and a leaked rule is traceable. revocation creates a version, it never erases the evidence that produced it.
two adapters sit on top: an authenticated http api and a bounded mcp server. neither owns learning state. theyre windows onto the engine.
the receipts
the quickstart is the honest demo. one command, four assertions. run it and watch a candidate do nothing before approval, change a related run after it, leave an unrelated run untouched, and come back intact after a restart. thats the loop working. a different thing from the loop being proven. it never got that far.
why it didnt work
evaluation never converged. the tasks i could run cheaply were too small. variance between runs swamped the difference between arms so everything looked like a tie. the tasks big enough to show a real difference were too rare and too slow to accumulate signal. four arms means four times the compute for margins that mostly sat inside the noise floor.
the memory wasnt the failure. as far as the logs could say merakis arm did fine. the failure was that fine isnt provable at the scale i could run at. a system that claims to help and cant prove it is indistinguishable from one that doesnt, so i archived it instead of pretending.
i thought the hard part was the memory system. the loop was built and working in weeks. the part that killed the project was proving it mattered and i walked in with no plan for that at all. building is the entry fee. evaluation is the game.