Workbrain gives Claude persistent local context about how you work, your weekly agenda, work log, and commits, and lets it update that context during sessions.
Retrieve unified context: playbook, agenda, recent work log, and commits (get_context).
Read and update your personal playbook (get_playbook, update_playbook).
Manage a weekly agenda: view, add, update, delete, and roll over items (get_agenda, add_agenda_item, update_agenda_item, delete_agenda_item, rollover_agenda).
Mark agenda items done with optional auto work logging (update_agenda_item).
Log work summaries and link them to agenda items (log_work).
Review work logs, weekly summaries, and git commits (get_work_log, get_weekly_summary, get_commits).
Capture commits automatically via optional git hook.
Provides integration with Git repositories by automatically capturing commit activity through an optional post-commit hook, recording hashes, branches, messages, and changed files into a local database.
Uses SQLite as the local storage backend for agenda items, work log entries, and commit records, enabling persistent and queryable data management.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@workbrain What's my current focus and recent work?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Your personal operating layer for AI-assisted work.
Workbrain is a local Model Context Protocol (MCP) server for Claude Code. It gives Claude persistent context about how you work, what you're focused on this week, and what you've shipped — without sending that data to the cloud or sharing it with your team.
Most AI coding setups tell the model how to behave (rules, prompts). Workbrain tells it what you're doing — and lets it keep that picture up to date as you work.
Layer | What it stores | Example |
Playbook | How you work | Bug-fix approach, communication style |
Agenda | What you're focused on | This week's priorities and deliverables |
Work log | What you shipped | Summaries linked to agenda items |
Commits | Raw git activity | Auto-captured via optional hook |
Everything lives on your machine in ~/.workbrain/. Nothing is committed to project repos unless you choose to.
Related MCP server: acheron-mcp-server
Unified context — get_context returns playbook, agenda, work log, and commits in a single call
Living weekly board — Claude can add, update, and complete agenda items during a session
Automatic work logging — marking an agenda item done creates a linked work log entry
Local-first & private — SQLite + markdown on disk; no accounts, no cloud sync required
Cross-project — registered at user scope; follows you across every repo
Git integration — optional post-commit hook records commits automatically
CLI — check your week from the terminal without opening Claude
Node.js 22+ (uses built-in node:sqlite — no native dependencies)
Claude Code CLI or extension (Cursor, VS Code, or terminal)
git clone https://github.com/himanshu-sharma-55/work-brain.git
cd work-brain
npm install
node bin/install.jsRegister the MCP server (server name is workbrain; repo folder is work-brain):
claude mcp add --scope user workbrain -- node /absolute/path/to/work-brain/src/index.jsSet WORKBRAIN_ROOT once per machine:
# macOS / Linux — add to ~/.zshrc or ~/.bashrc
export WORKBRAIN_ROOT=/absolute/path/to/work-brain# Windows PowerShell (persists for new terminals)
setx WORKBRAIN_ROOT "C:\path\to\work-brain"Verify in Claude Code: type /mcp and confirm workbrain is connected.
Edit your playbook: ~/.workbrain/playbook.md
┌─────────────────────────────────────────────────────────┐
│ Claude Code │
│ (Cursor / VS Code / CLI) │
└────────────────────────┬────────────────────────────────┘
│ MCP (stdio)
▼
┌─────────────────────────────────────────────────────────┐
│ Workbrain Server │
│ get_context · get_agenda · log_work · get_commits … │
└────────────────────────┬────────────────────────────────┘
│
┌──────────────┼──────────────┐
▼ ▼ ▼
playbook.md data.db git hook (optional)
(how you work) (agenda, (commit capture)
work log,
commits)
└──────────────┴──────────────┘
│
~/.workbrain/
(or WORKBRAIN_HOME)Claude calls Workbrain tools on demand — your rules aren't loaded into every message, keeping context lean until it's needed.
Tool | Description |
| Recommended entry point. Playbook, current agenda, recent work log, and commits |
| Read your personal playbook |
| Replace or append to your playbook |
| Weekly board: focus, coming up, expected |
| Add an item to the board |
| Update status, title, estimate, etc. Auto-logs work when marked done |
| Remove an agenda item |
| Move unfinished items from last week to the current week |
| Agenda stats, work log, and commits for a given week |
| Recent work summaries |
| Log what you shipped (optionally linked to an agenda item) |
| Recent commits captured by the git hook |
Add this to your personal Cursor or Claude rules:
At the start of a work session, call
get_context. When we finish a clear task, update the agenda and log work. Marking an agenda item done is enough — it auto-logs.
You say | Workbrain does |
"What's my focus this week?" | Calls |
"Mark CSV export as in progress" | Calls |
"What did I ship this week?" | Calls |
"Roll over unfinished items" | Calls |
"How do I usually fix bugs?" | Reads playbook |
Check status without Claude:
node bin/workbrain.js status # current week at a glance
node bin/workbrain.js summary # full week recap
npm run status # shortcut via package scriptVariable | Default | Description |
|
| Data directory (playbook, database) |
| — | Path to the work-brain repo; required for git hooks |
~/.workbrain/
├── playbook.md # How you work (markdown)
├── data.db # Agenda, work log, commits (SQLite)
└── git-template/ # Git hook template (created by install)export WORKBRAIN_HOME=/path/to/shared/workbrain-data
claude mcp add --scope user workbrain -- \
env WORKBRAIN_HOME=/path/to/shared/workbrain-data \
node ~/work-brain/src/index.jsnode bin/install.js configures a global git template so new repositories automatically include the post-commit hook.
For an existing repository:
export WORKBRAIN_ROOT=/path/to/work-brain # macOS/Linux shell profile
# Windows: setx WORKBRAIN_ROOT "C:\path\to\work-brain"
node /path/to/work-brain/bin/setup-git-hook.js /path/to/repoEach commit records hash, repo, branch, message, and files changed into ~/.workbrain/data.db.
setup-git-hook.js writes to .git/hooks/post-commit. Repos that use husky set core.hooksPath to .husky/, so Git ignores .git/hooks/ and commits will not be recorded (you'll see 0 commits in status).
Fix: add (or append) this line in .husky/post-commit:
node "$WORKBRAIN_ROOT/hooks/record-commit.js" || trueConfirm with git config core.hooksPath. If it points into .husky (husky v9 prints .husky/_), use the path above instead of setup-git-hook.js.
To keep it personal, add .husky/post-commit to .git/info/exclude so it's never committed.
Clone and register on each machine:
git clone https://github.com/himanshu-sharma-55/work-brain.git ~/work-brain
cd ~/work-brain && npm install && node bin/install.js
claude mcp add --scope user workbrain -- node ~/work-brain/src/index.jsEach machine maintains its own ~/.workbrain/ by default. To sync data:
Method | Approach |
Cloud folder | Symlink |
Dotfiles repo | Track |
Shared path | Set |
Workbrain registers as a user-scoped MCP server via the Claude Code CLI. That works the same whether you run Claude Code in the terminal, VS Code, or Cursor.
Install Claude Code (CLI and/or editor extension)
Run claude mcp add from Quick start
In Claude Code, type /mcp and enable workbrain
Workbrain does not use editor-specific MCP config files (for example Cursor's ~/.cursor/mcp.json). Keep registration on --scope user so it follows you across projects.
Workbrain is designed for individual use:
MCP is registered with --scope user — not tied to any project repo
Personal data never leaves your machine unless you sync it yourself
Do not commit .mcp.json to shared team repositories
Issue | Resolution |
| Install Claude Code CLI or use the extension terminal |
Server missing from | Re-run |
Broken path after moving the repo |
|
Commits not recording / | Verify |
Server won't start | Run |
npm install
npm start # run MCP server (stdio)
npm run install:local # install + init data dir + git template
npm run status # CLI status checkFor local development with a global CLI alias:
cd work-brain && npm link
claude mcp add --scope user workbrain -- workbrainName | Used for |
| GitHub repository and local clone directory |
| MCP server name, npm package, data dir ( |
| Environment variable prefix |
Add an item to the weekly agenda board.
Inputs: title (required), type, week, notes, +2 more.
Remove an item from the weekly agenda.
Inputs: id (required).
Get the weekly agenda: focus items, coming up, and expected deliverables.
Inputs: type, week.
Get recent git commits recorded by the post-commit hook.
Inputs: days.
Get full personal context in one call: playbook, this week's agenda, recent work log, and commits. Call at session start.
Inputs: days.
Read how the user works: approach, bug-fix style, communication preferences.
Inputs: no named parameters.
Summary for a week: agenda stats, work log entries, and commits for that week.
Inputs: week.
Get recent work summaries logged by Claude or hooks.
Inputs: days, project.
Log a work summary after completing something.
Inputs: summary (required), type, project, commit_hash, +1 more.
Move unfinished items from a previous week into the current week (defaults: last week → this week).
Inputs: to_week, from_week.
Update an agenda item: status, estimate, title, etc. Marking done auto-logs work unless log_on_done=false.
Inputs: id (required), type, notes, title, +4 more.
Update the personal playbook. Use append=true to add a section without replacing the whole file.
Inputs: content (required), append.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 12 tools
Each tool targets a distinct resource and action: agenda items have get/add/update/delete, playbook has get/update, work log has log/get, and get_context/get_weekly_summary are clearly composite views. No two tools appear to do the same thing.
All tool names follow a consistent verb_noun pattern (e.g., get_agenda, add_agenda_item, update_playbook, rollover_agenda). The verb 'rollover' is unconventional but still follows the same structure, and there is no mixing of naming styles.
12 tools is well within the ideal 3-15 range and each tool covers a distinct function needed for personal work management: playbook, agenda, work log, commits, and summaries. No tool feels redundant or missing.
The agenda has full CRUD plus rollover, playbook has read/update, and work log has log/read with summaries and commit retrieval. The main gap is that work log entries cannot be updated or deleted, which could be an issue if a log entry contains errors.
Persistent context for Claude. Your AI always knows your projects and next actions across sessions.
Persistent memory for Claude Code and Cursor. Stop re-explaining your project every session.
A second brain for Claude: remembers your work, plans your day, encrypted under a key only you hold.
One memory for Claude, ChatGPT and Cursor, kept on your computer. Optional sync, encrypted first.
