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.
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.
an agent output misses. you say what missed the mark and what youd choose instead
the correction lands as immutable evidence: task, source, outcome, hash. nothing in the ledger can be edited, only added to
a candidate rule gets derived from the evidence: narrow wording, explicit scope. it changes nothing yet
a person or an explicit policy accepts, weakens, rescopes or rejects it. no approval no activation
a matching task gets the approved guidance inside a scoped pack. an email task gets email rules, the poem task stays clean
the output gets compared against the no memory baseline. the delta is the entire product. keep, narrow or revoke
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.
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 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.
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.