2024-26
Ariyah
A Prosthetic for Executive Dysfunction
The Challenge
Traditional productivity tools assume a neurotypical brain. They assume you can look at a list of 47 tasks and decide which one matters most. They assume you remember what you were working on yesterday. They assume context doesn't evaporate every time you switch focus. For someone with ADHD and executive dysfunction, these assumptions fail catastrophically.
The tools aren't broken. The model is. Every productivity system treats task management as a human activity that software supports. But for severe executive dysfunction, the task-planning function itself is impaired. No amount of tagging, prioritizing, and organizing helps when the underlying machinery for deciding 'what now' doesn't work reliably.
The question wasn't 'what task manager should I use?' It was: can you build a system that replaces the broken function entirely—that decides 'what now' so you don't have to?
Core tensions
Looking at a backlog induces paralysis, not clarity. The longer the list, the less gets done.
Context evaporates. Monday doesn't remember Friday. Every session starts from zero.
The brain compresses routine and only records novelty—but trauma accelerates this compression. Years disappear into fog.
Productivity tools require you to manage them. Managing the system becomes another task you can't execute.
Approach
Backlog-less, not task-less
Actions persist as files with metadata—you can query them, they won't disappear. But you never stare at a priority list. You ask 'what should I do?' and get contextual recommendations. The system surfaces; you execute.
Emergent actions
Tasks aren't pre-planned. They surface from state plus context. What's your current operating mode (Build, Flow, Rest, Repair, Tend)? What portal are you in? What arcs are active? What did last week's state file identify as important? The right action emerges from intersection, not from top-down planning.
Memory that doesn't compress
The brain forgets routine to save space. Ariyah never compresses, never deletes. Every daily note, every fleeting thought, every captured dump flows into the temporal spine. Daily states summarize into weekly. Weekly into monthly. Monthly into quarterly. The cascade preserves what the brain discards.
Cognitive prosthetic, not assistant
The goal isn't to help you manage tasks better. The goal is to replace the task-planning function with an external system that works reliably. You're not augmented; you're extended. The system isn't a tool you use—it's infrastructure you live in.
Technical Implementation
Domain model
Four domains (Business, Content, Home, Personal) contain twenty portals—specific contexts you 'enter' to work. Portals are stable; they map to life areas that don't change often. Within portals, arcs represent multi-piece concerns: projects, problems, ongoing threads. Actions live inside arcs or directly under portals.
State cascade architecture
States summarize vault activity for closed time periods. The cascade flows Daily → Weekly → Monthly → Quarterly → Yearly → Decade → Life. Each level reads everything below it: a weekly state reads all seven daily states plus the previous weekly. A monthly reads all weekly states plus the previous monthly. Context accumulates; nothing is lost.
Critical rule: closed periods only
States only generate for CLOSED periods—never today, never this week, never this month. You can't summarize a period that's still unfolding. Yesterday is closed. Last week is closed (on Monday). This prevents the system from generating false confidence about incomplete data.
Multi-agent pipeline
Long Claude sessions with compaction cause context drift. Complex skills with 10+ responsibilities lead to missed steps. Solution: code-enforced pipeline with isolated agents. Each agent has isolated context. Data passes via JSON files. No context pollution between stages.
ORCHESTRATOR (Python)
│
├── SCANNER ─── finds files needing processing
├── COLLECTOR ─── captures timestamps BEFORE edits
├── LABELER (Claude) ─── proposes classifications
├── VALIDATOR ─── deterministic rule checking
├── APPLIER ─── writes frontmatter, restores timestamps
└── AUDITOR ─── documents what changedAction surfacer
The heart of emergent recommendations. Reads current operating state (determined fresh from today's signals), historical context (state files, active arcs), and open actions with their metadata. Returns ranked recommendations based on intersection of what matters and what's possible right now. Read-only—never modifies files.
Dump processor
Raw captures land in Inbox.md throughout the day. The processor parses them, creates action files with proper frontmatter, assigns to portals and arcs, and archives processed dumps into monthly logs. Capture is frictionless; structure is automated.
Outcome
Working MVP serving as daily driver
The system runs every day. Morning briefings surface from state files. Action recommendations emerge from context. Dumps get processed into structured actions. The pipeline executes without manual intervention.
Architecture proven portable
The cascading state pattern, the handoff rule, the draft-review-approved lifecycle—this entire architecture was first proven in Weedl (operations intelligence for retail). What works for store performance coaching works for personal knowledge management. The pattern is domain-agnostic.
Context persists across sessions
Monday remembers Friday. Last week's weekly state informs this week's recommendations. The quarterly review captures themes the daily notes missed. Years don't disappear into fog anymore.
Backlog paralysis eliminated
No list of 47 tasks staring back, demanding prioritization. Ask 'what should I do?' and get three recommendations with rationale. Execute one. Ask again. The system decides; you act.
The measure of success is not whether the system captures everything, but whether it surfaces the right thing at the right moment—and whether you trust it enough to act.