HN

Comments (144)

• Menu

  gbnwl
  I'm not sure how many HN users frequent other places related to agentic coding like the subreddits of particular providers, but this has got to be the 1000th "ultimate memory system"/break-free-of-the-context-limit-tyranny! project I've seen, and like all other similar projects there's never any evidence or even attempt at measuring any metric of performance improved by it. Of course it's hard to measure such a thing, but that's part of exactly why it's hard to build something like this. Here's user #1001 that's been told by Claude "What a fascinating idea! You've identified a real gap in the market for a simple database based memory system to extend agent memory."
• Menu

  ramoz
  I struggle with these abstractions over context windows, esp when anthropic is actively focused on improving things like compaction, and knowing the eventual* goal is for the models to yave real memory layers baked in. Until then we have to optimize with how agents work best and ephemeral context is a part of that (they weren’t RL’d/trained with memory abstractions so we shouldn’t use them at inference either). Constant rediscovery that is task specific has worked well for me, doesn’t suffer from context decay, though it does eat more tokens.Otherwise the ability to search back through history is a valuable simple git log/diff or (rip)grep/jq combo over the session directory. Simple example of mine: https://github.com/backnotprop/rg_history
• Menu

  ossa-ma
  There are a quadrillion startups (mem0, langmem, zep, supermemory), open source repos (claude-mem, beads), and tools that do this.My approach is literally just a top-level, local, git version controlled memory system with 3 commands:- /handoff - End of session, capture into an inbox.md- /sync - Route inbox.md to custom organised markdown files- /engineering (or /projects, /tasks, /research) - Load context into next sessionI didn't want a database or an MCP server or embeddings or auto-indexing when I can build something frictionless that works with git and markdown.Repo: https://github.com/ossa-ma/double (just published it publicly but its about the idea imo)Writeup: https://ossa-ma.github.io/blog/double
• itissid
  The general process feels very much like having kids over for a birthday party. Except you have to get them all to play nice and you have no idea what this other kid was conditioned on by their parents. Generally it would all work fine, all the kids know how the party progresses and what their roles are — if any.But imagine how hard it would be if these kids had short term memory only and they would not know what to focus on except what you tell them to. You literally have to tell them "Here is A-Z pay attention to 'X' only and go do your thing". Add in other managers for this party like a caterer, clowns, your spouse and they also have to tell them that and remember, communicate what other managers have done. No one has solved for this, really.This is what it felt like in 2025 to code with LLMs on non trivial projects, with some what of an improvement as the year went by. But I am not sure much progress was made in fixing the process part of the problem.
• Menu

  JoshGlazebrook
  Is anyone else just completely overwhelmed with the number of things you _need_ for claude code? Agents, sub agents, skills, claud.md, agents.md, rules, hooks, etc.We use Cursor where I work and I find it a good medium for still being in control and knowing what is happening with all of the changes being reviewed in an IDE. Claude feels more like a black box, and one with so many options that it's just overwhelming, yet I continue to try and figure out the best way to use it for my personal projects.Claude code suffers from initial decision fatigue in my opinion.
• Menu

  coffeeboy27
  What's the data retention/deletion policy and is there a self-hosted option planned? I'd prefer not to send proprietary code to third-party servers.
• Menu

  ChicagoDave
  I use 92% of context, have Claude write a “work summary” to a context folder, commit, push, quit, restart, repeat.I’m never stopped and Claude always remembers what we’re doing.This pattern has been highly productive for 8 months.
• Menu

  qudat
  Have you tried https://github.com/steveyegge/beads
