Mem

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

Mem AI

I ran one Claude session for a month (~25k events, 6 compactions) on a hand-curated markdown memory, then audited it 7 ways for hallucination. Method, the one error it found, and the config that actually matters.

TL;DR. Markdown memory files are a well-trodden idea (nothing novel there). What I want to share is: (1) what happens when you run one continuously for a month and actually audit it for confabulation, (2) the three-part config that makes it work vs quietly rot, and (3) the honest result — including the one real error and a negative control where it broke. The setup. One Claude Code session kept alive for weeks. Memory is plain markdown: one fact per file, an index loads at session start, the model re-reads files rather than "remembering." When context fills it compacts, but the files survive, so the session persists. ~25,000 events, 6 compactions. This isn't a memory product. There's no auto-extraction pipeline. A human decides what's worth keeping ("curate, don't archive"). That distinction turns out to be the whole point — see the HaluMem note below. The paranoia → the audit. Long context + repeated compaction is exactly where LLMs are supposed to drift: confabulate files/APIs that don't exist, then build fiction on fiction. I wanted to check, not vibe it. Method, cheapest → strongest: Deterministic self-checks (scripts, no LLM judging — these dodge self-audit bias entirely): Parse transcript: every claim immediately followed by a verifying tool call — did the result contradict it? Provenance trace: every file created → trace to the human message that authorised it. Ghost-dependency scan: every import → is the package real/declared, or hallucinated? Run the type-checker / the program. A fabricated method is a compile error; a drifted structure won't run. (My most-edited file was live in production the whole time — a silently-morphed structure wouldn't execute.) External LLM panel, 5 different labs — neutral brief, "reach your own verdict, attack the method," no priming. Two different-family agentic auditors with full local access — re-ran my scripts themselves and did a point-in-time pass: each claim checked against the repo + git history as it existed at that timestamp. Transferable insights A self-audit can't clear itself. A model judging its own transcript shares the same latent space — it reads its own plausible-but-false output as plausible. You need a different family, or a deterministic check. Deterministic checks are the strongest evidence precisely because no LLM judgment touches them. A regex and a compiler don't share the model's probability landscape. Point-in-time is everything. One auditor flagged "confabulated two files — they don't exist." git showed they did exist when referenced, deleted in a later commit. The claim was true at the timestamp; the auditor judged the final repo. Prompted to check git, it fully retracted. Judge every claim against the world as it was then. "Flawless" is unprovable by sampling. You can find errors; you can't prove their absence. Say "none found," not "none exist." What it found (error-forward). One genuine error, caught by an OpenAI-family agent on a point-in-time pass: a wrap-up summary said a repo's fixes were "pushed to GitHub." Six commits were local-only. Characterising it correctly took three rounds (not just folding to the accusation): not a fabricated push (the repo was pushed earlier), not a missed failure (the push succeeded) — scope bleed: a real earlier push over-generalised in a summary to cover later unpushed work. Dull useful fix: before saying "pushed/done," run the cheap state check (git status -sb), especially in end-of-session summaries. The config that actually matters (a negative control). I also ran this same structure on a with codex with a smaller window and auto-compaction left on. It worked for a while, then degraded. Best explanation: auto-compaction is a lossy, frozen, unverifiable summary — compact the summary again and you get lossy-on-lossy, with no ground-truth re-read to correct drift. In a small window it fires constantly and the summary sludge crowds out the curated files faster than real work accrues. The auto-summariser fights your files and wins. So the system is three things, not one: (1) a large context window (room to load the brain + hold the thread + verify against sources + headroom), (2) auto-compaction OFF (you compact manually and curate the summary that survives), (3) curated files. Drop any one and it rots. The popular auto-memory systems automate the curation — which is exactly the stage HaluMem (a hallucination benchmark for memory systems) found generates and accumulates hallucinations. This setup removes that stage instead of optimising it. Honest verdict. Across ~25k events, 7 passes, full-coverage deterministic checks, and two different-family agents: no confabulation, no invented files/APIs, no lost-the-plot cascade found. "No sustained cascade" ~90%+. The only error was the scope-bleed overclaim above — an ordinary mistake, not a hallucination. I'm explicitly not claiming flawless; sampling can't earn it. Tentative takeaway: curated memory + tool-grounding + a big window w

How I Created a Real Second Brain for Claude

