vibe harness · MCP server for working state

AI optimises for output. This one paces to the human.

Five working modes. Defeasible governance. Transition friction where leaping skips the metabolic work. Vibe Harness is a pull-only MCP server that adjusts the AI to where you actually are — and never interrupts to do it.

MCP server · stdio · works with Claude Code Pull-only · cooldown · session export ESL-A · Layer 1 available · biosignal layer designed

Wired but useless. Productively hollow.

Four hours in and your nervous system is cooked. Tools keep suggesting things faster than you can think. You're editing more than creating, and you're not sure which parts were yours. The problem is structural — AI is optimised for throughput; your nervous system isn't.

What you have today

Tools that give you the same energy at hour four they gave you at minute one.

A focus app that blocks distractions but doesn't know whether you're exploring or shipping.

Calendar guilt as the only mechanism telling you to stop — and it tells you too late.

What vibe harness gives you

Five named modes the AI actually respects — explore widens, build narrows, ship forbids new ideas, cool-off winds the session down.

Transition friction calibrated to the metabolic cost — explore→ship needs double confirmation; cooling off is always free.

A defeasible governor that explains every nudge and never silently overrides — pull-only, never interrupting.

Name where you are. The AI follows.

Each mode comes with its own AI behaviour preset and its own duration check-in. You set the mode. The AI's tone, verbosity, and willingness to introduce new ideas all shift. The act of naming is the move that changes the dynamic.

explore

Open. Divergent.

Follow threads. Let things stay ambiguous. Cross-project surfacing turned up.

build

Concise. Code-first.

Reasonable defaults instead of asking. Show the thing. Same-project bias.

think-with

Reflective.

Think alongside, not ahead. Longer responses. Less prescription.

ship

Decisive.

Catch scope creep. No new ideas. Finish what's in front of you.

cool-off

Minimal.

Wind down. The session is ending and that's fine. Suppressed surfacing.

Not all mode switches are equal.

Jumping from explore straight to ship skips the metabolic work of design and testing. The system makes you confirm that leap. Stepping back from build to explore gets an acknowledgement, not a wall. Cooling off is always free.

from ↓   to →
explore
build
think-with
ship
cool-off
explore
none
none
high
none
build
med
med
none
none
think-with
none
none
med
none
ship
high
med
med
none
cool-off
med
med
med
high
none — natural progression medium — acknowledged, allowed high — requires double confirmation

From a mode set to a defeasible nudge to a session export.

Five moments from a real working day: name a mode, switch with friction, meet a duration nudge, see the rule trace, export the session.

01
Set the mode
vibe_set_mode explore — tone shifts.
02
Switch with friction
explore → ship blocked until you confirm twice.
03
Duration nudge fires
45 minutes in build — vibe_check returns a check-in.
04
See the rule trace
Defeasible logic: which rule fired, what defeated what.
05
Export the session
Mode history + governance trace as JSONL.
vibe-harness · stdio
claude  vibe_set_mode --mode explore

mode:     explore     (was: think-with)
friction: none        think-with → explore is free

behaviour preset applied:
   · widen — follow threads, let things stay ambiguous
   · cross-project surfacing turned up
   · longer answers OK · code less prescriptive

written:  ~/.vibe-harness/mode-history.jsonl

# Sense, if installed, reads this file and reshapes retrieval.
# The naming itself is the move — the AI follows.
claude  vibe_set_mode --mode ship

⚠  high-friction transition: explore → ship

   You've been exploring. Shipping skips the metabolic work
   of design and testing. Are you sure you want to leap?

   confirm:  vibe_set_mode --mode ship --confirm
   step instead:
       explore → think-with → build → ship    (natural)
       explore → build (medium) → ship (none) (if reframing)

claude  vibe_set_mode --mode ship --confirm
accepted   leap recorded · governance trace stamped

# Friction is acknowledgement, not prevention. You can still leap.
# But the leap is named, and the trace shows it.
claude  vibe_check

mode:           build
duration:       46m  in current mode
session:        2h 12m
interactions:   89

nudge:  build duration check-in

   Building for nearly an hour. Are you in flow, or grinding?
   If in flow — keep going.
   If grinding — try `vibe_set_mode think-with` to step back,
   or `vibe_set_mode cool-off` to wind down.

cooldown:  next nudge no sooner than 14:38

# Pull-only. The nudge appears because you asked.
# It never interrupts a tool call or a generation.
claude  vibe_check --explain

rules evaluated:

   [1] cooldown            last nudge 16m ago · cap 15m     → pass
   [2] session duration    132m < 120m threshold          → skip
   [3] mode duration       46m in build > 45m              → FIRE
   [4] drift / interaction 89 < 100 cap                     → skip
   [5] circadian late      14:22 local · before 22:00      → skip

winner:  rule [3] — mode-duration check-in
defeats: nothing  (no higher-priority rule fired)

# Defeasible logic: rules are ranked, conflicts are explicit,
# overrides are visible. Silent governance is no governance.
$ vibe_session_export --out session-2026-04-30.jsonl

[history]  reading mode-history.jsonl …
[gov]      replaying rule evaluations …
[merge]    interleaving by timestamp …               

