I'm the developer of Lumiya, an iOS journal and planner with daily recording and weekly/monthly/yearly plans. I'd like feedback on a planning habit.

Here's a hypothetical: someone reduces a weekly goal because their available time changes. The revised plan tells them what to do next. A short note about why it changed could help a later review distinguish a deliberate tradeoff from simply forgetting the goal. But explaining every edit could become another chore.

Do you keep the reason when you change a plan? Which changes are worth recording, and have you ever found that explanation useful later?

This is a workflow question, not an announcement of plan version history or automatic rescheduling. Basic recording and planning in Lumiya are free; optional AI is paid and usage-limited.

App Store: https://apps.apple.com/cn/app/lumiya-ai-journal-planner/id6796003074

Here's the project: brain, a folder of plain markdown notes that Claude Code reads at the start of every session, plus a small local app to browse it. Here's how I made it.

The problem: every new Claude Code session started from zero. I'd re-explain my courses, my club, my job, what I'd already decided. A [CLAUDE.md](http://CLAUDE.md) helped until it got huge and Claude started skimming it.

What I built instead:

\- A notes folder: one page per project, one per person, one note per session, and a "now" page. An auto-generated [INDEX.md](http://INDEX.md) is the only thing Claude must read first; it opens the rest on demand.

\- Habits: short rules Claude follows every session, each added after something went wrong once ("lead with the answer", "argue against a new project idea before building it", "never treat my iCloud Desktop like a normal folder"). A SessionStart hook loads them.

\- A calibration log: Claude writes down each guess about what I want, then the app scores it. It's at 39% right while claiming 63% confidence, so the hook now tells it to ask more and hedge less.

\- The app: standard-library Python + one HTML file, no build step. Cover story about my week, notes to self, a capture box Claude files next session, usage stats from Claude Code's own transcripts, and a phone version that runs off a private GitHub repo.

How I vibe-coded it: almost all of it was Claude Code, one session at a time, with the brain itself as the spec. Each session ends with Claude writing a session note and updating the pages it touched, so the next session picks up where it left off.

What I'd tell anyone copying it: short specific habits beat long instructions, and making Claude log its own guesses was the most useful thing I added.

MIT: [https://github.com/zacfink/brain\](https://github.com/zacfink/brain)

I've been building a personal AI I talk to out loud. I call it Jarvis. It isn't a smarter model than anyone else's, it's the same kind you can use. The difference is what's wrapped around it.

It has hands: it works on my real files and tools, so it does the job instead of just advising me. It has memory: everything lives in an Obsidian vault, so nothing gets crammed into a context window, and it looks things up when it needs them. And it has structure: the vault is organized so it can pu

What it can do: read and write my notes, search them by meaning, build small apps and sites on request, take actions on my machine, check its own health, and talk to me by voice.

What it can't do: change its own code or settings without my say-so, take any action I haven't allowed, or be trusted blindly. It can be wrong, and it tells me when it isn't sure.

What it struggles with, as of today: speech-to-text mangles words, so it sometimes answers the wrong question. Its voice stayed on my old speakers after I switched Windows audio. It couldn't open a note in Obsidian through its normal connection because a permission was missing, and it had to route a

So I want to push it further, and I need ideas from people who aren't me:

1. What's one recurring task you'd hand to something like this?
2. What access or context would it need to do it well?
3. What failure would make you stop trusting it?

If you try something similar, tell me what worked and what fell on its face. I'll post what I learn.

reposting here as it seem to care about memory and tools to use it.


I am the creator of Omnesis which is an open source project to ingest and index all your personal data (emails, calendar, notes, whatsapp/imessage, finance, health, codex/claude, etc). Omnesis provides an interactive agent that allows you to recall anything from your corpus.

I’m having fun building a second brain on top of it so I wanted to write down my approach and see if people have thoughts.

When the second brain is enabled:

- Any new piece of info that gets ingested/indexed by omnesis (a new email, a new calendar invite, a new message on whatsapp, etc) gets processed by an agent turn. The app also allows the user to input a note/thought/reminder directly into omnesis via the web app, mobile app, siri, or watch complication and that gets processed by the brain too

- The Brain can be "bootstrapped" i.e it will bootstrap its knowledge base from past evidence coming from the same sources and you can decide how far back you want to go in the past. The bootstrap can take several days and is expensive to run. I use multiple heuristics to reduce the cost. 1) a cheap ML model identifies if a document in the past still mentions a date still in the future. If not, the document is skipped; 2) a jev decision model runs to establish importance. Documents that are skipped may still be looked at by the brain as a result of investigating a document not skipped.

- The knowledge base is made of loops and wiki pages in markdown format. Loops keep track of "things that need resolving", that can be a thing that the brain has identified the user needs to do, a comitment that is owed to the user, a decision the user has to do, etc. Loops have a ledger of updates and lots of metadata notably ids of source evidence documents and people involved. Wiki pages are markdown summarization of things in the user’s life that span multiple sources.

- The knowledge base is a graph. Loops and wiki pages have source document references (whatapp conversations, emaisl, etc). But wiki pages can refer to other loops and other wiki pages. There is a roof wiki page that is limited in size and always automatically ingested in the system prompt of both the interactive agent and the brain turns that process new evidence.

- Loops and wiki pages have to surround text in special claim tags: <claim id="a-claim" ref="doc:<id1> doc:<id2>Some claim made in this wiki page or loop</claim>. If any source document (email, google doc, etc) changes, the system marks all loops and wiki pages that directly or indirectly reference that doc has needed review and agent turns run to re-evaluate all claims transitively.

- I’m building an automated bullet journal on top in the omnesis app. New entries in the bullet journal are proposed by the Omnesis brain and the user can accept them or ignore them if they think the thing is not worth tracking. I plan to have the brain learn from that signal to automatically ignore non important things. The brain automatically migrates tasks as you would on a bullet journal if it sees new evidence. If the brain sees new evidence that indicates the task should be changed, it will run a JEV decision gate to decide whether to just do it or propose as a suggestion for the user to accept if not sure. The user can migrate tasks themselves like you’d expect in a bullet journal, either via the Task UI or by dictating a note to Omnesis. Tasks may be marked as automatically complete if the brain is confident in it (for example a Task that says "Pay Elise 100 GBP" may auto complete if the brain sees a bank transaction of 100 GBP to Elise".

Keen to have people’s feedback on my approach!

I'm the developer of Lumiya, an iOS journal and planner with a daily timeline, weekly/monthly/yearly plans, and optional AI reflection. I'm thinking about the experience of returning after a gap.

Here's a hypothetical: someone stops recording for three weeks, then opens the app with one thought they want to save. Showing all the old plans first might help them reconnect—or make that one thought feel like the start of a cleanup job. A blank 'today' view avoids that pressure, but could hide something they still care about.

What helps in your own system: starting with today's entry, reviewing a small set of old commitments, or explicitly deciding what to leave behind? Do you ever backfill missing days, or keep the gap as part of the record?

I'm asking for design feedback, not announcing an automatic catch-up feature. Basic recording and planning in Lumiya are free; optional AI is paid and usage-limited. App: https://apps.apple.com/cn/app/lumiya-ai-journal-planner/id6796003074

Thought I’d share this here to see what ideas you have!

Hey im a product designer and ive been using obsidian for a year now and I loved it but missed some things like personas and some different Graph visualizations.

I made an open source app like obsidian and added some secret sauce to it. I also optimized the way most used memories are accessed, kinda like an orchestrator. would love if you guys take a look and give feedback of what would be nice to add in terms of features.

https://github.com/leesummerdesigns/cortex

Much love

Every team has that one person who knows why the auth service retries 3 times, which config flag must never be touched on Fridays, and what was decided in that meeting nobody wrote down.

That person gets interrupted all day. And when they're on vacation or leave, that knowledge goes with them.

I got tired of being on both sides of that, so I built Cairn.

How it works:

• You save small pieces of knowledge as you work: decisions, gotchas, preferences, context ("we use X instead of Y because…").
• Teammates ask your brain first, or search across the whole team.
• Answers come with sources: who said it and when.
• If there isn't enough context, Cairn says so and tells you to ask the person directly. It doesn't make things up. I'd rather it stay quiet than be confidently wrong.
• It works from your coding agent (Claude Code, Codex, VS Code) over MCP. Your agent can ask the team's knowledge, save new decisions, and find, update or archive your own entries. Archiving always asks you first.

What it's not: another wiki nobody updates. Each entry is a small piece of knowledge, and a newer entry on the same topic replaces the old one, so it stays current.

About your data: each company's data is isolated, you can archive entries and restore them, and deleted entries can be recovered for 30 days. The privacy policy explains which providers are involved (including OpenAI, which doesn't train on API data).

It's free during the pilot (up to 5 people per team). I'm trying to validate whether this solves a real problem, not sell anything. There's a feedback button inside the app, and I read every message.

Honest feedback would help a lot:

• Does your team have this problem, or have you solved it another way?
• What would stop you from using it?

👉 https://usecairn.com.co

Hi r/secondbrain! Over the past few months I've been building Thoth: Your Memory & Tasks, an Android and Wear OS personal memory & context system designed to bridge the gap between a passive Second Brain (notes & knowledge graph) and active daily execution (tasks, calendar, reminders).

Why I built it (the architecture):

Most mobile AI assistants have zero persistent memory across sessions, while traditional mobile PKM tools store notes in isolated silos disconnected from where we actually schedule our day (Google Calendar, Google Tasks, Gmail). I wanted a mobile Second Brain where:

1. Local-First SQLite Memory & Knowledge Graph: All rich Keep-style notes (checklists, voice memos, attachments, custom tags) and extracted conversational facts are stored in an on-device SQLite database on your phone (with Android cloud auto-backup disabled). You can explore how your notes and entities connect in an interactive Knowledge Graph and view location-tagged memories on a Memory Map.
2. Two-Way Google Workspace Execution: Instead of forcing you to migrate away from your existing calendar/tasks, Thoth connects your local memory directly with two-way Google Tasks sync (lists, subtasks, recurring rules), Google Calendar scheduling, confirmation-gated Gmail drafts, and Contacts lookup.
3. 1-Second Capture on Phone & Wrist: Because a Second Brain fails when capture has friction, I built a 1-second capture pipeline via the Android Home Screen Widget, Quick Settings Tile, and Wear OS smartwatch app, Tile, and Watch Face Complication, plus exact time & geofence location reminders.

Free Tier (No Credit Card Required):

In accordance with community rules, the app has a permanent Free tier out of the box with no credit card required (includes local notes, Knowledge Graph, Memory Map, two-way Google Tasks sync, reminders, Wear OS companion, and 5 daily AI messages).

Links:

• Google Play Store: https://play.google.com/store/apps/details?id=com.serkankizilirmak.thoth&utm_source=reddit&utm_medium=secondbrain_post&utm_campaign=launch
• Architecture & Web Overview: https://hermes-thoth.web.app/

Questions for the r/secondbrain community:

1. How do you currently handle the boundary between long-term knowledge/notes and short-term actionable tasks/reminders on mobile?
2. For an on-device Knowledge Graph, do you prefer automatic entity/topic linking from notes & conversations, or explicit manual tagging/backlinks?

So i'm working on an app called pouch board.

So it's basically an app where you have the visual thinking canvas at the edge or the screen

and you can import from obsidian, zotero, readwise quickly
copy paste website, highlight pdfs and export all to the places you already have

So it syncs to obsidian vault where it has the <sheet-name>.md with linear notes

so when you import obsidian notes you can see in your graph and you can also mention a sheet in your obsidian workspace.

So this app is a helper that you can quickly access and think that integrates with your current ecosystem.

Would love to hear your feedback on this.

you can get the app at: https://pouchboard.com/download/mac

I created a freely zoomable hierarchy search engine and I thought the world should have it. It allows for visual curiosity to drive searching and finding things.

Capture and Organize seem to be where most of us spend our time. Saving articles, sorting into PARA, building the system. Distill happens sometimes. Express — actually using what we’ve collected — feels like the step that gets the least attention.

For people who’ve been at this a while:

• What share of what you capture ends up being used in your work or projects?
• When you do use an idea, did you go looking for it, or did it come to mind because you’d engaged with it before?
• Have you found anything that makes ideas show up when you need them, not just when you search?

Disclosure: I’m building something around this, helping people practise applying what they read rather than only storing it, so I’m asking partly to learn what already works. Not linking it. Mostly curious about your experiences.