Tried gpt5.5 and so far good. Zapier also shared an automation benchmark where 5.5 came on top in the leaderboard https://zapier.com/benchmarks

Write `[ ] Fix the search auth bug` in a scratchpad. Three minutes later, without you at the keyboard, CORE picks it up, pulls the relevant context from your codebase, drafts a plan in the task description, and spins up a Claude Code session in the background to do the work. You review the output in the task chat and unblock it when it gets stuck.

Every AI tool today is reactive. You open a chat, brief the agent, it responds. Before anything moves, you've already done the real work: opened the Sentry error, found the commit, read the Slack thread, grabbed the Linear ticket, and stitched it all together into a prompt. The model isn't the bottleneck. You are.

Demo Video: https://www.youtube.com/watch?v=PFk4RJvQg1Y

CORE removes you from that loop. The interface is a shared scratchpad, think a page you and a colleague both have open. You write what's on your mind. When you write a checkbox line like `[ ] Fix the search bug`, CORE converts it into a task and starts working on it after a short delay (long enough for you to add context if you want to). No prompt template. No workflow to configure.

The reason it can do this without you re-explaining everything: CORE keeps a persistent memory built from your tasks, conversations, and connected apps (Linear, Gmail, GitHub, Slack etc.). When it spins up a Claude Code session, it arrives with your codebase and project context already loaded.

A real example: we wrote `[ ] Create a widget in Linear integration`, about 14 minutes later, CORE had opened a PR .

What CORE is _not_: it's not Devin (no autonomous web browsing or shell loops you can't see), and it's not "Claude Code with memory bolted on." It's the layer above it that decides what should run, gathers the context, hands it to the right agent, and keeps the receipts in one place. Today the agent backend it spins up most often is Claude Code; the orchestration, scratchpad, memory, and integrations are CORE.

Open source, self-hostable with `docker compose up` and it supports multiple models.

GitHub: https://github.com/RedPlanetHQ/core Website: https://getcore.me (you can chat with Harshith's butler there) Demo: https://www.youtube.com/watch?v=PFk4RJvQg1Y

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

Points: 3

# Comments: 0

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

Points: 3

# Comments: 3

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

Points: 3

# Comments: 3

I also like preparing a draft and using llm for critique, it helps me figure out some blind spots or ways to articulate better.

2 months ago we launched CORE: an open-source, personal, portable memory layer for individuals designed to work the way humans think: context-rich, evolving, and shareable across AI tools.

We evaluated CORE using the LoCoMo benchmark, a rigorous test involving 1,540 questions across 10 multi-turn conversations. Achieving an overall accuracy of *88.24%*, CORE outperformed existing systems in all categories:

- Single-hop recall: 91%

- Multi-hop reasoning: 85%

- Temporal understanding: 88%

- Open-domain synthesis: 71%

- Overall: 88%

For detailed info on our approach, architecture, and the full benchmark results check our blog post.

Try it and give us some feedback:

- Hosted free tier (HN launch): https://core.heysol.ai

- Local: docker compose up from https://github.com/RedPlanetHQ/core

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

Points: 4

# Comments: 0

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

Points: 3

# Comments: 0

We use a reified knowledge graph for memory, where: Each fact is a first-class node (with timestamp, source, certainty, etc.) - Nodes are typed (Person, Tool, Issue, etc.) and richly linked - Activity (e.g. a Slack message) is decomposed and connected to relevant context

This structure allows precise subgraph retrieval based on semantic, temporal, or relational filters—so only what’s relevant is pulled into the context window. It’s not just RAG over documents. It’s graph traversal over structured memory. The model doesn’t carry memory—it queries what it needs.

So yes, the memory problem is real—but reified graphs actually make it tractable.

Currently, only Cursor, Grok, and ChatGPT have memory capabilities, with more following soon. But even when all AI systems develop individual memory, this problem will still exist.

I believe we need an independent 3rd party memory layer for the AI systems, one that can share context with any AI app or agent you use.

Many people on X are already discussing this memory layer problem. Some are building memory MCPs that connect to various providers, but this only partially solves the issue since it's not deeply integrated with these systems.

An open standard for memory should

- Adds context in your memory from everywhere (pdfs, webpage, blogs, linear, notion, document, meetings etc.) - Enable seamless context recall in any AI app you use - No more vendor lock-in, you own your personal memory

Do you think your AI memory should be owned by you, or should it remain vendor-locked with each platform?

Disclaimer - I am building one of such 3rd party memory layer called CORE (https://github.com/RedPlanetHQ/core) hence it is important for me to understand how you folks see about memory ownership.

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

Points: 3

# Comments: 2

I integrated Claude with CORE memory MCP, making it an assistant that remembers everything and have a better memory than Cursor or chatgpt.

Before CORE : "Hey Claude, I need to know the pros and cons of hosting my project on cloudfare vs AWS, here is the detailed spec about my project...."

And i have to REPEAT MYSELF again and again regarding my preferences and my tech stack and project details.

After CORE: "Hey Claude, tell me pros n cons of hosting my project on cloudfare vs AWS."

Claude instantly knows everything from my memory context.

What This Means - Persistent Context: You Never repeat yourself again - Continuous Learning: Claude gets smarter with every interaction it ingest and recall from memory - Personalized Responses: Tailored to your specific workflow and preferences

Check out full implementation guide here - https://docs.heysol.ai/providers/claude

I guess "semantic web" folks were right about the destination, just few years early :P

We designed CORE for complex, evolving memory where text files break down.

Example: Health conversations across ChatGPT, Claude, etc. where your parameters change over time.

A text file can't give you: "What medications have I tried, why did I stop each one, and when?" or "Show me how my symptoms evolved over 6 months."

For timeline and relational memory, CORE wins. For static facts, text files are enough i guess.

We will evaluate qwen and deepseek going forward, thanks for mentioning.

With use-case we wanted to showcase the shareable aspect of CORE more. The main problem statement we wanted to address was "take your memory to every AI" and not repeating yourself again and again anymore.

The relational graph based aspect of CORE architecture is an overkill for simple fact recalling. But if you want an intelligent memory layer about you that can answer What, When, Why and also is accessible in all the major AI tools that you use, then CORE would make more sense.

CORE lets you - Automatically extracts and stores facts from conversations - Builds intelligent connections between related information - Answers complex queries ("What did I say about something and when?") - Detects contradictions and explains changes with full context

For simple fact recall, plan.md should work but for complex systems a relational memory should be able to help better.