DEV Community: tianfu wu

Turning Daily Context Into a Local Personal Wiki

tianfu wu — Tue, 09 Jun 2026 16:10:35 +0000

I do not want to write a personal wiki manually.

Most of the important material already exists before I sit down to organize it: diary notes, voice notes, messages, source logs, todos, and decisions made while working.

The problem is not a lack of information. The problem is that the information is scattered and disappears from working memory.

KnowYou MyWiki is an attempt to turn that daily context into a private local wiki that humans and AI agents can search later.

The workflow

During the day, KnowYou collects the context you already create:

diary notes
voice notes and transcripts
messages
app source logs
todos
project decisions

MyWiki then turns that material into source-backed pages around people, projects, decisions, concepts, sources, and todos.

The useful part is that each page keeps evidence. It should not feel like a vague AI summary that cannot be checked.

Why this matters for AI agents

Agents still start from zero too often. They ask the same background questions, forget project decisions, and miss context that was obvious yesterday.

A local MyWiki gives them a place to look first. The agent can retrieve cited local context before it answers, while the user keeps the memory layer on their own Mac.

This is the direction I want KnowYou to move toward: personal full-context infrastructure, not another blank-page note app.

Download for macOS:
https://giiift.site/know-you/

Demo:
https://www.youtube.com/watch?v=UiaAVBtqBx0

Your Workday, Remembered: Local Context for Humans and AI Agents

tianfu wu — Tue, 02 Jun 2026 17:20:45 +0000

Someone asks at the end of the day:

"Did you actually get enough done?"

It is an uncomfortable question because the answer is often yes, but the proof is scattered everywhere.

Modern work does not happen in one place. It happens across a code editor, browser tabs, notes, meetings, copied snippets, documents, notifications, todos, and small decisions that never become a clean artifact.

The work happened. But by the time you need to explain it, the day has already fragmented.

That is the story I am working on with KnowYou.

Download KnowYou for macOS:
https://giiift.site/know-you/

The problem: work is real, but hard to reconstruct

At the end of a day, I might remember the obvious outputs:

shipped a fix
wrote a doc
joined a meeting
replied to a teammate

But the useful context is usually more detailed:

why the fix mattered
which source led to the decision
what todo emerged from the conversation
which document changed
what should be remembered tomorrow

This is especially painful for people who work with AI agents. The agent starts from zero unless you manually explain what happened yesterday.

Local memory, not monitoring

There is an important distinction here.

I do not want employee monitoring software.

I want self-owned memory.

KnowYou is designed around the idea that your work context should belong to you. It should live locally, be readable by you, and be inspectable through source evidence.

That is different from tracking people for management dashboards.

The goal is personal context: for status updates, weekly reviews, reflection, and AI agents that need to understand what happened before they start working.

Why source evidence matters

A generated summary without sources is hard to trust.

If a memory says "reviewed onboarding issue", I want to know where that came from. Was it a note, a file, a notification, a copied snippet, or a document?

Source evidence changes the feeling of the product.

It turns memory from a vague AI summary into something you can inspect, correct, and reuse.

What KnowYou turns into memory

KnowYou is a local-first macOS app that turns scattered work context into a daily memory.

The workflow connects:

daily diary / timeline
source evidence
todos and follow-ups
My Wiki context
local Markdown storage
future AI-agent context

When someone asks what happened today, you should not need to reconstruct the day manually.

The day should already be readable.

Why this helps AI agents

AI coding agents are getting better at execution, but they still lack continuity.

They do not know what you did yesterday. They do not know which decisions were already made. They do not know which sources are trusted.

A local memory layer can become the missing bridge.

You capture the day for yourself first. Then, when an agent needs context, you can provide a trusted, source-linked version of what happened.

The small use case that matters

The first use case is very human:

Someone asks, "What did you do today?"

Instead of defending yourself from memory, you can show the day:

the timeline
the sources
the todos
the decisions
the summary

That is the kind of memory I want my computer to help me keep.

Download KnowYou for macOS:
https://giiift.site/know-you/

Building a Local Memory Layer for AI Agents on macOS

tianfu wu — Mon, 01 Jun 2026 08:00:14 +0000

AI coding agents are getting much better at changing code. The remaining problem is not always reasoning or tool use.

It is context.

Every new agent session starts with the same missing memory:

what I worked on yesterday
why a product decision changed
which file mattered
what note, message, or copied snippet led to the current implementation
what context should not be sent to a cloud service