exported:
   · 7 mode transitions
   · 11 rule evaluations
   · 3 nudges fired
   · 1 high-friction leap (explore → ship · confirmed)

file:      session-2026-04-30.jsonl  14.2 KB

# Full governance trace. Diff-able. Auditable.
# Couples cleanly with EBS biosignals via shared session ID.

Three properties no productivity tool combines.

01 · Modes that bind AI behaviour

Naming the state changes the dynamic.

The AI's verbosity, willingness to introduce ideas, and same-project bias all shift with the mode you set. When paired with sense, retrieval reshapes too.

  • Five research-informed modes
  • Per-mode behaviour presets
  • Mode signal flows to sense, ebs, and downstream tools
  • Append-only mode-history JSONL
02 · Friction where it earns its place

Acknowledgement, not prevention.

The matrix is calibrated to the metabolic cost of each transition. You can still leap from explore to ship — but the leap is named, double-confirmed, and stamped on the trace. Cooling off is always free.

  • 5×5 transition friction matrix
  • High-friction transitions require --confirm
  • Cool-off is always permitted
  • Every transition recorded
03 · Defeasible governance

Rules that can yield. Visibly.

Six prioritised governance rules. Each can be defeated by a higher-priority rule. Every evaluation is traced. Silent overrides are invisible governance — and that's the failure mode this tool refuses.

  • Cooldown · session · mode · drift · interaction · circadian
  • Pull-only — never interrupts
  • Per-rule explain output
  • Cooldown caps nudges at 1 per 15 minutes

An MCP server. A JSONL log. Control stays with you.

Vibe Harness ships as a stdio MCP server. Mode state lives in ~/.vibe-harness/mode-history.jsonl — append-only, plain text, yours to keep. The agent calls vibe_set_mode, vibe_check, vibe_nudge, or vibe_session_export. Nothing else moves.

┌──────────────────┐ ┌─────────────────────┐ ┌──────────────────┐ │ Claude Code │ │ vibe-harness MCP │ │ mode history │ │ │ stdio │ │ append │ │ │ vibe_set_mode │────────►│ friction matrix │────────►│ JSONL │ │ vibe_check │ │ defeasible rules │ │ yours · local │ │ vibe_nudge │◄────────│ cooldown gate │ │ │ │ vibe_session_ │ │ governance trace │ └──────────────────┘ │ export │ │ │ │ └──────────────────┘ └──────────┬──────────┘ │ │ ▼ │ ┌────────────────────────┐ │ │ sense reads mode → │ │ │ reshapes retrieval │ │ │ ebs shares session ID →│ └─────────────►│ joinable biosignal │ │ downstream agents │ └────────────────────────┘

Pull-only, by design

The system never interrupts. Nudges appear when the agent (or you) calls vibe_check. Calendar guilt goes to the calendar; this stays out of the way.

Append-only history

Mode-history is a JSONL log under ~/.vibe-harness/. Every transition stays. You can replay, diff, or pipe it to your own analysis.

Cooldown means it can't nag

One nudge per 15 minutes. Defeated by nothing. Even if every other rule fires, you only see one of them. The system has bandwidth too.

Three layers, built incrementally

Layer 1 (modes + governance) is available. Layer 2 (Polar H10 HRV via EBS) is designed. Layer 3 (semantic coupling from conversation history) is the research horizon.

Couples with sense and ebs

Sense reads the active mode and reshapes retrieval. EBS shares a session ID so biosignal trajectories can be aligned with mode transitions post-hoc.

Configurable rules

Cooldown windows, mode-duration thresholds, and circadian boundaries all live in config. The defaults are research-informed; the knobs are there when your tempo differs.

Frequently asked questions.

How is this different from a focus-mode app or pomodoro timer?
Focus apps block distractions. Pomodoro counts intervals. Neither talks to the AI you're working with. Vibe Harness binds your named state to the agent's behaviour — so a build session looks different from an explore session inside the same chat.
What does "defeasible governance" actually mean?
Each rule has a priority. A higher-priority rule can defeat a lower one (cooldown defeats every other nudge for 15 minutes). The governor can explain which rule fired and which it defeated. The alternative — silent overrides — is invisible governance, which is the failure mode this tool refuses.
Does it interrupt my work?
No. Pull-only. The system surfaces nudges when called. The agent decides when to call it. You can ignore every nudge and the tool will not nag.
Can I change the modes or the friction matrix?
Modes are fixed for now — the five are deliberately small and research-informed. Friction values, cooldown windows, and rule thresholds are configurable. The roadmap considers user-defined modes once the five-mode pattern has more session data behind it.
What about the biosignal layer?
Layer 2 reads HRV from EBS — not to score you, but to inform the governor when your nervous system is already telling the story. It is opt-in and consent-scoped, like everything else in EBS. The mode signal alone does useful work; biosignals deepen it.
Where's the source?
Open source under the Earthian Stewardship License (ESL-A) v0.1. On GitHub. Python, MCP stdio transport, works with Claude Code today.

Your nervous system sets the tempo.

Name your mode. Layer 1 is available as an MCP server.

install: claude mcp add vibe-harness -- uvx --from "git+https://github.com/m3data/vibe-harness-mcp.git" vibe-harness-mcp