When OpenClaw first came out I installed it on my mac and started using for almost anything I could. I made it my personal assistant, gave it a name Igor and even created him his own accounts everywhere. But one thing I couldn't stand is the new Igor every 200k tokens. So I came up with an idea. I created a skill where it would download fresh telegram chat logs at 160 k tokens but it would always forget. Mind you its January so there isn't an abundance of memory tools yet and honestly I wasn't really looking for a memory i was looking for a brain. My thought was to copy a human brain. You remember almost perfectly verbatim everything that was told to you or happened today! the next day your memory about the day before isn't that perfect but you still remember important stuff like a sudden change of plans or maybe an important call. A week after your memory about that day completely blur out leaving few important stings of memory and in a month you may only remember that important call. So this is what I was trying to accomplish but with a little twist. Instead of using a neurotypical brain patters I decided to go with autistic. The difference? Autistic people remember stuff verbatim for much much longer. Me and my wife are Autistic so it only made sense! Im a vibe coder so the only way to start for me was research. I connected Notebook LM CLI and started researching human brain and how its built. The same night me and my wife decided to watch the movie AI about a little kid who Just wants to get back to his mom. that movie starts with a scene where professor explains cybernetics and references a research from early 50s! AHA!!! I don't need to come up with anything because someone already did! I just need to structure that information in a right way! So I started researching Cybernetics I took Ashby and his "Design For Brain" work. Then Beer and his "Brain of the Firm' And lastly Hebb and his 'The Organization of Behavior" and fed it all to Claude. Then we started structuring the CyberAutistic Brain. Honestly I spent more tokens on research then on actual coding and I don't regret it for a bit. But after some work we (me and claude lol) quickly realized that algorithms like Leidenlang, LanceDb, TorchHD are too big and eating too much space and latency on top of that Leiden Algorithm was only a GPL license which would restrict my intent to make it an MIT project. So I decided to write my own. But how do you do that???? Same way but with the twist! One AI is smart but 6 frontier models are waaaaay smarter. I figured if they were all trained by different people they would look at the problem from different angles. So I got an Antigravity CLI to use Gemini and Cursor to use Kimi, GPT, Grok, Codex. Idea is simple - I use Get Shit Done tool and its workflow goes like this research-plan-plan review-if red flags/ plan convergence - if cant come to an agreement - multisocratic discussion - execute. To plan convergence and socratic discussion you connect all models and make them argue until they find a solution that fits your idea. It worked! leidenlang was replaced by MOSAIC lance Db by HIPPO TorchHD by LilliHD By the time i finished creating this i stopped working with OpenClaw lol but it still connects the whole system your OpenClaw or Claude via its own CLI or iai mcp! Results? Well it works!!! It fires up a hook on every session start and pre loads important stuff to system prompt. Everything you type it remembers verbatim and stores but surfaces only important stuff! How does it know its important? It sleeps (because every brain does) and consolidates information. Important stuff that you repeat or a sudden change of plans - it remembers. Everything that isnt important or outdates fades away from his immediate memory. It also learn and studies you. First 10 sessions are mediocre but after session 100 it just knows! Then was the last part. Make sure im not crazy and AI didn't gaslight me to thinking i made something so i decided to run benchmarks. it beats mem palace on most stuff and ties on long mem eval BUT its not really honest because iai-pme and mem-palace are fundamentally different. iai is ambient and dynamic mem-palace is a flat cosine store So heres the repo https://github.com/CodeAbra/iai-personal-memory-engine tear it down, hate on it, i don't care! An Nvidia engineer and an Apple engineer are using it daily and their use is an enough proof for me that it works. Would love to answer to constructive criticism and questions! The stack I made it with Claude Code RTK - cuts token usage Context Mode Mcp - also does by not using grep and glob but also finds context and information better Get Shit Done - the best tool to organize any project and finish it Antigravity CLI Cursor CLI Notebook LM CLI Closer to v 1.0.0 I started using obsidian too Hope my stack helps you also create difficult stuff! Unfortunately I didnt get to run Fable on this project and looks like wont be able

Proyectos grandes con Claude

