The architecture is simple: jot add "..." writes to SQLite and returns immediately. A detached background worker picks up the note and sends it to a local model for enrichment. By the time I next search or summarize, the note already has tags, action items, linked notes, and an urgency flag. None of it required waiting.

Two problems

Cloud note-taking has a privacy problem. Every note I write lives on someone else's server. For personal logs, meeting notes, and work context, that's a real concern, not a theoretical one.

API-based AI analysis has a cost problem. Running every note through a frontier model adds up. For background enrichment across hundreds of notes over months, the per-token cost isn't zero. Local models solve both: they run on my machine, they cost nothing per query, and they're good enough at classification, tagging, and extraction.

Instant capture, async analysis

The core architecture: instant capture, async enrichment.

jot add "met with advisor, discussed timeline for paper, need draft by June 1"

That saves to SQLite immediately and returns an ID. Done. In the background, a detached worker process picks up the note and sends it to the local model. The model extracts tags, action items, linked notes, and project associations. Those get written back to the note record.

The capture path has zero AI latency. The enrichment path runs offline, async, at whatever pace the local model handles. By the time I next search or summarize, the note is fully analyzed. I didn't wait for any of it.

This is the same pattern lobs-core uses for agent workers: submit fast, process in background, query the results later. It works for notes for the same reason it works for agent tasks. The user doesn't want to wait for enrichment that can happen after the fact.

What the local model extracts

For each note, the model pulls out:

  • Tags: topic labels
  • Action items: things that need to happen
  • Linked notes: other notes in the database this one relates to
  • Projects and people: structured entities mentioned in the text
  • Urgency flag: whether this note describes something time-sensitive

None of this requires a frontier model. A local Qwen or Llama running in LM Studio handles it well. The prompts are straightforward structured extraction: "here is a note, extract the following fields." Local models are reliable at this class of task. The tradeoff (lower quality on creative or complex reasoning) doesn't matter for tagging.

The extracted data lands in SQLite alongside the raw note. jot search "paper deadline" queries against raw content and extracted fields. jot summarize aggregates action items and tag frequency across all notes. The AI did the work asynchronously; the query is just a database read.

The three-tier daemon

Jot runs a background daemon with three tiers of proactive behavior.

Tier 1 runs every 15 minutes: sync Gmail and Google Calendar (if connected), analyze any unprocessed notes, check for overdue todos. Cheap, fast, runs constantly in the background.

Tier 2 runs at 7:30am: generate a daily digest of outstanding action items, upcoming calendar events, and open todos. Delivered to Discord or the terminal.

Tier 3 is event-driven: fires immediately on overdue todos, urgent note flags, or high-priority incoming email.

The tier structure exists for the same reason lobs-core's monitor uses rule detectors before LLM calls: most checks should be cheap and produce nothing. Only the morning digest involves a real LLM call to produce human-readable output. Everything else is rule evaluation on structured data already in SQLite.

The learning file

All prompts inject ~/.jot/user.md, a two-section file. The first section is manual: a short description of who I am, what I'm working on, and what kinds of notes I take. The second section is auto-maintained: after each batch of analysis, the model appends new things it learned about me. Recurring people, active projects, patterns in my notes.

Over time, the tagging improves because the model understands context. A note about "the advisor meeting" gets tagged correctly because the user file already says who my advisor is and what project we're working on. The accuracy compounds over weeks.

The full file is plain markdown. I can read it, edit it, or delete the auto-learned section if it drifts. No black-box model state anywhere.

What it replaced

I used to take notes in a markdown file, grep for things occasionally, and lose most action items by the next day. The capture was fine; the retrieval was manual and unreliable.

Jot didn't change the capture behavior, just moved the target from a markdown file to a SQLite row. It added async enrichment, structured search, and a daemon that surfaces what I'd otherwise forget. The notes still live entirely on my machine. The AI made them queryable and proactive. That's the whole thing.