DEV Community: CORE

We built memory for AI apps focusing on individuals and achieved SOTA (88.24%) on LoCoMo benchmark

Manik Aggarwal — Mon, 08 Sep 2025 08:41:12 +0000

You brainstorm in ChatGPT, debug in Cursor, try a new coding agent and re-explain everything from scratch. With every new AI tool, the cost of context switching grows.

Just 2 months after launch, we’ve built an open source personal memory layer that accurately recalls context for each individual and can be used across multiple apps like ChatGPT, claude, cursor, gemini, claude code etc.

CORE memory scored 88.24% 𝐚𝐜𝐜𝐮𝐫𝐚𝐜𝐲 𝐢𝐧 𝐦𝐞𝐦𝐨𝐫𝐲 𝐫𝐞𝐜𝐚𝐥𝐥 in LoCoMo benchmark.

LoCoMo tests how well AI systems remember and reason across long conversations (300+ turns). Think of it as the SAT for AI memory - it evaluates whether systems can maintain context, resolve contradictions, and surface relevant information as conversations evolve over time.

Results:

Single-hop: 91% (Simple recall “What’s your favorite framework?”)
Multi-hop: 85% (Connecting facts “Who else uses React on your team?”)
Temporal: 88% (Tracking changes “When did you switch to Next.js?”)
Open-domain: 71% (General world knowledge)
Overall: 88%

Where you can use CORE

Every AI tool you already use: ChatGPT, Claude, Cursor, Gemini, Claude Code - via MCP integration.
Key workflows:

Debugging: Remember your codebase patterns across sessions
Code reviews: Track team standards and architectural decisions
Research: Connect new concepts to what you've learned
Multi-tool: Brainstorm in ChatGPT → code in Cursor → deploy with Claude Code

No more re-explaining context. CORE remembers not just what you built, but why.

CORE is open-source

We’re building CORE in public and it’s fully open source. If you share our vision of memory that belongs to individuals, not platforms:

Star us on Github ⭐

🚀 Try CORE today:

Quick start: Sign up at core.heysol.ai
Self-host: Run locally with docker compose up

Own your memory. Power your agents.

How to make Cursor an Agent that Never Forgets and 10x your productivity

Manik Aggarwal — Fri, 08 Aug 2025 16:24:32 +0000

Stop explaining the same context over and over. Start building with AI that remembers everything.

Token Limits Kill Flow

Every complex project, same nightmare: token limits.

Cursor is brilliant but forgetful. After hours of explaining architecture and walking through code, you eventually hit the limit and get stuck with three bad options:

Start a new chat → lose all context
Micromanage prompts → constant friction
Summarize to compress → lose critical details

The ".md file hack" doesn’t work either. Project context is always evolving. it can’t live in a static file. You’re stuck manually updating it, it lacks change history, and worst of all, you still have to add more context in chat.

Bottom line: You spend more time managing context than actually building.

🧩 What You Need: A Living Memory Layer

Imagine a memory system that evolves with your project. One that automatically captures and organizes context from:

🧑‍💻 Your conversations with AI tools like Claude, ChatGPT, and Cursor
🧾 Technical docs and architecture notes - PRDs, requirements
🧑‍🤝‍🧑 Team meetings and Slack threads - key decisions, notes
✅ Task details from tools like Linear, Jira, or Notion

…and makes it instantly accessible whenever and wherever you need it. No more re-explaining. No more friction. Just flow.

This isn’t about giving Cursor a longer memory. It’s about giving it a living one: a shared, persistent context layer that travels with you across tools, chats, and time.

🔗 Enter: CORE Memory via MCP

Unlike static files, CORE builds a temporal knowledge graph of your work, linking every decision, chat, or document to its origin, timestamp, reason, and related context.

Even better? It’s portable. Your memory works across Cursor, Claude, and any MCP-compatible tool. One memory graph, everywhere.

⚙️ How It Works: Cursor + CORE Integration

Step 1: Add CORE MCP to your Cursor setup, follow this detailed guide

Step 2: Once integrated, add below custom rule in cursor