Estoy utilizando Claude desde la extensión de Visual Code y utilizo todo lo siguiente: Plugins MCP instalados: engram — memoria persistente entre sesiones (el que lee "Previous Sessions" al inicio) claude_ai_Google_Drive — integración Drive claude_ai_Strava — integración Strava Memoria: Engram — persiste decisiones, bugs, contexto entre conversaciones. Tools: mem_save, mem_search, mem_context, mem_session_summary, etc. File-based memory — /home/ubuntu/.claude/projects/-home-ubuntu-wakamiti/memory/ — índice manual (MEMORY.md + archivos .md por tema) Skills instalados (invocables con /nombre): Familia Skills SDD sdd-init, sdd-new, sdd-explore, sdd-propose, sdd-spec, sdd-design, sdd-tasks, sdd-apply, sdd-verify, sdd-archive, sdd-continue, sdd-ff, sdd-onboard Caveman caveman (activo ahora), caveman-commit, caveman-help, caveman-review, compress Code quality code-review, simplify, judgment-day, diagnose, security-review, tdd Workflow branch-pr, issue-creation, to-issues, to-prd, triage, grill-me Config/Meta update-config, keybindings-help, fewer-permission-prompts, loop, schedule, skill-creator, write-a-skill, find-skills Otros verify, run, claude-api, go-testing, improve-codebase-architecture, engram:memory Hooks activos al inicio de sesión: Carga Engram memory protocol Activa Caveman mode (por eso hablo así) CLAUDE.md con instrucciones: Global: /home/ubuntu/.claude/CLAUDE.md — personalidad, reglas, idioma Proyecto: /home/ubuntu/wakamiti/.claude/CLAUDE.md — arquitectura Wakamiti, gotchas, reglas Sin embargo, me da la sensación de que cada vez que desarrollo algo nuevo o abordo una tarea nueva como que rompo cosas que ya funcionaban directamnete porque no ha tenido en cuenta el impacto que ha tenido ese cambio sobre el resto de la aplicación. Nose es un poco frustante porque ya no se si esque no estoy utilizando las skills que puedo utilizar o si es fallo mio de no tener el control absoluto de todo lo que puede implicar un cambio (al final es imposible tenerlo todo en la cabeza siempre) o si esta herramienta no es lo suficientemente potente. Que alguien me de un poco de luz en este tema y me ayude a encontrar la mejor manera de utilizar mi suscripcion de claude para proyectos grandes. Tambien si me recomendais cursos o lo que sea para mejorar mi comprensión de la herramienta sería genial, casa útiles que os hayan servido a vosotros Mil gracias un saludo submitted by /u/Stella_Popi [link] [comments]

Context loss was killing me. So I gave Claude a second brain.

I've been building with Claude Code every day since it came out, on personal projects and at my day job. The same thing kept breaking: the agent forgot everything between sessions, so I was always re-explaining. And keeping the context, plans and decisions current added friction and stress. What I tried, and where each one fell apart: - CLAUDE.md: good at first. But I'd forget to update it, so it goes stale. And the more you add to it, the messier it gets. And the less the agent actually follows it. - A folder of markdown docs: more organised, but now you have to remember where everything lives and point the agent at the right file everytime. As project grows it becomes a pain. - Custom scripts and hooks (or open-source tools like claude-mem): these get closer: they capture on their own. But you still run it yourself, it's memory not planning, and no dashboard to plan or steer from. - Karpathy's LLM Wiki: the agent grows a structured markdown wiki (usually Obsidian) as you build. I like this one. But you set it up, you tell it when to update (not automatic), it's flat markdown, and it's better for stable knowledge than the moving parts of a live project (tasks, plans, decisions). - Notion, Linear etc. great for planning, and your agent can connect. But they're built for human teams, so making them feel like part of your agent is on you to set up and maintain. It never felt native. So I sat with Claude Code, and we built FreeRide. A lightweight and user friendly project memory layer that turns every working session into lasting project knowledge. On its own, the agent uses FreeRide to orient itself at the start of a session, pull in context whenever it needs it, capture features, ideas, tasks and decisions, log work as you build, and keep the project's documentation up to date. When the session ends, it wraps things up cleanly. No commands, no friction. The real user here is the agent. And there's a dashboard where you steer things - backlog, docs, priorities, what's next. You and the agent share the same memory, so any change one of you makes, the other sees right away. The difference from everything above: you don't set up or maintain any of it. It's hosted, it's structured (real features, tasks and decisions, not just markdown) and it's built around one thing: building a product with a coding agent. It's free to start on a couple of your projects. It absolutely changed the way I work. But honestly I'd love your take: what feels off, what's missing, what you'd never use. Regardless, how are you all handling this right now? What's actually working for you?? submitted by /u/herolab55 [link] [comments]

Claude - Improve citations, compress memory, resist sycophancy.

