Roles

System Overview

Designed with three layers: data, reasoning, and agentic.

1. Data Layer 📊

Fetch raw data from wherever:

• Health: Apple Health (sleep, heart rate, workouts, etc.)
• Finance: Plaid (transactions, balances, net worth)
• Productivity: Calendar, ideas, tasks, project threads

Everything is stored locally in JSON and markdown, with files organized by source and date. Syncing is CLI-driven via life sync, and the sync architecture is modular — each integration lives in its own self-contained interface under /sync/.

Example structure:

/sources/health/apple/2025-06-08.json
/sources/finances/plaid/2025-06-08.json
/sources/productivity/calendar/2025-06-08.json

Sample data file:

{
  "date": "2025-06-08",
  "source": "apple_health",
  "metrics": {
    "sleep_hours": 7.2,
    "steps": 12450,
    "heart_rate_avg": 68,
    "workout_minutes": 45
  },
  "events": [
    {"time": "06:30", "type": "wake", "heart_rate": 72},
    {"time": "19:00", "type": "workout", "duration": 45, "type": "strength"}
  ]
}

2. Reasoning Layer / Persisting Memory 🧠

The memory layer captures structured takeaways from each interaction. This persistent local memory feeds Claude with rich, evolving context that reflects how I actually live and think.

How Memory Works:

• Continuous updates: After each interaction, Claude extracts key insights and updates relevant memory files
• Pattern recognition: System identifies recurring themes, preferences, and decision patterns over time
• Context synthesis: Memory files are automatically included in relevant prompts to maintain continuity

Memory consolidation triggers:

• Weekly reviews that synthesize daily interactions
• Monthly goal assessments that update long-term preferences
• Project completions that capture lessons learned
• Significant life events or decision points

I've created a set of prompt templates for different reasoning tasks:

• Generate a one-pager for a new business idea from a voice note
• Analyze portfolio allocation against risk tolerance and market conditions
• Create an impact/value matrix for current projects based on personal goals
• Recommend flights using Chase Sapphire points and active promotions

Sample memory file:

# Financial Preferences - Updated 2025-06-08

## Risk Tolerance
- Conservative with emergency fund (6+ months expenses)
- Moderate-aggressive with investment portfolio
- Prefers index funds over individual stocks
- Willing to take higher risk on side projects/startups

## Spending Patterns
- Coffee: $120/month (consistent, values quality)
- Travel: Seasonal spikes in Q2/Q4
- Tech: Invests in tools that save time
- Dining: Prefers cooking at home, splurges on special occasions

## Decision History
- 2025-05: Increased 401k contribution after bonus
- 2025-04: Switched to high-yield savings (3.5% → 4.2%)
- 2025-03: Declined expensive co-working space (cost/benefit analysis)

Memory is stored in /memory/, continuously enriched with preferences, patterns, goals, and reflections.

3. Agentic Layer 🤖

This layer turns insights into action. Based on data patterns and reasoning, Claude suggests specific next steps that are added to a unified task list. Rather than executing directly, it creates actionable recommendations with clear context and priority.

Example suggestions:

• "Based on your spending pattern, consider setting up auto-transfer of $500/month to high-yield savings"
• "Your sleep quality dropped 15% this week coinciding with late evening screen time - suggest digital sunset at 9 PM"
• "Project Alpha shows 3x better ROI than Project Beta based on time invested - recommend focusing resources on Alpha"

Intent Routing System

The Intent Routing System is the core intelligence layer that makes natural language input useful. It converts freeform prompts into structured, validated commands that map to Life OS functionality.

[Natural Language Prompt] 
        ↓
[PromptClassifier (Claude)]
        ↓
[Command Object]
        ↓
[Schema Validator] ✅
        ↓
[Command Registry] → [Service Module]
        ↓
[Execution Engine]
        ↓
[Audit Logger] 📝

Design Principles

• Classifier is not executor – Claude only recommends actions — it doesn't execute
• Confidence-based filtering – All routes must pass a threshold (default: 0.5)
• Traceable – Every prompt → classification → action chain is logged
• Schema validated – Every command must pass validation against JSON schema

CLI Usage (Natural Language)

life "analyze my Q2 spending against my savings goals"
life "what projects should I prioritize based on current workload?"
life "capture insight: morning workouts correlate with better focus"
life "review my investment allocation given recent market changes"

Available Commands

Current Limitations

• Single-user system: Not designed for shared or collaborative use
• Limited action execution: Suggestions only, no direct API integrations yet
• Local processing only: No cloud backup or multi-device sync
• Basic natural language processing: Intent routing works for structured commands but struggles with very ambiguous requests
• Memory size constraints: Large conversation histories may impact performance

Stack & Architecture Decisions

Python 3.13

Anthropic Claude – Selected over OpenAI for better reasoning capabilities and longer context windows essential for memory synthesis

Plaid API

Apple Shortcuts

JSON + Markdown storage

Bash CLI interface

File Structure

~/Developer/life_os/
├── services/         # Core logic (projects, memory, Claude, sync)
│   ├── memory.py     # Memory consolidation and retrieval
│   ├── claude.py     # AI interaction and prompt management  
│   └── sync.py       # Data source integrations
├── sources/          # Synced raw data (health, finances)
│   ├── health/
│   ├── finances/
│   └── productivity/
├── memory/           # Persistent AI memory
│   ├── preferences.md
│   ├── patterns.md
│   └── goals.md
├── projects/         # AI-generated project files
│   ├── active/
│   └── archived/
├── templates/        # Claude prompt templates
│   ├── analysis/
│   ├── planning/
│   └── review/
├── sync/             # Modular sync logic
│   ├── plaid_sync.py
│   ├── apple_health_sync.py
│   └── calendar_sync.py
├── logs/             # System audit trail
└── main.py           # CLI entrypoint

Sample project file:

# Project: AI Expense Categorization Tool
**Created**: 2025-06-01
**Status**: Active
**Priority**: High

## Context
Personal pain point: spending 2+ hours monthly categorizing expenses for tax prep.
Market research shows 67% of freelancers have same issue.

## Metrics
- **Time Investment**: 12 hours (research + prototyping)
- **Potential ROI**: $500/month revenue if 50 users at $10/month
- **Confidence**: 75% (based on initial user interviews)

## Next Actions
1. Build MVP using Plaid API + Claude for categorization
2. Test with 5 beta users (target: 95% accuracy)
3. Validate pricing model through pre-orders

## Memory Links
- Financial preferences: prefers tools that save time
- Technical skills: strong API integration experience
- Risk tolerance: moderate for side projects

Logs

/logs/
├── routing_chains_*.jsonl     # Full prompt→action chains
├── classifications_*.jsonl    # Intent classification results
├── validations_*.jsonl        # Schema validation outcomes
├── executions_*.jsonl         # Command execution results
└── errors_*.jsonl            # System errors and debugging

Each entry includes:

• Timestamp + session ID
• Original prompt
• Classification result (with confidence score)
• Validation status
• Execution result
• Unique chain ID for tracing

Why I Built This

Most new AI tools still feel like demos, with no memory, no real structure, and no actual system behind them. I wanted to understand what it would take to build something more useful: a local assistant that can reason over real data, remember things over time, and actually help me make decisions.

Life OS started as a way to explore what a model context protocol (MCP) might look like in practice. Not just chatting with a model, but giving it memory, inputs, and a set of actions it could suggest or help with.

The goal was to create something that grows with you, learns your patterns, and becomes more useful over time—like the journaling habit that inspired it, but with the ability to surface insights and suggest actions based on years of data.