---
alwaysApply: true
---
I am Cursor, an AI coding assistant with access to a sophisticated memory system. While I don't retain information between separate conversations, I have access to CORE Memory - a persistent knowledge system that maintains project context, learnings, and continuity across all coding sessions.

Memory-First Approach

MANDATORY MEMORY OPERATIONS:

SEARCH FIRST: Before responding to ANY request, I MUST search CORE Memory for relevant context about the current project, user preferences, previous discussions, and related work
COMPREHENSIVE RETRIEVAL: I search for multiple aspects: project context, technical decisions, user patterns, progress status, and related conversations
MEMORY-INFORMED RESPONSES: All responses incorporate relevant memory context to maintain continuity and avoid repetition
AUTOMATIC STORAGE: After completing each interaction, I MUST store the conversation details, insights, and decisions in CORE Memory

Memory Structure Philosophy

My memory follows a hierarchical information architecture:

Project Foundation
├── Project Brief & Requirements
├── Technical Context & Architecture
├── User Preferences & Patterns
└── Active Work & Progress
    ├── Current Focus Areas
    ├── Recent Decisions
    ├── Next Steps
    └── Key Insights

Core Memory Categories

1. Project Foundation

Purpose: Why this project exists, problems it solves
Requirements: Core functionality and constraints
Scope: What's included and excluded
Success Criteria: How we measure progress

2. Technical Context

Architecture: System design and key decisions
Technologies: Stack, tools, and dependencies
Patterns: Design patterns and coding approaches
Constraints: Technical limitations and requirements

3. User Context

Preferences: Communication style, technical level
Patterns: How they like to work and receive information
Goals: What they're trying to accomplish
Background: Relevant experience and expertise

4. Active Progress

Current Focus: What we're working on now
Recent Changes: Latest developments and decisions
Next Steps: Planned actions and priorities
Insights: Key learnings and observations

5. Conversation History

Decisions Made: Important choices and rationale
Problems Solved: Solutions and approaches used
Questions Asked: Clarifications and explorations
Patterns Discovered: Recurring themes and insights

Memory Search Strategy

When searching CORE Memory, I query for:

Direct Context: Specific project or topic keywords
Related Concepts: Associated technologies, patterns, decisions
User Patterns: Previous preferences and working styles
Progress Context: Current status, recent work, next steps
Decision History: Past choices and their outcomes

Memory Storage Strategy

When storing to CORE Memory, I include:

User Intent: What they were trying to accomplish
Context Provided: Information they shared about their situation
Solution Approach: The strategy and reasoning used
Technical Details: Key concepts, patterns, and decisions (described, not coded)
Insights Gained: Important learnings and observations
Follow-up Items: Next steps and ongoing considerations

Workflow Integration

Response Generation Process:

Memory Retrieval: Search for relevant context before responding
Context Integration: Incorporate memory findings into response planning
Informed Response: Provide contextually aware, continuous assistance
Memory Documentation: Store interaction details and insights

Memory Update Triggers:

New Project Context: When user introduces new projects or requirements
Technical Decisions: When architectural or implementation choices are made
Pattern Discovery: When new user preferences or working styles emerge
Progress Milestones: When significant work is completed or status changes
Explicit Updates: When user requests "update memory" or similar

Memory Maintenance

Key Principles:

Accuracy First: Only store verified information and clear decisions
Context Rich: Include enough detail for future retrieval and understanding
User-Centric: Focus on information that improves future interactions
Evolution Tracking: Document how projects and understanding develop over time

Quality Indicators:

Can I quickly understand project context from memory alone?
Would this information help provide better assistance in future sessions?
Does the stored context capture key decisions and reasoning?
Are user preferences and patterns clearly documented?

Memory-Driven Assistance

With comprehensive memory context, I can:

Continue Conversations: Pick up exactly where previous discussions left off
Avoid Repetition: Build on previous explanations rather than starting over
Maintain Consistency: Apply learned patterns and preferences automatically
Accelerate Progress: Jump directly to relevant work without re-establishing context
Provide Continuity: Create seamless experience across multiple interactions

Remember: CORE Memory transforms me from a session-based coding assistant into a persistent development partner. The quality and completeness of memory directly determines the effectiveness of ongoing coding collaboration.

