Working memory for Claude Code.
WORKINONIT wraps Claude Code. It knows which client and project every folder belongs to, and it works out from your sessions what's done and what's left. Claude gets all of it before you type your first prompt.
macOS · runs on your Mac · no server to manage
You're working on Rossi Studio site.
Rossi Studio site
- MacBookthis one
- Office Mac mini2 unpushed commits
- iMac3 h ago
- Renew the domain by Nov 30Rossi Studio
- Ship the builds to TestFlightBrand Nova
- Winter prices in the catalogAlpi Shop
Every Claude session starts from zero.
Claude Code is brilliant inside a session. Between sessions it remembers nothing: which client you're working for, what you decided yesterday, what you left half-done on the other Mac.
You re-explain everything, every time
Every session opens with you rebuilding the context by hand. Whatever you forget to mention, Claude doesn't know.
agent-nova-app.md
agent-alpi-shop.md
last edited: 3 months ago
Custom agents go stale
One prompt per client and per kind of work turns into a matrix to maintain. The corrections you make in a session never make it back in.
opening 14 files…
reading 38,000 tokens to answer
A second brain costs you on every question
A notes vault read by the agent has to be explored every time, by the most expensive model. The bigger it gets, the more it costs, and it can't tell what's still true.
Put the specialization in the place, not the agent.
The model and its tools stay generic. WORKINONIT ties instructions and memory to the scope you're in (client, project, folder), and it finds that scope from the folder where you open Claude.
- Derivescans transcripts and repositories, without you writing anything
- Consolidatea small model summarizes every session and types the notes
- Injectwhen Claude starts, it passes only that scope's context
Memory writes itself
Most of the memory nobody writes. It comes from your sessions, from git and from GitHub. You just work.
Pay the cost once
When a session stops, Haiku summarizes it in four lines. One small call, made once, instead of a search on every question.
Claude starts up to speed
A Claude Code hook resolves the scope from the folder and passes the brief. No semantic search: the folder is the query.
Everything Claude should know, right when it matters.
Every folder knows who it belongs to.
You organize your work into masters (a client, an agency, a product line) and projects. One project can live across many folders, repos, sites and servers.
- A folder resolves by longest path prefix, deterministically.
- A master's notes apply to all of its projects. Other clients never see them.
- If a folder belongs to no master, Claude asks you once and links it.
├─ Site ~/Clients/Rossi/site · github rossi/site · rossistudio.com
└─ Brand ~/Clients/Rossi/brand
The handoff writes itself.
Twenty minutes after a session stops, Haiku reads the transcript and writes the handoff: where you are, what you did, what's next, what you're waiting on. The next session, on any Mac, picks up from there.
- It runs isolated: no hooks, no ghost sessions.
- Each handoff replaces the last one, so the context stays short.
- On first run it rebuilds the history of every project.
- 10:02“fix the menu on mobile”
- 10:09Edit header.css, nav.js
- 10:21git commit -m "mobile menu"
- 10:24“the new photos arrive Friday”
- State
- Mobile menu done on
menu, not in main yet. - Done
- Rewrote header.css and nav.js, commit 3f2a1c.
- Next
- Merge and deploy.
- Waiting on
- New photos from the client, Friday.
Notes with a type and a natural expiry.
An open todo, a decision you made and a note from six months ago shouldn't weigh the same. Every note has a type, and the type decides how long it stays in context.
- todo leaves once it's done. Urgent ones stay on top everywhere.
- decision and fact stay: Claude won't reopen what you've already settled.
- lesson (coming soon) will carry over to similar projects too.
Three Macs, one memory, no server.
Each Mac keeps its own local database and writes only to its own folder in iCloud. It reads everyone else's and rebuilds the state. If you left unpushed work somewhere else, the brief tells you before you touch the project.
- Append-only event log, last-write-wins: no locks, no conflicts.
- Which Macs are online, what's in progress, what isn't pushed.
- The shared code means every Mac runs the same version.
sync/air/sync/mini/sync/imac/pull/push before touching the project
Corrections become rules. coming soon
workinonit learn will reread a project's sessions and find the moments you corrected Claude: rejected requests, reverted edits, redone operations. Each correction will become a lesson in the context.
- It will get better the more you use it, without rewriting prompts.
- Pipelines already make a proven method portable: record it once, run it in any master. How they work
All your work, on one local page.
The dashboard runs on your Mac. It shows where you left every project, what's urgent and what changed on your other Macs.
Diary
What you did yesterday or last week, by master and by project, with real active minutes. Breaks over 10 minutes don't count.
Notes from your phone
Dictate a voice note and it shows up transcribed in the Inbox, ready to assign to a project.
Search everything
One query on the local database, across every master.
Masters at a glance
Every client with its projects, how recent they are and what's still open.
Flat cost
Startup context doesn't grow with your archive: Claude reads only the brief for the current scope.
Why not an agent, or a second brain.
| WORKINONIT | Custom agents | Second brain read by the agent | Built-in memory | |
|---|---|---|---|---|
| Setup | None: context grows from your work | One prompt per client and task | Constant writing discipline | None |
| Knows which project a piece of information belongs to | Yes, from the folder | Only if it's in the prompt | Only if you search well | No |
| Startup cost | ≈ 100 tokens, flat | Fixed, often high | Grows with the vault | Varies |
| Tells open from closed | Yes: types and lifecycle | No | No | No |
| Learns from corrections | Coming soon, with learn | Only if you rewrite the prompt | No | Partly |
| Multiple machines | Yes, with warnings on unpushed work | Depends | With vault sync | Tied to the account |
Local, readable, yours.
Data on your Mac
SQLite database in ~/.workinonit. No account, no third-party cloud.
Open formats
The catalog is masters.json, notes are a .jsonl log. You can read them and version them.
No new model
Summaries go through your own Claude Code, with Haiku. Memory lives outside the model: switch models and you lose nothing.
Adds to, doesn't replace
A SessionStart hook, a skill and a CLI. Claude Code stays the tool you know.
Questions
What is it, exactly?
A layer between you and Claude Code. It catalogs your clients and projects, derives memory from your sessions and from git, and hands it to Claude when you open a session. It's not another assistant: it's the context the one you already use was missing.
Do I have to change how I work?
No. Open Claude in the project folder like you do today. The one rule is that every project lives inside a master: when you open an unknown folder, Claude asks you once where it goes.
How many tokens does it cost?
The starting brief is about 100 tokens. Haiku writes the session summaries, once per session, in the background. Your main model never acts as a search engine over the archive.
Where does my data go?
It stays on your Mac, in a local database. If you use several Macs, they sync through your own iCloud. There's no WORKINONIT server.
Does it work on Windows or with other models?
Today WORKINONIT is for Claude Code on macOS. Memory lives outside the model, so the format isn't tied to any vendor.
Your AI. Just less stupid.
WORKINONIT runs every day across dozens of real projects. Write to us and we'll help you set it up on your own work.