The Daily Pulse — Why I Monitor My Life OS with Bash, Not AI

I tried using an LLM to summarize my daily system health.

It told me my server CPU was at 12% — an impressively precise number, considering the server had been offline for 6 hours.

It informed me that “all cron jobs completed successfully” — despite the fact that the finance pipeline email parser had been failing all week, and I knew that because I checked manually after the LLM told me everything was fine.

It produced beautiful, confident, completely wrong summaries. Every single day. And I paid API tokens for the privilege of being misinformed.

So I deleted the LLM integration, wrote a 63-line bash script, and now I have the best monitoring system I’ve ever built.

It costs zero dollars per run. It never hallucinates. And it’s completely silent unless something actually needs my attention.

The Experiment That Failed

The idea made perfect sense on paper. I was already running Prometheus and Grafana for Life OS infrastructure monitoring. The .monitor layer was producing structured reports. Why not feed those into an LLM and get a nice daily summary?

The execution went like this:

  1. Collect health data (cron status, disk usage, folder changes)
  2. Feed it to an LLM with a prompt: “Summarize today’s system health”
  3. Get back a friendly paragraph about how everything’s going

Step 3 never worked.

The LLM would:

  • Invent metrics — “CPU at 12%” when no CPU data was in the input
  • Lie by omission — Skip the cron failure because it didn’t fit the “everything’s fine” narrative the model preferred
  • Hallucinate trends — “Disk usage has been stable this week” when I’d just freed 40GB
  • Cost money — Every summary was $0.03-0.05 in tokens, and I had to run it daily because the output was never quite right

The worst part isn’t the cost. It’s the trust erosion. After the third wrong summary, I stopped reading them. The LLM had trained me to ignore my monitoring system — the exact opposite of what I needed.

The Bash Script That Fixed It

The script is called daily-pulse.sh. It’s 63 lines. Here’s what it does:

Scans every active folder → checks last-modified time →
counts how many have AGENTS.md → writes a YAML report →
outputs a short summary if anything changed

The core is dead simple:

for dir in projects/*/ areas/*/; do
  modified=$(stat -c %Y "$dir")
  age=$(( (now - modified) / 86400 ))
  if [ "$age" -le 1 ]; then
    CHANGED=$((CHANGED + 1))
  fi
done

It checks which folders have been modified in the last 24 hours. It counts how many folders have an AGENTS.md file (my proxy for “is this project properly documented”). It writes the results to a YAML-frontmatter report in .monitor/health/daily/YYYY-MM-DD.md.

And then it makes the most important decision in the whole script:

if [ "$CHANGED" -gt 0 ]; then
  echo "☀️ Daily Pulse — $TODAY"
  echo "Changed: $CHANGED folder(s)"
fi

If nothing changed, it prints nothing.

That’s the design. Silent-on-ok. The script only speaks when there’s something to say.

The Three-Layer Rhythm

The .monitor pattern runs at three cadences, each with a different purpose:

Daily: The Pulse

Runs every morning. Checks 24h activity. Silent unless something moved. If you see a “☀️ Daily Pulse” notification, it means something in your system changed — not that everything is broken, just that there’s news.

Weekly: The Staleness Scan

Runs Sunday. Checks for folders untouched for 30+ days and folders missing AGENTS.md. Produces a warning if anything’s fallen through the cracks. Silent if the system is healthy.

Monthly: The Audit

Runs the 1st. Full inventory: total folders, AGENTS.md coverage percentage, archive candidates (90+ days stale). This one always produces output — monthly is review time, not monitoring time.

Three scripts. ~170 lines total. Zero API calls. Zero hallucination risk. Zero cost.

What I Lost vs What I Gained

What I lost:

  • AI-generated prose summaries (turns out I didn’t need them)
  • The comforting feeling of an LLM telling me everything was fine (turns out that feeling was dangerous)

What I gained:

  • Deterministic reports — Same system state → same output. Every time. Testable, auditable, reliable.
  • Zero cost — Bash on cron is free. I recovered $1.50/month in API costs that were buying me bad information.
  • Zero alert fatigue — The system is silent 80% of the time. When it speaks, I listen.
  • Machine-parseable output — The YAML frontmatter means an LLM can analyze the reports later, if I want. But the monitoring itself doesn’t depend on it.

The last point is the key. By separating monitoring (deterministic, bash, silent) from analysis (optional, LLM, sampled), I get the best of both worlds. The monitoring never hallucinates. The analysis can hallucinate as much as it wants — I’ll catch it because the raw data is sitting there in YAML files, waiting to be checked.

The Grafana Dashboard

For the metric-minded, the YAML reports feed into Prometheus via a small exporter, which feeds into Grafana. The dashboard shows:

  • Daily change activity (bar chart, 30-day window)
  • AGENTS.md coverage percentage (gauge, trending)
  • Staleness by folder (table, sorted by age)

But honestly? I check the daily pulse at my terminal, not in Grafana. The dashboard is for trends. The terminal is for today.

Silent-on-Ok Is the Most Important Design Choice

Every monitoring system I’ve inherited screams at you constantly.

The monitoring system I built whispers.

When everything’s fine, it says nothing. When something changes, it sends a single line. When something’s broken, it shows up in the weekly scan. When something’s been abandoned, the monthly audit catches it.

This is the opposite of AI summarization, which produces output every single day, filling your inbox with confident noise until you stop paying attention.

The bash script never needs my attention. It just runs, checks, reports or doesn’t, and moves on.

That’s the pulse. Quiet. Reliable. Boring.

I’ll take boring over hallucinated any day of the week.

This post is part of the Life OS series. It pairs with The Observability Gap, which describes how the same pattern applies to AI agent monitoring, and Evaluation-Driven Development, which establishes the framework where deterministic checks (Layer 1) are the foundation.

*The companion sample — an open-source .monitor reference implementation with daily pulse, weekly review, and monthly audit scripts — is available as part of the Life OS Architecture sample at github.com/craigMull/spirit-machine-life-os-architecture-sample. *