Laya Inbox
EXECUTIVE SUMMARY
Laya Inbox is a local-first Windows capture inbox built around a single global hotkey. Pressing Ctrl+Space anywhere captures unstructured text, a language model normalises it into a structured item, a locally hosted GPU model classifies what the item actually is, a deterministic action engine decides what should happen, and the result is written to SQLite and optionally surfaced as an Obsidian note. The entire pipeline runs on the user’s own machine, so captured material never leaves the workstation.
PROBLEM STATEMENT
Personal knowledge capture tools force a choice between speed and structure: the fast tools store raw text that must be filed later, while the structured tools require filling in fields before saving, which is enough friction that nothing gets captured at all. Existing AI capture assistants solve this by shipping everything to a cloud model, which conflicts with the material most worth capturing — private notes, client work, unreleased research. The system also makes the classification step probabilistic, so an assistant that guesses incorrectly still files the item confidently in the wrong place.
INVESTIGATIVE FINDINGS
- ▸Capture friction is the dominant failure mode of every note system, not storage or search
- ▸Normalising and classifying are separate concerns and should be handled by different models
- ▸A local classifier is fast enough for interactive use and removes the privacy constraint entirely
- ▸The action step must stay deterministic, because an LLM deciding what to do with a captured item is unauditable
- ▸Persisting before acting prevents data loss when the downstream action fails
BEHAVIORAL ANALYSIS
The design keeps the probabilistic and deterministic steps strictly separated. The model is allowed to be uncertain about meaning; it is never allowed to be uncertain about consequence. This is the same reasoning that governs Aegis AI and Vouch elsewhere in this portfolio — let a model interpret, let code decide — applied here to a personal tool where a wrong autonomous action would be worse than a missing one.
TECHNICAL EXECUTION
The pipeline runs in four stages. Capture binds a global hotkey (Ctrl+Space) through Electron and opens an inline input. Normalisation calls GPT-OSS-20B via Groq to convert free text into a structured record. Understanding hands that record to Laya, a model served on a local GPU, which classifies it against a user-defined taxonomy. The Action Engine then applies deterministic rules to decide the concrete response — write to the inbox table, create an Obsidian note, set a reminder, or run a configured workflow. Results persist to SQLite via better-sqlite3, and an inbox UI provides review. The codebase is TypeScript in strict mode with zod validation at every boundary, and a Python stdio bridge (`resources/bridge/laya_bridge.py`) connects the Electron main process to the LayaDaemon service. V1 is complete and verified: 46 tests pass alongside a smoke test and a clean typecheck.
SYSTEM ARCHITECTURE
OPERATIONAL FEATURES
- ✓Global hotkey capture from any application on Windows
- ✓Model-based normalisation of free text into structured records
- ✓Local GPU classification against a user-defined taxonomy
- ✓Deterministic action engine with zod validation on every decision input
- ✓SQLite persistence with an inbox review UI
- ✓Optional automatic Obsidian note creation
- ✓Reminders and configurable settings
- ✓Python stdio bridge to a locally installed LayaDaemon service
- ✓Strict TypeScript throughout with a passing typecheck
TECHNOLOGICAL ASSETS
CURRENT STATUS
V1 complete and verified. Capture hotkey, model understanding, deterministic decision, action execution, database persistence, inbox UI, Obsidian note export, settings, and reminders are all implemented, with 46 tests passing and the smoke test green. Development is now focused on taxonomy refinement and richer action recipes.
CONCLUSION
Laya Inbox demonstrates that a useful AI capture tool does not need cloud inference. Splitting the pipeline into a cloud normalisation step, a local classification step, and a deterministic action step preserves the speed that makes capture habitual while keeping private material on the machine and keeping automated actions auditable.