01
The session ends
You spend an hour with your AI working through a hard decision. You close the tab. Tomorrow, neither of you remembers why you did it that way.
Context memory for people who build with AI
Your AI knows why your code is the way it is. Then the session ends.
The code stays. The reasoning (what you tried, what failed, why you chose this) vanishes. Alpheon captures the why as one plain file in your repo, so it's never lost between sessions, tools, or teammates.
git clone https://github.com/BravoAlphaSix/alpheon
Free and open source. No account to set up, no config. Writes one plain file into your project.
## Handoff Note (2026-07-16 13:42)
### Why
Swapped the in-memory cache for sqlite so it
survives restarts. Tried Redis first, too heavy
to set up for a solo project.
### Tried & rejected
Redis, dropped it: too much infra for one machine.
The problem
The code survives. The reasoning doesn't.
02
You switch tools
You move from one AI assistant to another. The new one starts from zero. Every dead end you already ruled out is fair game again.
03
Someone else opens it
A teammate, or future you, reads the code and can't tell why it works this way. The "obvious" reasons were never written down.
How it works
One artifact. The whole story of why.
When you finish a session, Alpheon reads what changed and drafts a short handoff note for you to approve before it's saved. Simple on purpose.
1 · It reads the changes
At session end or on commit, Alpheon reads your git diff. No manual tracking.
2 · It captures the why
What changed, why, what you tried that failed, and what's next, in plain readable language.
3 · You approve it
You review before anything is saved as truth. No hallucinated memory silently poisoning your project.
4 · The why is recoverable
Saved right in your project. Any human, or any AI in any tool, can pick up the reasoning.
See it
This is a real handoff note.
Generated from a real coding session. Not a mockup, this is the actual output.
$ python alpheon.py
Wrote HANDOFF.md from 2 changed files.
## Handoff Note (2026-07-16 13:42)
### What changed
- added: api.py
- modified: cache.py
### Why
Swapped the in-memory dict cache for sqlite because the cache
needed to survive restarts. Tried Redis first but it was too
heavy to set up for a solo project.
### What was tried & rejected
Redis, dropped it: too much infra overhead for one machine.
### What's next / open questions
Add an eviction policy before cache.db grows unbounded.The next person who opens this project, human or AI, knows exactly why the cache is sqlite, and not to reach for Redis again.
Why Alpheon
The simplest way to keep the why.
Other tools that capture reasoning run as servers wired into one specific AI agent, with a database beside your repo. Alpheon takes the opposite bet.
Server-based memory tools
- Run an MCP server or background daemon
- Tied to one AI agent (Claude Code, etc.)
- Store data in a database beside your repo
- Written and trusted automatically
Alpheon
- One Python file, zero dependencies
- Tool-agnostic: works off git, any editor or agent
- Plain markdown, committed in your own repo
- You approve every note before it's saved
Never lose the why again.
Alpheon is free and open source. Grab it, try it on your next commit, and star the repo if it saves you a re-explanation.
git clone https://github.com/BravoAlphaSix/alpheon