back home

Kriyan

a local-first personal operating system that keeps you on track and lets agents do work you can inspect.

GitHub →

Kriyan combines tasks, calendar, reminders, notes, sources, cited memory, and durable agent threads. Convex coordinates the product while a user-controlled node runs agents and maintains a readable Markdown and SQLite second brain.

inside the app

real product screens
Kriyan Today dashboard showing current work, captured context, and a command composer
todayTasks, reminders, recent captures, knowledge changes, and active agent work meet in one daily control surface.
Kriyan Sources screen listing connected services and their sync status
sourcesEvery captured input keeps its origin, sync state, and downstream references visible instead of disappearing into agent context.
Kriyan Memory screen showing retained context and its supporting evidence
memoryDerived facts and entities stay attached to citations, confidence, corrections, and the source material that produced them.

why I built this

the problem and the bet

my work is spread across tasks, notes, calendars, files, browser research, and agent sessions. the hard part is not capturing more of it; the hard part is turning that context into the next action without losing where anything came from.

Kriyan is built around two promises: keep me on track through normal productivity surfaces, and let personal agents do useful work through durable threads, explicit tools, and visible run state.

the second brain is deliberately inspectable. source material stays referenced, authored work stays versioned, derived memory stays cited, and local Markdown remains readable even when the app or an agent is not running.

what it actually does

the product in practice
  1. 01

    a real Today surface

    Tasks, agenda items, reminders, recent captures, knowledge changes, and active agent work are prioritized together instead of living in separate dashboards.

  2. 02

    tasks, calendar, reminders, and notes

    The core productivity layer works without asking an agent: create work, schedule it, receive reminders, write rich notes, and keep changes synchronized across clients.

  3. 03

    sources, artifacts, and cited memory

    Raw inputs remain Sources, authored notes and research become Artifacts, and derived people, projects, places, and topics become Memory with provenance.

  4. 04

    durable personal-agent threads

    Agent conversations retain their chosen agent revision, ordered turns, run state, tool activity, and final result so work can survive retries and client restarts.

  5. 05

    inspectable corrections

    A remembered fact can be retracted, replaced, or restored without rewriting history. New conflicting evidence becomes visible instead of silently reviving old memory.

  6. 06

    web, mobile, and desktop clients

    The same typed product contracts drive a Next.js web app, an Expo mobile client, and a Tauri desktop shell without giving any client direct control over the agent node.

how it's built

the decisions underneath

Convex is the coordination spine

Reactive product state, agent threads, commands, jobs, leases, and bounded run events live in Convex so every client sees the same accepted state.

agents run on a user-controlled node

A persistent Bun process claims capability-compatible jobs, runs or resumes Pi sessions, journals durable effects, and reports redacted progress back through Convex.

storage follows clear authority boundaries

Convex owns editable product state, the Markdown vault owns derived transcripts and entity files, and node-local SQLite owns disposable full-text and vector indexes.

turn submission is atomic and retry-safe

One mutation commits the user message, pinned agent revision, command, and queued job. Stable identities and leases prevent duplicate turns or duplicate final answers during retries.

memory is cited, projected, and reversible

Stable source references become Markdown projections and reactive relations with provenance. Corrections append new evidence instead of mutating history in place.

clients consume repositories, not infrastructure

Web, Expo, and Tauri bind to the same typed repository contracts. The clients subscribe to state and submit intent; they never address the private node directly.

runs on

Next.js 16the web app carries the dense productivity, knowledge, and agent surfaces while sharing typed repositories with the other clients.Convextasks, notes, reminders, sources, agent threads, jobs, and run events need one reactive coordination plane across clients.Expothe mobile client turns the same task, reminder, note, and agent contracts into quick action surfaces and notifications.Tauri 2the desktop shell keeps the accepted web product while adding a native boundary for local persistence and node control.Bun agent nodea persistent user-controlled process can run local agents, hold leases, journal effects, and access the vault without sending private state through the UI.Markdown + SQLitememory stays readable and portable in Markdown while SQLite provides rebuildable full-text and optional vector retrieval.

hover a tool to see why it is here

seen enough:

back home