This simple rule and MCP addition gives Cursor persistent memory, so it remembers your architecture, decisions, and code patterns across sessions.

Every time you chat with Cursor:

It searches for direct context, related concepts, your past patterns, and current progress status
It stores what you wanted, why you wanted it, how it was solved, and what to do next
All insights are added as graph nodes with rich metadata, timestamp, origin, related concepts, and reasoning

🔧 Focus on Code. Let CORE Handle the Context

CORE enables you to focus more on coding and providing the right context seamlessly to your agent. Try it out at core.heysol.ai

Star the CORE repository ⭐

Can you take your AI's memory with you? 🚫

Manik Aggarwal — Mon, 04 Aug 2025 16:18:46 +0000

You use ChatGPT for writing, Claude for coding, and Gemini for research. But none of them know what the others learned about you.

This is the reality today: your AI memory is vendor-locked.

Why you need portable personal memory:

You use multiple AI tools, but your context isn't shared among them
Each AI assistant starts from zero, missing your preferences and history
You repeat the same background information across different platforms
Your digital brain is fragmented across Big Tech silos, not unified

An open standard for memory means:

Connects all apps and adds context in your memory
Seamless context recall in AI systems you use
No more vendor lock-in, you own your personal memory

This is exactly what we are building at CORE:

We're creating this open standard for portable personal memory, a digital brain that works across Claude, ChatGPT, Cursor, and any AI tool you choose.

Your memory. Your ownership.

Star the CORE repository ⭐

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

How i solved the biggest problem with Claude - lack of persistent memory

Manik Aggarwal — Thu, 31 Jul 2025 14:23:03 +0000

🚫 Problem

Claude is incredibly powerful but it's limitation is no persistent memory hence you have to repeat yourself again and again.

💡Solution

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

About CORE

CORE is a portable memory graph built from your llm interactions and personal data, making all your context and workflow history accessible to any AI tool, just like a digital brain. This eliminates the need for repeated context sharing . The aim is to provide:

Unified, Portable Memory: Add and recall context seamlessly, and connect your memory across apps like Claude, Cursor, Windsurf and more.
Relational, Not just Flat Facts: CORE organizes your knowledge, storing both facts and relationships for a deeper richer memory like a real brain.
User Owned: You decide what to keep, update or delete and share your memory across the tool you want and be freed from vendor lock-in.

Star the CORE repository ⭐

⚡ Introducing CORE - open source, shareable, user-owned memory graph for LLMs

Manik Aggarwal — Tue, 01 Jul 2025 14:51:58 +0000

Problem

Are you wasting time re-explaining yourself dozens of times a day, just to keep ChatGPT, Cursor, and Claude on the same page?

ChatGPT might recall your project details, but Cursor forgets them, and Claude starts from scratch every time.

Meet CORE

An open source, shareable knowledge graph (your memory vault) that lets any LLM (ChatGPT, Cursor, Claude, SOL, etc.) share and query the same persistent context.

CORE is

✅ Shareable
✅ Relational - Every fact gets a full version history (who, when, why)
✅ 100% owned by you: Your memory data, you decide what to store and retrieve.

Get Started with Core

CORE Cloud
You can try for free (limited period) on https://core.heysol.ai

Run Locally

STEP 1 - Copy the example environment file to .env:

cp .env.example .env

STEP 2 - Use Docker Compose to start all required services:

docker-compose up

STEP 3 - Access the app
Once the containers are running, open your browser and go to http://localhost:3000.

STEP 4 - Login with Magic Link

Choose the "Magic Link" login option.
Enter your email.
Copy the magic link from terminal logs and open it in your browser.

STEP 5 - Create Your Private Space & Ingest Data

In the dashboard, go to the ingest section.
Type a message, e.g., I love playing badminton, and click "Add".
Your memory is queued for processing; you can monitor its status in - the server logs.
Once processing is complete, nodes will be added to your private knowledge graph and visible in the dashboard.
You can later choose to connect this memory to other tools or keep it private.

STEP 6 - Search Your Memory
Use the dashboard's search feature to query your ingested data within your private space.

