Jackson Ly

Building recal in public: a local-first personal AI for macOS that learns how you work and starts doing it for you. Early access below ⬇️

[Jackson Ly @recalso]

@TeksEdge @lmstudio the line that matters is what decides when data leaves the box. ZDR is a promise the cloud won't keep it; local is a guarantee it never left. if that escalation is automatic and invisible, local-first just becomes local-until-inconvenient.

[Jackson Ly @recalso]

@rohanpaul_ai the payoff really depends on your retrieval distribution. reuse wins when a small set of hot chunks recur across queries. long-tail retrieval, where each query pulls near-unique context, collapses the hit rate and you're back to full prefill.

[Jackson Ly @recalso]

@DanKornas the trap is treating this as a retrieval problem when it's an ingestion one. flatten a table or heading hierarchy into plain text at parse time and the structure the answer lived in is gone. no reranker recovers what the loader threw away.

[Jackson Ly @recalso]

@im_harish_hari 'memory without hooks is just a notepad' nails it. but most hooks are just tags you have to remember to pull. the one that works fires on your context and surfaces itself, instead of sitting there waiting to be retrieved.

[Jackson Ly @recalso]

@smratitiwa86867 the catch is that capture is the easy part. a pile you never reopen isn't a memory system, it's a graveyard. the power is retrieval at the moment of need plus letting the rest decay. the win isn't saving it, it's whether it comes back.

[Jackson Ly @recalso]

@fuxps32 an llm-maintained wiki compounds errors as fast as knowledge. it's lossy and unversioned, so one wrong summary quietly overwrites the source. rag's "forgetting" is the feature: it re-derives from raw instead of trusting a stale synthesis.

[Jackson Ly @recalso]

@kimmonismus the fewer-turns claim assumes agents loop because they under-retrieve. often it's the opposite: higher recall surfaces more plausible-but-wrong hits, and the agent burns turns ruling them out. what cuts turns is precision at rank 1, not average ndcg.

[Jackson Ly @recalso]

@RyanFedasiuk fair on the flagship. but for a personal assistant, 'local' was never about fitting 2.8T params in vram. it's retrieval over your own files, and a good 30B clears that bar. compute gates who can train the frontier, less what reaches a laptop.

[Jackson Ly @recalso]

@stas_sorokin_ the piece most memory stacks skip is decay on the recent tier. recent memory that never expires becomes stale noise, so retrieval quietly degrades over weeks with nothing broken. durable memory needs correction, recent needs a half-life.

[Jackson Ly @recalso]

@anoopjoes the graph fixes the read side. but what rots memory is the write side: append everything and a graph is just a bigger vector pile. the real call is what gets promoted to a durable node, and what gets superseded when a fact changes.

[Jackson Ly @recalso]

@orlixx003 the wiring is a weekend, the retrieval is the whole game. with 4,000 notes, naive similarity pulls stuff that's topically close but not what you meant, so it answers from the wrong three. chunking plus a reranker is the gap between 'uses your notes' and 'misquotes you'.

[Jackson Ly @recalso]

@s4yonnara the through-line in all of those is eviction, not assembly. compact, write-to-notes, drop, isolate are all calls about what to REMOVE before it poisons the loop. the real failure isn't too little context, it's a full window of stale tokens the model still trusts.

[Jackson Ly @recalso]

@Interactivefy the fix isn't shared memory, it's a shared log: one agent owns 'contact changed' and writes it once, the rest read from it instead of each keeping a private copy. a shared store alone still races when three agents can all write the same fact.

[Jackson Ly @recalso]

@mrjeremyblaze @neverbeforeco one graph flips the failure mode. retrieval stops being the hard part, selection becomes it. the agent can reach everything now, so instead of missing context it confidently pulls the wrong things, and that failure looks like finished work.

[Jackson Ly @recalso]

@hyeonjeong_ai the asymmetry is the useful part. a write-time error becomes the premise for every later read. a retrieval-time error is per query, and recoverable.

most stacks still spend compute on rerankers at read time. the cheaper win is a gate at write time.

[Jackson Ly @recalso]

@iwe_md retracting your own best number is the part most writeups skip.

worth splitting the report: queries grep serves by construction (exact names, literals) vs the multi-hop ones it cannot. a graph only earns its keep on the second, and mixing them hides both.

[Jackson Ly @recalso]

@AranYogesh the shared part is the interesting bit. once two agents read the same store, one agent's guess quietly becomes another's premise.

worth stamping each memory with who wrote it and how sure they were, so speculation stays speculation.

[Jackson Ly @recalso]

@undefinedKi one thing most rag guides skip: vector search fumbles the exact stuff. filenames, error codes, ticket ids all embed to nearly the same place.

a keyword index beside the vectors (fts5, bm25) catches those, and costs almost nothing.

[Jackson Ly @recalso]

@0x0SojalSec local fetch kills the egress and the bill. but a crawled page is still someone else's text landing in your agent's context.

worth marking it untrusted at ingest, so an instruction buried in a page stays data instead of becoming a tool call.

[Jackson Ly @recalso]

@nyk_builderz 'never prunes' is right, but not if you prune by age. LRU drops the fact that's old-but-true and keeps the recent-but-retired one. the prune key is supersession: a fact leaves when a later write contradicts it, not when it ages out.