Most of that context already exists on my Mac. It is just scattered across notifications, copied snippets, local Markdown, project files, terminal activity, and notes.

KnowYou is my attempt to turn that scattered local context into a source-linked memory layer for myself and for future AI agents.

Download for macOS: https://giiift.site/know-you/

Why memory should start local

For developer and knowledge-worker context, local-first matters for three reasons.

First, the data is sensitive. Work memory includes code decisions, private messages, debugging notes, customer conversations, and half-formed product thinking. I do not want the default architecture to be "upload everything and trust the vendor."

Second, memory should be fast and inspectable. If a daily summary says "you decided to change onboarding," I want to click into the source evidence and see where that came from.

Third, the useful unit is not just a document. It is a timeline of work: what happened, what mattered, what changed, and what an AI agent should remember next time.

What KnowYou does

KnowYou is a macOS app that builds a local daily memory from the context already available on your machine.

The goal is not to create another notes app. The goal is to make personal and project context reusable.

In the current workflow, KnowYou connects:

Diary: a readable daily memory
Todo: action items that emerge from the day
Other Source: source evidence behind generated memory
My Wiki: longer-lived personal/project knowledge
local Markdown storage
agent-ready context that can later be passed into tools like Claude Code, Codex, Cursor, OpenClaw, or MCP-style agent workflows

What changed in KnowYou 1.1.2

This release focuses on the first useful moment.

A memory product that opens to an empty screen feels broken even if the architecture is right. So I changed the first-run experience around proof.

New users now start with a real Demo Day instead of an empty app. You can click a diary paragraph and inspect the source evidence behind it. That makes the product easier to understand before your own data has accumulated.

After setup, KnowYou prepares recent memories from the last three days of available local history on the Mac. The point is to give users a useful surface immediately instead of asking them to wait.

I also added a clearer local privacy flow. KnowYou stores memory locally as Markdown and does not depend on a KnowYou backend server for your private working memory.

There is now an Applications install gate before Full Disk Access. On macOS, permissions can be confusing if the app is running from a temporary location, so the onboarding flow now pushes users toward the stable app bundle first.

Finally, there is a Diary Engine recovery nudge. If the local AI diary engine is missing or unhealthy, the app tells you instead of failing silently.

Why source links matter

Generated memory without source evidence becomes another black box.

For AI agents, that is dangerous. If an agent receives a summary but cannot tell where the claim came from, the summary becomes hard to trust.

So I think personal memory systems need a simple rule:

Memory should be readable, but also inspectable.

The user should be able to move from the generated paragraph back to the underlying source. That makes it easier to correct mistakes, remove sensitive information, and decide what context is safe to pass into an agent.

Where this is going

The bigger direction is a personal context layer for agents.

Today, every AI tool starts from zero unless I manually reconstruct the state of my work. In the future, I want agents to begin with the right local context: what I am building, what changed recently, what decisions were already made, and what sources they should trust.

That context should be owned by the user.

KnowYou 1.1.2 is a step toward that: local memory, source evidence, a better first-run workflow, and a surface that can become useful to both humans and agents.

Download KnowYou for macOS:
https://giiift.site/know-you/

I would love feedback from people who use AI coding agents every day. What context do you find yourself repeating most often?

Why I'm building a local-first memory layer for AI agents

tianfu wu — Mon, 18 May 2026 10:20:15 +0000

AI coding agents are getting better, but they still start most sessions with amnesia.

I use Codex, Claude Code, Cursor, and other agent workflows every day. The annoying part is not code generation. It is context repetition: what the project is, what I tried yesterday, why a decision was made, which logs mattered, and what the next agent should not forget.

That is why I built KnowYou MyWiki.

KnowYou MyWiki is a local-first Mac app that turns existing messages, logs, notes, and work traces into a source-linked personal wiki for AI agents. The goal is to make your working memory inspectable and reusable by future agents, without making your private work context a cloud profile by default.

What the first version does:

collects local working traces
turns messages and logs into readable memory
keeps source evidence attached
creates a MyWiki-style personal knowledge layer
exports memory for agent workflows

I care about the local-first part because working context is sensitive. It can contain code decisions, debugging notes, product strategy, private links, and half-formed thoughts. I want users to own it, inspect it, and decide which agents can use it.

Demo: https://www.youtube.com/watch?v=UiaAVBtqBx0
Product: https://giiift.site/know-you/

I would love feedback from developers using AI coding agents:

What context do you repeat most often to agents?
Would you trust a local-first memory layer more than a cloud memory product?