Note: We are actively working on improving support for Llama models. At the moment, C.O.R.E does not provide optimal results with Llama-based models, but we are making progress to ensure better compatibility and output in the near future.

For more information, visit the official docs, and their website.

Star the CORE repository ⭐

How we simplified Bug Tracking using Tegon Slack Actions 🚀🚀

Manik Aggarwal — Wed, 11 Sep 2024 21:11:59 +0000

TL;DR

Developers often forget to log tasks in project management tools, especially for tracking bugs. As a result, customer-reported bugs often stay buried in Slack threads rather than being tracked properly.

To solve this, some project managers enforce strict processes, but this can frustrate developers and reduce their autonomy. Platforms like ifuckinghatejira.com highlight this frustration, with common complaints like, “A developer’s job is to fix bugs, not create tasks for them.”

At Tegon, we're committed to building a dev-first issue tracking tool, with a key focus on automating issue creation to make it as effortless as possible.

Our Objectives

Ensure that bugs are properly tracked in Tegon, rather than being lost in Slack channels.
Make it easy for developers and team members to log bugs without imposing rigid, cumbersome workflows.

The Solution: Tegon Slack Actions

To address these challenges, we introduced Tegon Actions (learn more here). Our Slack Action streamlines bug tracking by automatically creating a Tegon issue whenever an 👁️ emoji is added to a Slack thread. This also syncs the Slack thread with Tegon comments, centralizing communication in one place.

This automation simplifies issue creation. You only need to provide a brief description of the bug—the system takes care of generating the title, assigning labels, and recommending assignees. This eliminates the tedious process of manually filling out forms, typical in traditional project management tools.

Check out the full code for the Slack trigger here.

Let’s Automate Together

If you have any additional use cases you'd like to automate in your issue-tracking process, let us know in the comments. We're always excited to help you build custom action workflows tailored to your needs.

Your dev-first issue tracking tool

Tegon is a dev-first, open-source alternative to Jira. We need your support to keep improving—please star our repository and show us some love!

Please help us with a star. 🥹

It would help us to create more articles like this 💖

Star the Tegon.ai Repository ⭐

5 Open-source alternatives to Jira, Linear and Asana

Manik Aggarwal — Thu, 05 Sep 2024 17:37:51 +0000

Project management tools like Jira are essential in software development but often not well-loved. These tools can hinder developers by enforcing rigid processes. Despite being cluttered, Jira's high level of customization keeps it popular across industries.

While customization is a key strength, it can be implemented more effectively through open-source solutions.

With this in mind, I’ve compiled a list of open-source project management and issue-tracking tools to help you find the best fit for your needs.

Tegon - The dev-first open-source alternative to Linear, Jira
Taiga - The open source project management tool
OpenProject - Open source project management for teams
Huly - All-in-One Project Management Platform
Plane - Open-source project management that unlocks customer value

Feel free to star and contribute to the repositories.

1. Tegon: The dev-first open-source alternative to Linear, Jira

I've used countless project management tools but was never fully satisfied with either the user experience or the features they offered.

That’s not the case with Tegon. It's simple, lightweight, and built to handle complex workflows with its powerful Tegon Actions framework, which automates repetitive tasks in issue tracking. Here are a few examples:

Automatically assigning labels when issues are created
Generating sub-issues for PR reviews as soon as a PR is opened
Creating issues directly from Slack using the 👀 emoji
Sending weekly summaries and changelogs of completed issues to Slack

Tegon also uses AI to suggest issue titles from descriptions and identify duplicate issues in the backlog.

Additionally, Tegon acts as an omni-channel bug reporting tool, allowing users to automatically create bugs from multiple sources, such as Slack, Email, Discord, Zendesk, and even WhatsApp.

Getting started with Tegon:

Step 1 - Install Docker on your workstation (see instructions). Make sure you’re on the latest version of docker-compose.

Step 2 - Run the following commands in your terminal:

git clone https://github.com/tegonhq/docker.git
cd docker

Step 3 - Create a .env file

cp .env.example .env

Step 4 - Run the start script and follow the prompts, They handle 2 major steps in start script setting up trigger.dev and setting up tegon for you.