• Menu

  scubbo
  I've been tinkering with building something similar for myself - though for a generic chatbot, rather than for Claude (not every task is coding, and I'd like to keep !). From other comments (e.g. https://news.ycombinator.com/item?id=46428368, https://news.ycombinator.com/item?id=46427950) suggest that many others are already ahead of me. Any recs for tools, libraries, or approaches that I should learn from or adopt? In particular, I've found that - no matter how direct and clear the system prompt is - models have a tendency to respond verbally as if they've made a tool-call recording some gained-knowledge ("thanks! I'll remember that"), but to not actually return the JSON required to trigger the call by the tool.
• Menu

  austinbaggio
  Thanks everyone for the comments, really, I wasn't expecting this.Quite a few of you have mentioned that you store a lot of your working context across sessions in some md file - what are you actually storing? What data do you actually go back to and refer to as you're building?
• Menu

  linsomniac
  The past few weeks I've been experimenting with using less context and less memory and it's been going really well. Where before I'd try to do a bunch of fairly related things in a single session, experimenting with compacting more or less frequently, now I'm clearing my context or exiting and restarting claude and codex. It seems to help it focus on the task at hand, hasn't tended to go off into the weeds as much, and my token costs have dropped way down.Combined with a good AGENTS.md, it seems to be working really well.
• anon
  undefined
• amannm
  There's a lot of people interested in forming some sort of memory layer around vendored LLM services. I don't think they realize how much impact a single error that disappears from your immediate attention can have on downstream performance. Now think of the accrual of those errors over time and your lack of ability to discern if it was service degradation or a bad prompt or a bad AGENTS.md OR now this "long term memory" or whatever. If this sort of feature will ever be viable, the service providers will offer the best solution only behind their API, optimized for their models and their infrastructure.
• Menu

  AndyNemmity
  I don't understand the use case. I think if you don't use agents, and skills currently effectively, then perhaps this is useful.If you're using them though, we no longer have the problem of Claude forgetting things.
• Menu

  ec109685
  This is impressive.Though I have found repo level claude.md that is updated everytime claude makes a mistake plus using —restore to select a previous relevant session works well.There is no way for Anthropic to optimize Claude code or the underlying models for these custom setups. So it’s probably better to stick with the patterns Anthropic engineers use internally.
• zyan1de
  I mostly use it during long Claude Code research sessions so I don’t lose my place between days.I run it in automatic mode with decent namespacing, so thoughts, notes, and whole conversations just accumulate in a structured way. As I work, it stores the session and builds small semantic, entity-based hypergraphs of what I was thinking about.Later I’ll come back and ask things like:what was I actually trying to fix here?what research threads exist already?where did my reasoning drift?Sometimes I’ll even ask Claude to reflect on its own reasoning in a past session and point out where it was being reactive or missed connections.
• Menu

  heliumtera
  Stop Claude from forgetting by telling it to not forget
• Menu

  altmanaltman
  Thank you for specifying it wasn't magic or AGI.
• EMM_386
  Just put a claude.md file in your directory. If you want more details about a subdirectory put one in there too.Claude itself can just update the claude.md file with whatever you might have forgot to put in there.You can stick it in git and it lives with the project.
• robertwt7
  Congrats for this! how does this differs from claude-mem? I've been using claude-mem for a while nowhttps://github.com/thedotmack/claude-mem
• BonoboIO
  Different approach: I continuously refine my global CLAUDE.md (~/.claude/CLAUDE.md) instead of external memory systems.I work primarily in Python and maintain extensive coding conventions there - patterns allowed/forbidden, preferred libs, error handling, etc. Custom slash commands like `/use-recommended-python` (loads my curated libs: pendulum over datetime, httpx over requests) and `/find-reinvented-the-wheel` to catch when Claude ignored existing utilities.My use case: multiple smaller Python projects (similar to steipete's workflow https://github.com/steipete), so cross-project consistency matters more than single-codebase context.Yes, ~15k tokens for CLAUDE.md + rules. I sacrifice context for consistency. Worth it.Also baked in my dev philosophy: Carmack-style - make it work first, then fast. Otherwise Claude over-optimizes prematurely.These memory abstractions are too complicated for me and too inconsistent in practice. I'd rather maintain a living document I control and constantly refine.
• Menu

  sabareesh
  Non starter for us, we cant ship propriety data to a third party servers.
• Menu

  dr_dshiv
  I just ask Claude to look at past conversations where I was working on x… it sometimes thinks it can’t see them, but it can.I’ll give this a go though and let you know!
• Menu

  bilbo-b-baggins
  Your site advertises careers in San Francisco/Remote. California law requires compensation disclosures.
• alex_young
  Doesn't Claude already use RAG on the backend?
• Menu

  senshan
  What is the advantage over summarizing previous sessions for the new one?Or, over continuing the same session and compacting?
• gaigalas
  I like the fact that it forgets.Each time an LLM looks at my project, it's like a newcomer has arrived. If it keeps repeating mistakes, it's because my project sucks.It's an unique opportunity. You can have lots of repeated feedback from "infinite newcomers" to a project, each of their failures an opportunity to make things clearer. Better docs (for humans, no machine-specific hacks), better conventions, better examples, more intuitive code.That, in my opinion, is how markdown (for machines only and not humans) will fall. There will be a breed of projects that thrives with minimal machine-specific context.For example, if my project uses MIDI, I'm much better doing some specialized tools and examples that introduce MIDI to newcomers (machines and humans alike) than writing extensive "skill documents" that explain what MIDI is and how it works.Think like a human do. Do you prefer being introduced to a codebase by reading lots of verbose docs or having some ready-to-run examples that can get you going right away? We humans also forget, or ignore, or keep redundant context sources away (for a good reason).
• fullstick
  I like it when the conversation is new sometimes.
• Menu

  idiotsecant
  Not X, not Y, just slop
• jijji
  every time Claude code loads or it compacts the conversation it loses its context so I always type in: read CLAUDE.md .... which usually solves the problem... I run Claude code on a few screen sessions in different directories for months
• zyan1de
  maybe you are in a claude code session and think "didn't i already make design doc for system like this one?" Or you could even look at your thought process in a previous session and reflect. but rn i mainly use it for reviewing research and the hypergraph retrieval
• graphememes
  stop wasting context space with this stuff ミ · · 彡
• jMyles
  We built one too, with a web frontend and a 'spy' viewer in case your team wants to watch your interactions. Also has secret redaction:https://github.com/jMyles/memory-lane
• Menu

  lloydatkinson
  > Not magic. Not AGI. Just state.Why did you need to use AI to write this post?
• anon
  undefined
• Menu

  CPLX
  I absolutely love this concept! It's like the thing that I've been looking for my whole life. Well, at least since I've been using Claude Code, which is this year.I'm sold.With that said, I can't think of a way that this would work. How does this work? I took a very quick glance, and it's not obvious at first glance.The whole problem is, the AI is short on context, it has limited memory. Of course, you can store lots of memory elsewhere, but how do you solve the problem of having the AI not know what's in the memory as it goes from step to step? How does it sort of find the relevant memory at the time that that relevance is most active?Could you just walk through the sort of conceptual mechanism of action of this thing?
• anon
  undefined
• devhouse
  [dead]
• incoming1211
  [dead]