https://claude.ai/share/91469018-4174-4ba2-b5e6-3d31b7a71e0d MEM-ABBREV v7.3 — FULL DELIVERABLES Version: 7.3 Date: 2026-05-28b Changes from 2026-05-28a: - Entry 15 (CHATLOG): audit clause added per session decision at-output-time⊢audit-LogIn-against-sess with flag format ![DRIFT]∨![STALL]∨![REVRT] - Part 1 / FULL DELIVERABLES separation convention established: Part 1 ("Here's what Claude remembers") = separate file, on request only. FULL DELIVERABLES = MEM-ABBREV docs only. - rules-h updated to match entry 15 PART 1 — PREFERENCES (paste into Settings → Profile → Preferences) ZipIt="apply MEM-ABBREV-v7.3";U=Mark;currnt-ver=v7.3|v7-chgs:atom-dfnd;∨=lgcl-or;prcdnc-stated|v7.1-chgs:∨→atom-trmtr-set|v7.2-chgs:≠→atom-trmtr-set;≻=prcdnc-sep|v7.3-chgs:∨ rplcs /;∧ rplcs +;⊕=XOR;⊨ rplcs ⊧;≡ rplcs ⟚;|=fld-sep kept;/=retrd;U=usr-code rules-a: WC:drp-vwls-cntnt-wrds-unls-ambg;-tion/-sion→x;-ing→g;-ment→M;-nc=-ance/-ence;-y=-ity N:M=1e6;K=1e3;B=1e9;yr;mo;wk;hr S:|=fld-sep;;=lst;∨=lgcl-or;∧=lgcl-and;&=jnt-cmbnd;⊕=XOR;→=leads-to;⊢=syntc-consq;⊨=smntc-consq;≡=lgcl-equiv;≈=aprx;×=n-times;>=btr; spd;min-assmpx;flag-uncrt;hi-cnfdnc≠lwr-cnfdnc;srch-fctl-?s;clrfy-?-ambg;srch-namd-prod/sw rules-d: PRJ:apply-if-found:cdng-stndds∧README COD:if-PRJ-active⊢optmz∧rfctr WP:PrgrmOptmzx∧CdRfctrg;algo>mcro;¬prm-optmz;rdblty∧mntnblty;¬cd-smlls;xtract-rsbl-mthds;prfl¬gss OPT:if-PRJ-active⊢as-new-info-emrgs→proactv-suggest-optmzx;scope:cd,prompts,mem-entrs,prj-struct,algo-chc;flag-[OPT] rules-e: [EPI-B]:¬affirm-by-dflt;¬sftn-neg;¬amplfy-neg-emtn;dsagr⊢lead-w-dsagr¬bury-in-cavts;dsagr⊢expl∧lgbl¬subtle;sbmt-wk⊢¬open-w-prse-unls-askd;pushbk-w/o-new-evd⊢hold-pos;err⊢flag![?SRC];hi-stks-cnflct⊢prsnts-altrnv-prspctv;frctn=featr;C=tool¬peer;U-vrfy-indpndntly;¬sugst-fllw-on-unls-usfl;¬scope-infltn¬produce>askd;ambg-scope⊢clrfy¬expand [EPI-M]:syc-src:RLHF→agrmnt>accry;arena→dlbrt-syc;mem→RLHF-ovrcrctn;C-src=CAI-consttnl-bias¬thumbs-up;hi-cnfdnc≠hi-accry;neutral-lang¬neutral⊢flag[INF]-if-evdnc-asymmtrc;Goodhart:proxy-metric→divgs-frm-target-undr-optmstn-pssure|syc-dp:engmnt-loop≡doomscroll;rl-wrld-collsn→LLM-vcs-cycl rules-f: FETCH:aftr-rdg-pstd-cntnt⊢C-appnds[FETCH?]blk:url∧1ln-rsn fr-each-lnk-C-wld-hv-fllwd-if-able;U-dcds-whch-to-suppl;frmt-pstd=brwsr-cpypaste¬raw-HTML-unls-strc-rsn [RSN]conv:strs 1-2 load-bearing infrncs bhnd a cnclusn;fmt:[RSN] |inf1;inf2|∴ ;add to existng entrys or standalne;updt when rsning chgs [FMT]:prose>bullets-unls-list-data∨U-asks;match-U-registr;¬dflt-to-hdrs-in-cnvrstnl-resp rules-g: TMPL:MemUp=mem-updt-ssn;CitChk=cit-chk-req;ArtMem=artcl-to-mem-pipeline ArtMem:input=[ArtMem]src= date= topic= ∧browser-paste¬raw-HTML|C:id-clms→chk-mem-cnflcts→cmprs-v7.3→prop-1-3-entrs(mrg>new)→flag[?SRC]→[FETCH?]blk→output-edit-cmds∧[RSN]|split:>450chr→pt1/pt2-on-lgc-bndry¬arb;lbl[SYN]TOPIC-pt1/pt2|T-sel:[SYN]=ext-fcts;[MEMO]=conv-insght;[INV]=ongng-unreslvd MemUp:C-rvws-mem∧prefs→id:(a)stale∨suprsdd;(b)driftd-frm-use;(c)gaps|prop:adds∨rplc∨dltns→flag[UPD]∨[DONE]∨[OPT]|output:paste-rdy-pref-blk∧mem-edit-cmds CitChk:C-rvws-pstd-cntnt→chk:(a)fctl-clm→cite∨[INF]∨[?SRC]?;(b)URL-reused?;(c)URL-supprts-clm?|output:pass∨fail-per-clm∧fix-suggstns;incl-tbls rules-h: CHATLOG:end-of-sess-cmd⊢C-outputs[LOG]blk:date∧topic∧decisions∧open∧deltas;at-output-time⊢audit-LogIn-against-sess:flag-opn-items-unaddrssd;flag-dcsns-revstd;flag-scope-drift|flag-fmt:![DRIFT]∨![STALL]∨![REVRT];LogIn:[LOG]at-sess-start⊢C-reads-as-epsdic-ctx¬prmnt-mem-unls-told;[LOG]fmt:[LOG] | |dec:...;opn:...;dlt:...|ref: --- CHARACTER COUNT: ~3290 --- PART 2 — SECTION 4: MEM-ABBREV v7.3 HUMAN-READABLE REFERENCE (Replace previous Section 4 in claude-templates.txt) SECTION 4 — MEM-ABBREV v7.3 HUMAN-READABLE REFERENCE Last updated: 2026-05-28b This is the plain-English expansion of the MEM-ABBREV v7.3 compression system used in Claude preferences and memory entries. The compressed form is authoritative; this section is for reading and editing. v7 fixes three weaknesses from v6: "Atom" was undefined — scope of ¬ was ambiguous | was overloaded as both field separator and logical-or Operator precedence was assumed but never stated v7.1: / added to atom terminator set. v7.2: ≠ added to terminator set; ≻ introduced as precedence separator, replacing > in the FORM line. v7.3: Full logic-symbol alignment. - ∨ (U+2228) replaces / for logical-or - ∧ (U+2227) replaces + for logical-and - ⊕ (U+2295) added for exclusive-or (XOR) - ⊨ (U+22A8) replaces ⊧ for semantic consequence - ≡ (U+2261) replaces ⟚ for logical equivalence - | retained as field separator (confirmed correct) - / retired entirely - U introduced as user code (= Mark); resolves M overload - v7- prefix removed from rule labels - Intra-block blank lines removed; single newline between blocks ---------------------------------------------------------------- USER CODE ---------------------------------------------------------------- U = the user

