A weekly planner that lives
inside Claude.

Calendrome is a local-first scheduling engine for people who plan their week by talking to an AI. Hours are budgeted, time is tracked, and every adjustment is one sentence away.

BETA

This is an early beta. You install it locally, it spins up a SQLite file on your machine, and you experiment with it from Claude Code. Nothing leaves your laptop. Things will change. Bugs are expected. Feedback is welcome.

Why it exists

Three principles, illustrated.

Every other weekly planner pretends to solve scheduling with checkboxes and reminders. Calendrome takes the opposite bet: real time, real budgets, real conversations.

PRINCIPLE 01

If it's not on the calendar, it's not real.

You can talk about needing to do something. You can list it. You can intend it. But until time is actually allocated for it, it won't happen.

Calendrome makes the gap between "I should do this" and "two hours blocked Tuesday" as small as possible.

How: Tasks live with durations. Claude places them on real days. The week view shows the actual outcome, not the wishlist.
Wishful list
Finish ACME login spec
Plan Q3 roadmap
Study for cert
Call mom
Refactor billing
Actual week
MON3h
ACME spec
2h
Cert review
1h
TUE2h
Q3 roadmap
2h
WED1h
Call mom
7pm
PRINCIPLE 02

Work expands to fill the time allotted.

Even when client work drops, it still somehow takes all week — unless you budget deliberately. Without explicit hour caps, low-priority work absorbs every gap.

Calendrome makes hour budgets visible so you can see the drift and push back.

How: YNAB-style weekly hour caps per project. Soft warnings, not hard blocks — you decide what to do about overages. See the full envelope model ↓

ACME

11h / 20h

GLBX

9h / 10h

INTL

13h / 10h (+30%)

CERT

2.5h / 10h (-75%)

Budget bars from the actual GUI — over budget glows red, under glows muted.

PRINCIPLE 03

Claiming time should be one sentence.

The thing every other tool gets wrong is making "Tuesday night I'm doing nothing" into a settings exercise — recurring rules, calendar overlays, working hours panels.

In Calendrome that's one MCP call from a single conversational sentence. Same for reopening time.

How: The friction floor for adjusting your own schedule is a complete sentence. Never a click path.
YOU
Tuesday night I'm doing nothing.
→ calendrome.block_time
{
  "category_id": "work",
  "start": "2026-05-12T18:00:00",
  "end":   "2026-05-12T23:00:00",
  "reason": "off"
}
CLAUDE
Done — Tuesday 6pm to 11pm is now off-limits for work scheduling.
Architecture

Claude Code is the connector.

Calendrome doesn't reach out to anything on its own. It's a quiet local SQLite database with an MCP interface. Claude Code is what stitches it together with the rest of your stack.

External
Google Calendar events · meetings
External
Jira tickets → tasks
Local
Calendrome SQLite · MCP
External
Harvest time logs out
Hub
Claude Code
plans · connects · logs
What Calendrome owns

Tasks, projects, weekly hour budgets, time logs, availability windows, habit instances. The single source of truth for what you actually intend to do this week — stored in a SQLite file on your laptop you can rm any time.

What Claude does

Pulls Jira tickets, places events on Google Calendar, pushes time logs to Harvest. Calendrome stays local and dumb on purpose — Claude is the smart, networked, reasoning part that ties everything together.

The model

Give every hour a job.

Everything that claims your time is a commitment, and Calendrome budgets them the way YNAB budgets dollars — envelope budgeting, the same idea that works for money, applied to the actually-finite resource.

TASK

Ship the login spec. An estimate and a definitive finish line. Its blocks float wherever they fit.

HABIT

Stretch, daily, 15 minutes — or work out 4×/week, any days. Done or skipped per instance. You can't do the week's stretching in one sitting; the spreading-out is the commitment.

GOAL

Ten hours of prospecting before launch, or 3h of Spanish a week, forever. A bucket of hours — big chunks welcome, and the weekly ask re-paces itself when you fall behind.

EVENT

The standup. Owned by an external calendar. It just takes hours off the week's supply.

Your week has a real supply of hours. Spend it on purpose.

Calendrome computes what a week actually holds — your working windows, minus meetings, minus time you've blocked off. You assign that supply to envelopes: client caps that warn when you run over, goal floors that nag when you're falling short.

When something needs more than its envelope — the beautiful day, the client fire — you don't silently absorb it. You pull hours from another envelope, zero-sum, and the tradeoff gets named. Caps stay soft: warn loudly, never block. But drift can no longer happen unconsciously.

How: A YNAB-style budget view — Assigned / Activity / Available per envelope, To Be Assigned up top, every pull logged in Recent Moves and undoable.
YOU
It's gorgeous out — taking the afternoon for the trail. Take 2 hours from hobby, give it to ACME.
→ calendrome.pull_hours
{
  "week_start": "2026-07-13",
  "from": { "type": "project", "id": "hobby" },
  "to":   { "type": "project", "id": "acme" },
  "minutes": 120,
  "note": "trail afternoon"
}
CLAUDE
Done — 2h moved from Hobby to ACME, afternoon's clear. It's in Recent Moves if you change your mind.
Try it

Run it locally.

Calendrome is a local MCP server. No accounts. No cloud. The database is one SQLite file on your machine that you can delete whenever you're done experimenting.

Recommended: install the Claude Code plugin and let /calendrome:onboard walk you through MCP setup. Plugin install ↓ · Manual MCP-only install ↓

Plugin install (recommended)

1

Add the marketplace and install the plugin

Two commands — works from any directory.

claude plugin marketplace add mklute101/calendrome
claude plugin install calendrome

This is a self-hosted, GitHub-based marketplace. Calendrome is in beta and is not on the Anthropic official marketplace.

2

Run /calendrome:onboard

From any Claude Code session. Onboard handles the rest — clones the calendrome repo, builds the MCP server, registers it with Claude Code, and walks you through your first projects and budgets.

$ /calendrome:onboard
Where would you like to install calendrome?
[default: ~/dev/tools/calendrome]
3

Start planning

Restart Claude Code when onboard tells you to. Then try the /calendrome:week skill — or just say "create an ACME project, 20 hours a week".

$ /calendrome:week
Pulling Jira tickets…
Reading your calendar…
Here's a draft for 2026-05-11 → 2026-05-17.

Manual install (MCP only)

Skip the plugin and just register the MCP server. You'll have raw mcp__calendrome__* tools available but no /calendrome:* slash commands.

1

Clone and build

Requires Node 20+ and npm.

git clone https://github.com/mklute101/calendrome.git
cd calendrome
npm install
npm run build
2

Register it with Claude Code

From inside the cloned calendrome/ folder, one command:

claude mcp add calendrome \
  --env CALENDROME_DB="$PWD/calendrome.db" \
  -- node "$PWD/dist/src/mcp/server.js"

$PWD resolves to your current directory, so the absolute paths get filled in automatically. Verify with claude mcp list.

3

Start using the tools

Restart Claude Code. Calendrome's MCP tools are now available — call them directly, or just say "create an ACME project, 20 hours a week" and Claude will pick the right tool.

Optional dashboard: npm run gui opens the interactive weekly planner at localhost:3737 — drag blocks to reschedule, complete and snooze tasks inline. Same design system as this page — because they're the same product.