LifeGraph stores your life as plain Markdown and JSONL files on hardware you own, keeps that record append-only and hash-chained so tampering is detectable, and runs a team of scheduled AI agents that read those files instead of a black-box vector database. It already runs daily for its first user across calendar, journal, people, places, health and finances.
The core journaling primitive is real, tested code in the repo: a hash-chained JSONL log that detects any in-place edit, deletion, or reordering of past entries in a stream.
git clone https://github.com/adam-rhodes/lifegraph && cd lifegraph/examples/hashchain
python3 test_hashchain.py # tamper / delete / reorder detection
python3 lifegraph_hashchain.py verify ../vault/sample_timeline.jsonl # verify a shipped timelineYou should see the tests pass and the shipped timeline verify:
ALL PASS: clean-chain, genesis, linkage, tamper-detect, delete-detect, reorder-detect
OK {'entries': 3, 'head': '...'}Now edit any character inside examples/vault/sample_timeline.jsonl and run verify again. It names the exact entry where the chain breaks:
BROKEN {'broken_at': 2, 'reason': 'entry_hash mismatch (content altered)', 'entries_ok': 2}Then open examples/vault/ to see the real shape of the data: a hash-chained timeline, a Mind's journal, and a knowledge-graph node. To see what the record is for, run examples/demo/reconstruct.py: it rebuilds a relationship from the sample vault, cites every line to its source, and refuses to run on a chain it cannot verify.
Scope, stated plainly: this detects tampering with existing entries inside a stream. It does not by itself stop someone who can already write the file from truncating it or replacing the whole chain with a fresh, internally consistent one. Off-box backup and external anchoring are future work, tracked in the roadmap.
Plain files on your hardware. No lock-in, readable in any editor a decade from now.
Append-only, timestamped, uniquely identified, hash-chained so tampering is detectable. The memory is an audit trail, not a vector-DB black box.
Named specialists collaborate and journal in the open, routed through a model-agnostic broker so no vendor is load-bearing. Only the specific text a task needs is sent to a model; point the broker at a local model for strictly on-box processing.
Most tools give you a calendar here, notes there, a chatbot somewhere else. None see the whole picture, and none actually remember you. LifeGraph is one system that treats your whole life as connected, keeps a durable record you control, and runs specialists that work across every domain and write their reasoning to disk.
What this repo ships: the concept, the data schemas, the runnable hash-chain core, a minimal one-Mind runtime, and a public runtime slice (a roster of Minds on a scheduled tick, a model router with a daily spend cap and a chained cost ledger, and a file-based council with an evidence gate), all stdlib Python with no database. The rest of the private instance (the FastAPI server, the web app, the 35-Mind roster and voices, the Letta memory layer, the ingest pipelines) is being sanitized for public release and is listed on the roadmap with the reason each piece is not out yet.
Clients PWA (per-domain views) + chat / CLI
|
Edge Caddy (TLS, static + reverse proxy)
|
API FastAPI + enforcement / validation layer <- significant writes routed through (partial today)
|
Intelligence Minds runtime (scheduled + on demand)
model broker: Claude / GPT / Gemini / local, with fallbacks + spend cap
|
Memory The Vault: Markdown + JSONL, unique IDs, append-only hash-chained timelines
|
Durability owned hardware -> replicated (Syncthing/iCloud) -> [planned] versioned off-site encrypted git backup
| Minds | Scheduled and on-demand agents, each with a role and a journal file. See examples/vault/sample_mind_journal.md. |
| The Vault | The canonical file store. One home and one stable ID per fact. |
| Timelines | Append-only, hash-chained JSONL. See examples/vault/sample_timeline.jsonl and the runnable verifier. |
| The Constellation | The relationship graph. See examples/vault/sample_graph_node.md. |
| Illuminations / Resonances | An insight, and an insight that actually changed behavior. Tracked as records, not vibes. |
Full detail in docs/ARCHITECTURE.md. Threat model, auth and key handling in SECURITY.md.
A Mind is a named specialist with a role, a voice distinct enough that you can tell who is speaking, a journal it keeps in its own words written to disk, a strand of accumulated experience that persists across sessions, and the ability to collaborate with the other Minds and with you. If the system vanished, you could read the journals in order and reconstruct what the team was thinking and why.
The target coordination design: a significant event arrives; a chief-of-staff Mind assigns it to the owning specialist with an urgency and a follow-up date; the owner does the work and journals it; disagreements are logged and resolved rather than averaged away; a scheduled council reviews the output with an evidence gate. Today the Minds journal reliably on a schedule. The coordination layer is the current build focus, and that is stated plainly because honesty about built versus intended is a project principle.
The roster is not fixed at a number. When a domain of a life recurs and grows, that is the signal to give it a dedicated Mind. The first user's private roster and their live journals live in that user's own instance, not here. What lives here is the shape: docs/THE_MINDS.md and the sample journal in examples/vault/.
They all live in this repo against the shipped module and samples. Open an issue to claim one, or just open a PR.
The hash-chain module uses POSIX fcntl; on Windows locking is a no-op. Add a portable lock (msvcrt or fasteners) behind the same interface, with a test.
Wrap append, verify and the reconstruction demo into one lifegraph command that works over any vault directory.
Truncating the last entries leaves a valid prefix that still verifies. Prototype a periodic Merkle root or entry count committed off-box, or an append-only length receipt.
Sketch the common adapter interface and implement one read-only adapter (iCal, mbox) that emits timeline entries in the shipped JSONL shape.
A test that hammers append from several processes on POSIX and proves the chain never corrupts.
The best contributions right now are ideas, critique and design pressure, not just code. Open an issue that tells us where the vision is thin, where the architecture is wrong, or where a claim is overstated. Propose how a subsystem should work: the enforcement layer, the memory model, the Minds coordination protocol. Make the docs clearer for the next person. Small, self-contained reference implementations (a hash-chained append log, a model-agnostic broker, a named-path retriever) are gold.
Never commit personal data or secrets. Keep discussions civil and specific. Start with CONTRIBUTING.md, VISION, ARCHITECTURE and GLOSSARY.
| docs/VISION.md | Why this exists and where it is going. |
| docs/ARCHITECTURE.md | How it is built and the design choices. |
| docs/THE_MINDS.md | How the team of AI specialists works. |
| docs/PRINCIPLES.md | The commitments a real change must honor. |
| docs/ROADMAP.md | Honest current status and near-term priorities. |
| docs/GLOSSARY.md | The project's small, deliberate vocabulary. |
| SECURITY.md | Threat model, auth, key handling, self-host risks. |
| examples/ | Runnable code and anonymized sample data. |
Prefer the longer read? The original essay-form introduction is kept at The LifeGraph Record.