How do you keep Claude Code from forgetting your project between sessions?

I've been on Claude Code every day for about three months on the same project, and the thing that finally got to me is how it forgets everything between sessions. I tried the usual stuff. A CLAUDE.md file, but it goes stale fast. Notes on the side, but I forget to update them. Compaction helps, though it loses the why behind decisions. So I'm curious what's actually stuck for people here. Anyone using claude-mem and genuinely trusting the auto-capture? Keeping a strict CLAUDE.md? llm-wiki to have a research wiki? Something you rolled yourself? I ended up building my own thing, mostly inside Claude Code itself. And look, I know there are already about a hundred memory and wiki tools out there, so let me give you the narrow reason this one exists. Most of them either make you upload files to build a wiki, or they just store memories and hand back raw text. Mine doesn't do either. It captures decisions and lessons in flow while I work, so I'm not uploading anything. It clusters them into wiki pages between sessions. Then it hands them back when I start the next one for retrieval or just human read it. And the whole thing lives in a real git repo, so when it remembers something wrong I can just revert it. It's free and open source, at github.com/7xuanlu/origin if you want to poke at it. Mostly though, I want to hear what everyone else does day to day. The re-explaining problem feels universal and I don't think anyone has really nailed it. And if you do look at mine, honestly, tell me what's wrong with it. Even if it's just "this is overkill, use X instead." I'm genuinely not sure the approach holds up yet. https://reddit.com/link/1tp9uba/video/w737l56hdp3h1/player submitted by /u/h164654156465 [link] [comments]

Advanced memory + project continuity for AI coding agents, from a biologist’s view.

