I gave my AI a memory, and open-sourced the whole thing

Full disclosure up front: I am a founder, and this is about something I built and open-sourced. If that is not your thing, no hard feelings.

The problem was never the model

I run a small software company. Most of my day is a pile of small, different jobs: marketing, the website, a sales follow-up, a decision about a product. I started leaning on AI chat for all of it, and the model was genuinely good. That was never the problem.

The problem was that every new chat started from zero. I would re-explain the same context, the same positioning, the same constraints, over and over. Decisions I had made last week evaporated. The AI was smart, but it had amnesia, and I was the external hard drive.

Why I did not reach for an autonomous agent

The obvious 2026 answer is "use an agent." There is a whole wave of them now, the kind that go off and do things on their own. I looked, and honestly I did not trust handing over actions I could not see or verify. I did not want something acting on my company while I was not watching. I wanted to stay in the loop. I just wanted the thing to remember.

So I went the other way: not more autonomy, more memory.

The approach: a project that remembers

I use Claude Cowork, where a "project" is basically a workspace Claude can read and write. So I gave that workspace a structure and a habit.

The structure is just folders of Markdown:

• A context area for who we are and what we sell
• Working areas for marketing and the website
• A decisions folder with a decisions log and a list of open questions

The habit is the important part. Every meaningful task ends with a Memory Update: before calling it done, the assistant checks whether anything changed (a decision, an assumption, an open question, a risk) and writes it back to the right file. The next session reads those first.

That is it. No app, no database, no dependencies. But the effect compounds: after a few weeks the project actually knows the business, and it gets a little sharper each week instead of forgetting.

What it turned into

I cleaned it up, stripped every private detail, added a sanitized real workspace as a reference, and put it on GitHub as cowork-os, an open-source operating system for Claude Cowork. MIT.

It has three modules I actually use:

• A LinkedIn content system
• An outcome-driven "missions" workflow
• A set of recurring automations

The part worth calling out for builders: it started as "copy this folder, paste this installer." That works, but it is friction. So I also packaged it as an installable plugin. Now you add the marketplace and install it, and you get an always-on skill (the operating rules plus the memory protocol) and a handful of slash commands, with no copying.

If you build plugins, run claude plugin validate before you ship. It caught a YAML bug in one of my command files: a stray colon in the frontmatter that silently dropped all the metadata. Two minutes to fix, but it would have failed review.

The honest limitations

• It is a convention, not magic. It only works if you keep the habit.
• The plugin today ships the runnable core (the rules plus the commands) but not the full templates, so the guided setup leans on the repo for the high-fidelity version.
• And it is tied to one tool, Claude Cowork, though the method itself is portable.

Try it, or tell me where it breaks

Repo: https://github.com/yempik-ai/cowork-os

I am genuinely curious how other people handle memory and context across AI sessions, and where this approach falls apart at scale. If you try it, tell me what felt clunky. I am iterating in public.