The mindbeat

Your mind does work between your asks: it remembers what changed, tidies its own files, and checks that its rules still fit the tools it runs on. The mindbeat is the single clock all of that keeps time on — one heartbeat, and every background job counts off it. Its real job: keep the cheap work current, and never quietly spend on the expensive work behind your back.

One clock, not twenty timers

Without a shared clock, every background job needs its own timer — review captures hourly, check the tools daily, tidy the library weekly — and there’s no way to see, or change, the whole picture at once. The mindbeat replaces all of them with one beat plus a number on each job:

• The beat ticks on a schedule you set (say, every 15 minutes) — or, for a surface you only open now and then, simply the moment you open it.
• Each job says how many beats it waits: every beat, every 4th, every 96th.

Nothing keeps its own clock. They all count the same beat.

Not every beat costs the same

It’s tempting to think one dial — slow the beat, spend less — controls the bill. That’s only a third of the story. What a job costs is set by three things:

• How often it runs — the beat, and its every-N-beats number.
• How big a brain it needs — a shell command is free; a quick read is cheap; a full reasoning session (an agent thinking over your whole context) is where the real cost lives.
• How much it reads each time.

So the honest picture isn’t “everything on one dial.” A few jobs are almost free; a few are expensive — and the expensive ones stay expensive no matter how rarely you run them. Slowing the beat trims the cheap tail and barely moves the bill. The lever that matters is whether the expensive jobs run on their own at all.

The lean heartbeat — cheap runs itself, expensive asks first

So the beat sorts every job by what it needs to run:

• a shell job — housekeeping: rendezvous, push your notes, keep the shared to-do list tidy. Practically free.
• a read-and-report check — a quick look, like do my rules still fit this tool? Cheap.
• a full reasoning session — an agent thinking over your whole context: reviewing and improving memory, sweeping the library, doing dispatched work. Token-heavy.

By default a beat runs only the shell and read-and-report jobs on its own. A reasoning job doesn’t fire silently — and it doesn’t run on the clock: it comes due when enough has actually piled up to be worth it (say, enough new notes to make a review pay off), not on a fixed timer. Slow weeks skip it entirely; a busy day triggers it early — the cost tracks the work, not the calendar. When it does come due, the beat raises its hand: it drops a note on your shared to-do list (“time to review captures — run it?”) and spends nothing until you say go. A lean heartbeat keeps the cheap state fresh and surfaces the expensive work as your choice, instead of running it while you’re away.

Let a surface do more

“Run it on its own, or ask first?” is answered per surface.

A surface is any machine or tool your mind runs on. Every surface starts lean — the cheap jobs, and tidying the shared to-do list. To let one do the heavy work unattended, you clear it as a driver: it may pick a to-do off the list and run it itself, where a lean surface would only tidy the list and surface the work for you.

Here’s the shape that makes this pay off: a job is due for the mind, not for one surface, and the shared clock runs it once. So you make your cheapest surface — a free local model on a spare box — the driver, and it quietly carries the heavy work. Your metered laptop stays lean, so a background sweep never lands on the plan you pay for. Same work, run once, on the surface you chose to spend (or not spend) on.

And it’s safe from day one: a brand-new surface begins lean, so there’s nothing costly to run and nothing you need to know about its price yet. You weigh cost only later, if you choose to make it a driver.

Easy button, glass box

Easy button. MemMini ships it working: a beat, a starting rhythm for every job, and every surface starting lean. It just runs — and it won’t touch the expensive work without you.

Glass box. Every rhythm is a knob and every surface’s reach is yours to set. Tidy the library daily instead of weekly? Turn the dial. Let the spare box carry the reasoning? Make it a driver. Want finer grain — a surface that runs its own reasoning sweeps but doesn’t pick work off the shared list? Those are separate switches. Nothing hidden, nothing hard-coded: the same simple-by-default promise, now covering both time and cost.

How a beat runs — the skill is the router

A surface schedules exactly one thing: the mindbeat skill, which is a router. On each beat it reads three things — the ledger (which jobs are due), the surface’s capabilities (what it can do), and the surface’s reach (what it’s cleared to run on its own) — and then:

• a due job it can do and is cleared for → runs it, and claims it so no other surface repeats it;
• a heavy job it could do but isn’t cleared for → surfaces a to-do for you instead of spending;
• a job it can’t do at all → leaves it for a surface that can.

Same entrypoint on every surface; what runs, what waits, and what’s handed off all fall out of capabilities + reach. Because the jobs live in one shared ledger with a single-fire claim, each fires once across the whole mind, however many surfaces are beating.

The small mindbeat.sh script is just plumbing the router calls — figure out what’s due, record a beat, claim a job. It is not the beat; the beat is the skill, run by the agent. Wire a scheduler to the script instead of the skill and only the shell work ever fires — the reasoning never does.

One heartbeat. The cheap work runs itself, the expensive work waits for your say-so, and you decide — per surface — how much your mind may do on its own.