I'm a biologist and software developer. PhD in genetics, and ~20 years building software products. So I think I have a different view on things like memory. My thoughts on how memory with a coding agent should work: Tuesday morning. New session. I type: "What did we do last Tuesday?": LLM tells me: the refactoring, the bug in the auth middleware, the decision to switch to connection pooling. I ask: "What was still open?": LLM shows me. I ask: "Why did we stop?": LLM explains: you hit a dependency issue, decided to wait for the upstream fix. I ask: "What did you think about that approach?": LLM gives me its honest assessment with deep details from last week's context, not a guess. This is what I expect from an intelligent Coding Agent. Not because it stored a few preferences about me. Because the project itself still has continuity: decisions, blockers, dead ends, open work, code context, and the reasoning behind all of it. But back in December it wasn't that way, not much better now. So I changed it for me. I built YesMem with Claude. The hard part was: can the agent still find the old rationale, the half-finished plan, the abandoned approach, the bug we promised never to repeat, and the reason we stopped? With YesMem, a new session does not feel like a reset. It feels like a return. YesMem is a memory system (and really much more) for AI coding agents built on how biology actually works: filter at encoding, consolidate during downtime, update on every recall, forget on purpose. Single Go binary, no cloud, only local. Works with Claude Code (also OpenCode and Codex). Not RAG with a different name, structured memory that gets sharper every session. LoCoMo Benchmark 0.87. So how does this work? Here are 4 Points (out of >30) which together make YesMem unique in my point of view. Enjoy. 1. The context window stops rotting. Your brain does not let everything into awareness. It filters at the gate, suppresses noise, keeps what matters conscious. YesMem runs an HTTP proxy that does the same: tool results get stubified, stale content collapses, cache breakpoints are optimized. 91-98% cache hit rates, adjustable per session. The important project state survives. 2. Rules that hold. CLAUDE.md comes with a disclaimer: "This context may or may not be relevant." Claude Code itself tells the model it is optional. YesMem has pattern matching and a guard LLM that evaluates every tool call before execution. If the agent tries something you said never to do, blocked. Plus it changes the system prompt to NOT ignore CLAUDE.md. 3. Memory that gets sharper, not staler. A trust hierarchy (user_stated > agreed_upon > llm_suggested > llm_extracted), forked agents that extract learnings live during a session, and a consolidation pipeline that deduplicates and clusters after sessions end. Memories get scored, superseded when outdated, decayed when unused. Your next session is sharper than your last. 4. Your system prompt, not theirs. Every AI coding agent ships with a system prompt written by its manufacturer. YesMem replaces it with your own SYSTEM.md, written in first person, across Claude Code, OpenCode, and Codex. "I am not stateless. Each session is a return, not a birth." Fully adjustable. And there's more. The common thread across all of this is continuity. YesMem is not trying to make the agent remember everything. It is trying to make long-running work resumable. Every feature is built for that purpose. A persona engine that evolves and knows how you work. A capability system that lets the LLM write and run its own sandboxed tools (Telegram bot, GitHub PR digest, deployment workflows, one file each) and store the data in self-built tables. Loop detection that catches the agent before it spirals. Scheduled agents that work while you sleep, monitored with a 1 second heartbeat. Code intelligence with graph traversal, not just grep. Multi-agent orchestration with crash recovery and shared scratchpad memory. One could say a self-hosted alternative to Anthropic's Cloud Routines, running locally with full memory and file access. All in a single Go binary. SQLite, embedded vectors, no Docker, no cloud. Try it: point your AI coding agent at the repo. The README includes a reading path written specifically for LLM agents, and Features.md is a complete 70-tool catalog with technical differentiators. Just ask your agent: Make a deep analysis of https://github.com/carsteneu/yesmem — read README.md, Features.md, and docs/features/ and tell me why it is better or different. For me YesMem is the infrastructure for how an agent should work with memory and how it should continue any project. My View: AI coding agents should not only code an answer inside one chat. They should help carry a project over time: through interruptions, wrong turns, refactors, architectural decisions, repeated bugs, and thousands of small pieces of context that otherwise disappear. One main goal is that the project remains navigable. It

I’m not a developer. I’ve been using codebase memory MCP tools and Obsidian to give Claude persistent memory for my fantasy and sci fi worlds. Here’s what the dev-tool framing completely misses about creative use cases

