Two things that didn't fit in the post:

What's an "egregore"? Old word for a group-level entity sustained by the people holding it together. We picked it because it's literally the technical thing we built. The name is a shibboleth; use whatever framing works for you.

Who this probably isn't for yet. If you're a solo developer, Claude Code by itself is likely enough — Egregore's weight only pays off when more than one person is writing into the substrate. We'd rather say that now than have you install it and bounce.

Ask us anything — install problems, mechanism-design questions, the "how is this different from X" comparisons, and whether any of this survives a real team that isn't us. Especially the last one.

we were essentially working on dynamic ontology systems (how to organize unstructured data given context / starting conditions dynamically). since december new capabilities that came around with opus 4.5 completely altered the nature of our work. but despite the radical increase in speed and ambition of our experiments, we were visibly diverging from a common vision. once we acknowledged that together, we decided to find ways to infrastructure mechanisms for convergence. first it was integrating the GitHub organization and repos we are working on, later we developed custom commands that would help us share research, request code reviews and even send each other spam through a tg connector we built for notifications :)

https://imgur.com/a/egregore-telegram-notification-LM0ldPV

we then realized we can integrate the agentic knowledge graph infrastructure we were building for the dynamic ontology research. our stack emerged very rapidly and one week in it was glaringly obvious that we should stop everything and get to working exclusively on this. the speed of accumulation of multi-agent context coupled with frontier model capabilities yielded wow moments one after another. for two months we implemented key features and improved core functionalities.

given our background in organization design and distributed systems, we knew that this was a primitive that should be spread widely and experimented with since there is no single good answer to how an organization should be designed. but it was clear to us that using agent harness form factor as an organization design substrate is incredibly promising given: speed of context accumulation, the continuity (handoffs) it enables between individuals and adaptability of the organization to changing (internal and external) conditions.

anyway, after couple months of wow-ing to our own creation we knew we had to get this out and face the moment of truth whether: we actually built something interesting or we are getting high off our own supply. so thats what we are doing today: we created a version of egregore — slash commands, git-backed markdown memory, Claude Code hooks — that is self-hosted and without dependencies (no knowledge graph etc) so that we can release it as a viable open-source primitive anyone can use and mutate according to their needs with their friends and colleagues.

what you can do with it today:

- `/invite` — onboard a teammate with the full accumulated context already in place - `/handoff` — pass a session on with reasoning and context preserved. the next person, future-you, or their agent picks up the thread without restarting - `/activity` — see what the team has actually been doing, synthesized from real sessions - `/deep-reflect` — cross-reference an insight against the organization's full memory - `/view` — render a shareable artifact from any slice of what the team knows

excited to have you all try, and get your feedback.

Comments URL: https://news.ycombinator.com/item?id=47806427

Points: 5

# Comments: 2

there's a lot of good work happening on agent memory right now. but it's all single-player. your agent remembers what you did. it has no idea what your co-founder just spent four hours figuring out. we kept solving the same problems twice, or discovering decisions the other had made only when something broke.

the missing piece wasn't better memory. it was shared memory. not 'sync your notes,' but a layer where the act of one person working becomes context for the next person's session automatically.

egregore adds this shared cognition layer on top of claude code. your team shares tooling, knowledge, and skills that evolve with how you actually work. you get full visibility into what the organisation is doing, not through dashboards, but because the memory is right there when your agent starts a session. handoffs between team members, structured reflection on workflows, a knowledge graph that connects decisions to who made them and why.

we've been running on this internally for about a month and honestly the difference is hard to go back from. the organisation has its own continuity now. context stopped being something you maintained and became something that just accumulated from working.

terminal-first, git-native. we just launched and are looking for early alpha testers. if you're building with claude code in a small team, happy to give early access if you want to try it!

Right now you can clip fragments from the web, LACE auto-organises them into evolving research threads, builds a concept graph + summaries, and lets you chat with your own library (find bridge connections, pull related papers, or turn a cluster into an essay draft).

Where we're going: more “emergent” behaviour – high-signal rabbit holes (papers, videos, posts) based on what you’re actually working on, plus light collaboration so people can share drafts and reading lists around a question. The idea is that LACE keeps organising and resurfacing things for you, on the right time, instead of you fighting with folders/tags in Obsidian/Notion.

If that sounds fun, I'd love it if you can give it a spin and give us feedback. I'm on https://x.com/oyayla_ - if you can DM me I can also invite you to our Telegram group.

With LLMs, generating ideas and snippets is cheap; what’s hard is keeping track of fragments with their “why I cared” context over months. Most tools (Notion/Obsidian/etc.) assume you will do the work (folder/tag/linking) structure will maintain it forever. I don’t.

In LACE we: – capture fragments from the web via a browser extension – auto-cluster them into evolving “threads” / projects with summaries & reading lists – maintain a graph of connections across threads (“topology of attention”) – let you turn a cluster of fragments into an essay draft when you’re ready to share.

Stack is a fairly standard web app + LLM pipeline. Used neo4j's llm-graph-builder as a starting point.

The interesting bit is self-organising graph. treating fragments/questions/lines of inquiry as first-class objects and letting the system reorganise around them over time instead of fixed folders.

It’s in a small test phase right now. If you’re a researcher/writer/engineer/founder who constantly loses good ideas in your notes and want to try something opinionated in this space, I’d love feedback.

background write-up: https://open.substack.com/pub/ozthinks/p/from-fragments-to-i...

Comments URL: https://news.ycombinator.com/item?id=34440456

Points: 2

# Comments: 0