Athena - Local-First Agentic PKM for Any LLM

TL;DR

TL;DR: Athena is an open-source local-first memory and reasoning layer that attaches persistent context to any LLM — ChatGPT, Claude, Gemini, or any other — so your personalized agent survives model switches and platform updates.

Source and Accuracy Notes

This section is MANDATORY. All links must be verified from actual source, not guessed.

• Project page: athena.portfolio.pub — verified
• Source repository: github.com/winstonkoh87/Athena-Public — read README
• License: MIT (verified via LICENSE file)
• HN launch thread: news.ycombinator.com/item?id=46901937

What Is Athena?

Platform-based AI assistants forget you. A ChatGPT update wipes your custom instructions. Switching to Claude means starting from scratch. Your accumulated context, preferences, and learned relationships vanish.

Athena solves this with a local-first, model-agnostic personal knowledge management layer. It runs entirely on your machine, storing memory as plain Markdown files and SQLite. When you prompt any LLM, Athena retrieves the relevant context first and injects it into the conversation — regardless of which provider you are using.

The core claim from the README:

“Capture what you learn, retrieve it when relevant, and carry your context between models — a local-first memory, reasoning, and governance layer for any LLM, across ChatGPT, Claude, Gemini, and whatever you switch to next.”

Setup Workflow

Step 1: Clone the Repository

git clone https://github.com/winstonkoh87/Athena-Public.git
cd Athena-Public

Step 2: Set Up a Virtual Environment

python -m venv .venv
source .venv/bin/activate    # macOS/Linux
# .venv\Scripts\activate    # Windows

Step 3: Install

Two install profiles are available:

Lightweight install (no ML dependencies, about 30 seconds):

pip install -e .

Full install (5–10 minutes, enables vector search and reranking):

pip install -e ".[full]"

Step 4: Connect to an AI-Enabled IDE

Open the Athena folder in an AI-enabled IDE such as Cursor or VS Code with an Athena extension. Boot the agent from the IDE chat panel — not the terminal.

Step 5: First Run

On first launch, Athena runs a guided tour to capture your initial context. This establishes the baseline memory that persists across all future sessions.

Deeper Analysis

Architecture

Athena stores all data locally by design:

• Memory format: Plain Markdown files and Python scripts, growing over time as context compounds
• Vector store: SQLite by default (no external database required)
• Context retrieval: Topic-routed recall fetches relevant memory from the local store and injects it into LLM prompts at runtime
• Cross-provider: Works with any LLM that accepts long-context prompts — ChatGPT, Claude, Gemini, and open models alike

What Athena Actually Does

According to the README, Athena falls into four capability buckets:

1. Capture — ingest what you learn via conversation, documents, or manual notes
2. Retrieve — pull relevant context when you start a new session or ask a related question
3. Reason — structured reasoning layer on top of raw memory for complex, multi-step queries
4. Govern — policy guardrails on what context the LLM can and cannot use

Differentiation from Platform Memory

| | Platform native memory | Athena | |---|---|---| | Ownership | Provider | You (local files) | | Cross-provider | No | Yes | | Survives model updates | No | Yes | | Portable | No | Yes (git-friendly Markdown) | | Data stays local | No (sent to provider) | Yes |

Practical Evaluation Checklist

• Local install with zero external database dependency (full install still needs only pip packages)
• Context persists across provider switches — verified via architecture (plain Markdown + SQLite)
• No subscription or cloud service required to operate
• Markdown-based memory is human-readable and git-versionable
• Works with ChatGPT, Claude, Gemini simultaneously via prompt injection
• MIT license — commercial use permitted

Security Notes

All memory stays on your machine. No data is sent to external servers beyond what your LLM API calls already transmit. The local-first design means:

• No third-party storage of your personal context
• No dependency on platform continuity — if a provider goes down or changes policy, your memory remains
• Memory files are plain text — auditable, exportable, deletable at any time

FAQ

Q: Does Athena work with Claude and Gemini simultaneously? A: Yes. Because Athena operates at the prompt-injection level, it can attach context to any LLM that accepts long-context input, regardless of provider.

Q: What happens when I switch from ChatGPT to Claude? A: Athena retrieves your stored memory from local Markdown files and injects it into the Claude prompt. The conversation context you built up with ChatGPT carries over.

Q: Do I need the full install for basic use? A: No. The lightweight install works for memory capture and retrieval. The full install adds vector search and reranking for faster semantic recall over large memory stores.

Q: Is my data safe if I stop using Athena? A: Yes. Everything is stored as plain Markdown files and SQLite. You own the data completely with no lock-in.

Conclusion

Athena addresses the fundamental fragility of platform-locked AI memory. By keeping context in plain, portable files on your own machine, it decouples your learned knowledge from any single provider or model update cycle.

For power users who work across multiple LLMs or want long-term memory that they control outright, Athena is a clean, minimal solution that delivers on that promise without introducing new external dependencies.

Try it at github.com/winstonkoh87/Athena-Public and read the full docs at athena.portfolio.pub.