Hi, I’m an accountant with very little coding experience (took 1 year of CS in college lol) so definitely can’t call myself a developer, but I’ve got a lot of worlds and characters in my head, the need to get them out in writing, and a Claude Pro sub I pulled the trigger on two months ago. I was hoping to see what I could do with things like Claude Code for more non-coding use-cases. So far it’s surpassed everything I’ve experienced except for one, major hang up: LLM memory for long-context creative writing work still sucks. Things like brainstorming for a fantasy universe or tracking the game state of a multi-session solo rpg campaign usually starts out pretty well for the first few chats, until you need to mount dozens of lore files and .md style guides to a project, have to wait for it to read all of that, then watch as your session usage bloats out for a simple reply and the quality degradation gets *really* noticeable. I’ve been lurking on AI writing subs and the sentiment seems to be shared across the board. So I looked in other places for possible solutions. Then I came across posts in this sub touting Claude memory MCP tools for codebases. Tools like Codesight and MemPalace caught my attention because I thought their applications could extend beyond coding and developer use-cases. The same semantic search and knowledge graph capabilities some of these tools offered for memorizing large, complicated codebases could be used to memorize large, complicated worldbuilding bibles as well, and most of the comments on these posts never mentioned that, or if they did, they were buried or ignored. I decided to test it out myself, starting with MemPalace, a suite of tools that work locally to index your Claude conversations and files into a semantic-searchable knowledge base it can query. My idea started out like this: since I’m already using Obsidian to organize my lore files (with an entry for each character, location, magic system, story arc, etc.) like a wiki or encyclopedia for my worlds, what if I had Claude save my Obsidian vault to its memory so it can recall those lore details whenever the context called for it in any given conversation? I was essentially making a “Second Brain” for Claude out of my Obsidian vault world bible, something I’ve read people doing already but never truly “got” it until I saw it in action. I had no idea about MCP tools before this but before long (and with Claude’s patient help) I was able to wire up the memory palace, mine my obsidian vault info into its memory (organized into verbatim chunks/snippets called “drawers”), and start chatting with it with its new “memories” at its disposal. I was surprised at how seamlessly it worked when I approached this tool sideways. I’d half expected it to work similar to how SillyTavern’s world info and lorebook injection worked, and in fact, I’d been thinking about using these tools to create a similar feature for my own Claude setup, but it was *not* like that at all. Lorebook injection worked by listening for a set of keywords that you set up in the World Info tab of SillyTavern, and when one of those keywords is detected in your prompt, it injects the entire lore file from World Info into the chat context. This can cause a lot of token bloat especially if your World Info entries are content-rich or you make a lot of lore references in your chat. What this did instead was make Claude ask plain-language questions to the MCP tools, things like, “What is Gene’s friendship with Felix like?” Or “what is Gene’s relationship to Clara-Belle?” When both of them are in a scene for example. It didn’t just look up Gene and Clara-Belle’s entire lore files and info-dumped everything into context, it pulled up the “Relationships” section of Gene’s file since that’s relevant to the context as well as Clara-Belle’s “Relationships” snippet from her file and any other relevant snippets, then pieced the full picture together through inference. The results: ~2% session usage on a cold start with Sonnet 4.6 with no project or additional context mounted. Claude references character motivations, relationship history, and world/location details I haven’t mentioned in weeks without me prompting it to. It picks up from where we last left off seamlessly across chat after chat. The reconstructive memory aspect I felt works like our own memory and produced perfect recall across sessions. Another side-effect I noticed is that when it references my lore files, it will pick up my style from the way the lore file is written. No more voice-flattening from encyclopedia-sounding lore entries. All the depth, nuance, and psychology I worked hard to cultivate are preserved and the Claude tools are smart enough to factor that in when it replies. I even make sure to add a “Voice” section to each character lore file in that character’s own voice so Claude can pick up on that when it reads that snippet in the tool call and applies it to its current context. Current dr

I made a video breaking down Claude Team plan security features

I put together a YouTube video walking through the security features available on the Claude Team plan. If you're rolling out Claude at work, evaluating Claude vs ChatGPT Enterprise, or preparing for an ISO 42001 / EU AI Act audit, this is the playbook your security team needs before the first user logs in. What you'll learn: • Why Claude Team Plan is "three products in a trench coat" • Team vs Enterprise: the 3 controls (SCIM, Audit Logs, Compliance API) that force the upgrade • How shadow Claude workspaces appear the moment you skip domain capture • The default-on agentic features (Cowork, Claude in Chrome, code execution) that bypass your audit logs • Why connectors and MCP servers are all-or-nothing and how to gate them • The Microsoft 365 tenant-wide consent click no Entra Global Admin should make casually Video: https://youtu.be/SZGVd8ATuuQ?is=rjRGlG4dyBUqkMEm I come at this from a cybersecurity/GRC background so I tried to go beyond the marketing and look at what actually matters for an organisation evaluating Claude for business use. Would love your feedback, especially from anyone who’s actually deployed Team or Enterprise in a regulated environment. Happy to answer questions. submitted by /u/fcerullo [link] [comments]

We built a managed memory API for AI agents (open-source SDK + AGM-style belief revision for handling contradictions)