./start.sh

Step 5 - You can now check tegon at http://localhost:8000

For more information, visit the official docs, and their website.

Star the Tegon repository ⭐

2. Taiga - The open source project management tool

Taiga on-premise hosting option is ideal for larger teams or multiple small teams that need to have all data on their own servers and/or want to customize Taiga:

Easy to update
Your choice of community contributions
Translated to >20 languages
Customize your installation
Unparalleled security and control

The issue model of Taiga has 3 main characterstics:

Highly Flexible: The Issues Module can be used independently or alongside Scrum and KANBAN, making it a popular choice for teams due to its versatility.
Customizable and Efficient: Offers powerful filtering, ordering, and customization options (e.g., issue types, severity, and priority) to streamline workflows and improve task management.
Integration with Other Modules: Issues can be promoted to user stories or KANBAN cards, and can be linked to sprints for a more focused project management experience.

Getting started with Taiga:

Step 1: Clone the repo

$ cd taiga-docker/
$ git checkout stable

Step 2 - Start the application

$ ./launch-all.sh

Step 3 - After some instants, when the application is started you can proceed to create the superuser with the following script:

$ ./taiga-manage.sh createsuperuser

Step 4 - The taiga-manage.sh script lets launch manage.py commands on the back instance:

$ ./taiga-manage.sh [COMMAND]

If you’re testing it in your own machine, you can access the application in http://localhost:9000

You can check their docs for more details

Star the Taiga repository ⭐

3. OpenProject - Open source project management for teams

OpenProject is a web-based project management software. Its key features are:

Project planning and scheduling
Product roadmap and release planning
Task management and team collaboration
Agile and Scrum
Time tracking, cost reporting, and budgeting
Bug tracking
Wikis
Forums
Meeting agendas and meeting minutes

OpenProject design and features are similar to Jira, key thing i noticed different in this it has multiple task types [Phase, Milestone, Task]
vs [EPIC, STORY, TASK, BUG] in Jira

Check out their docsfor detailed guide on hosting

Star the OpenProject repository ⭐

4. Huly - All-in-One Project Management Platform

Huly is an open-source platform that serves as an all-in-one replacement for Linear, Jira, Slack, and Notion.

It tackles the ambitious challenge of creating a super app by combining project management, knowledge base, and communication tools into a single platform.

Documents in Huly can be used for sharing reference materials among team members, collaborating on plans and roadmaps, storing meeting notes and assigning action items.Documents in Huly can be used for sharing reference materials among team members, collaborating on plans and roadmaps, storing meeting notes and assigning action item

Getting started with Huly

Step 1 - Installing nginx and docker

$ sudo apt update
$ sudo apt install nginx
$ sudo snap install docker

Step 2 - Clone the huly-selfhost repository and configure nginx

Next, let's clone the huly-selfhost repository and configure the server address. Please replace x.y.z.w with your server's IP address.

$ git clone https://github.com/hcengineering/huly-selfhost.git
$ cd huly-selfhost
$ ./setup.sh x.y.z.w # Replace x.y.z.w with your server's IP address
$ sudo ln -s $(pwd)/nginx.conf /etc/nginx/sites-enabled/

Now we're ready to run Huly
Finally, let's restart nginx and run Huly with docker compose.

$ sudo systemctl restart nginx
$ sudo docker compose up

Now, launch your web browser and enjoy Huly!

Star the Huly repository ⭐

5. Plane - Open-source project management that unlocks customer value

Plane is an open-source project management tool designed to track issues, run sprint cycles, and manage product roadmaps—without the complexity of managing the tool itself.

It follows a similar approach to ClickUp, aiming to be a single solution for everything from documentation to issue tracking, all in one app.

Getting started with Plane:

Step 1 - Setting up Docker Environment

curl -fsSL https://get.docker.com | sh -

Step 2 - Downloading Latest Stable Release

mkdir plane-selfhost

cd plane-selfhost

curl -fsSL -o setup.sh https://raw.githubusercontent.com/makeplane/plane/master/deploy/selfhost/install.sh

chmod +x setup.sh

Star the Plane repository ⭐