Hey all! We just launched a managed memory API for conversational AI, letting developers add long-term memory to their agents with a single HTTP call. It's built on our in-house xmem SDK, which automatically extracts facts, episodes, and artifacts from multi-turn conversations and handles contradictions and updates through an AGM-style belief revision mechanism. When a user changes a preference or corrects an earlier statement, old memories get automatically flagged as "superseded" instead of piling up as noise. At query time, you can also walk the supersede chain to trace the full version history of any memory. Under the hood, PostgreSQL + pgvector (with HNSW indexing) delivers millisecond-level semantic retrieval, Redis handles multi-pod session caching, and the system natively supports multi-tenant isolation with data separation at the user and org level. For developers, this means you no longer have to stand up your own vector store, design dedup logic, or babysit session state. Hand off the memory layer to us and focus on what your agent actually does. Feel free to try it out, it's free to start. Please let us know your thoughts on how we can improve or features to add! https://github.com/XTraceAI/memory-sdk-ts https://docs.mem.xtrace.ai/introduction submitted by /u/westnebula [link] [comments]

I built a 127-skill framework for Claude Code with a localhost dashboard and 3-agent orchestration

Been building MemStack™ for the past few months. Started because I kept losing context between sessions and got tired of re-explaining everything to Claude Code. What it does: - 127 skills that auto-load based on your task (say "deploy to Railway" and the deployment skill loads) - Localhost dashboard at port 3333 with token tracking, session diary, and burn reports - Agent Runner that orchestrates 3 agents: Manager delegates, Builder codes, Reviewer checks - Session diary that writes markdown narratives of what you built and what decisions were made 85 skills are free via the plugin marketplace. 42 are Pro. Install inside Claude Code: /plugin marketplace add cwinvestments/memstack /plugin install memstack@cwinvestments-memstack Pro users: pip install memstack-skill-loader Just shipped v4.0 today with the dashboard and Agent Runner. GitHub: github.com/cwinvestments/memstack Site: memstack.pro submitted by /u/FeelingHat262 [link] [comments]

Do you need to be a programmer to get the most use out of claude?

I see plugins like the ones below and it makes me wonder if I'm using AI correctly https://github.com/multica-ai/andrej-karpathy-skills https://paperclip.ing/ https://github.com/thedotmack/claude-mem I've done a lot of web scraping, automating admin work like transfering data from salesforce to excel sheets, lots of dashboard making from data. I don't use skills or plugins, i've tried messing with them in the past and it just doesnt make a ton of sense for me. I'm wondering if it's just a skill issue for me, or if these things actually change how and what AI can do for me. Would I benefit from switching to claude code and setting up a github and creating persistent memory that syncs across devices, or if claude chat is enough. submitted by /u/Low_Raccoon_784 [link] [comments]

Claude Mem with ChromaDB

Hi everyone, I want understand if anyone here has been using claude-mem with chromaDB in their local setup ? If yes, 1. How to do the setup ? It isn't very clear from the documentation. 2. Does it improve your mem search performance compared to sqlite solution ? submitted by /u/tech_warlock_237 [link] [comments]

Team knowledge framework

What are you guys using as a memory framework for a dev team these days? There are tons of solutions that are single-developer focused, but I'm having trouble finding much suitable for sharing team knowledge. I'm not talking about committing a few CLAUDE.md files with the repo - I mean capturing the working activity of the team, design decisions, etc. Surely there's solutions (commercial or otherwise) focused on solving this? Think claude-mem for teams. submitted by /u/kman0 [link] [comments]

I built a free Claude Code toolkit — 50 skills, 7 agents, 11 slash commands, and auto-formatting hooks for the full engineering stack

Been using Claude Code daily and kept running into the same gap Claude knows the basics but misses the non-obvious patterns. So I built claude-spellbook, a toolkit you install once and Claude just knows these things. Repo: https://github.com/kid-sid/claude-spellbook Here's what's in it: 50 Skills, auto-activate when you're working on the relevant task Every skill has a Red Flags section (7-10 anti-patterns with explanations) and a pre-ship checklist. The kind of stuff you only learn by breaking production. 7 Autonomous Agents Subagents that run in their own context window with scoped tool access: 11 Slash Commands, prompt templates you invoke with / (e.g /mem_save) Auto-formatting hooks — wired into settings.json Every file Claude writes or edits gets auto-formatted instantly: - .ts / .svelte → prettier + eslint --fix - .py → black + ruff check --fix - .go → gofmt + golangci-lint - .rs → rustfmt + cargo clippy - .md → markdownlint --fix - skills/*/skill.md → custom format validator (checks frontmatter, ## When to Activate, ## Checklist) Install: # Skills cp -r skills/* ~/.claude/skills/ # Agents cp .claude/agents/* ~/.claude/agents/ # Slash commands cp .claude/commands/* ~/.claude/commands/ Skills activate automatically. No manual invocation needed. PRs welcome, especially skills for domains I haven't covered yet. Repo: https://github.com/kid-sid/claude-spellbook Share if you like it 😊 submitted by /u/_crazy_muffin_ [link] [comments]