March 13-25, 2026. This is your report, built from your actual local telemetry, cohort telemetry context, the daily reports from the window, your audit and psychology reports, and custom source material you provided to sharpen the read. The synthesis for this presentation copy ran locally on the founder's own machine. A fuller internal version exists. This presentation copy keeps the real observations, but blanks client names, transcript excerpts, exact implementation details, and sensitive commercial context where needed.
Three quarters of your typed output in the window landed inside Claude and Codex. That is not someone casually “using AI.” That is someone thinking, delegating, grading, and converging in public across multiple model surfaces. The personal operating system is already visible.
The drag is not idea generation. The drag is preserving evaluation criteria, protecting build mode, and converting decisions into durable artifacts without reopening the same loop in a different shell. When the standard is explicit, you move fast. When it is fuzzy, you burn time across models, tabs, and lanes.
The point here is not to flatten your work into generic productivity advice. It is to show the specific places a CEO-operator machine leaks: meetings that should create leverage but create residue, follow-ups that get delayed while the scalable version gets prettier, strategy loops that stay wider than they should, and compute that is only partly disciplined.
High-cost conversations were still too non-instrumented. When other people arrived underprepared, the CEO became the prep layer, the note-taker, and the post-call routing system by default.
When a repeated manual gap appears, the founder tends to go build the missing function immediately. That instinct is product gold at scale, but in a crowded week it can outrun the thinner bridge that would have closed the live loop first.
A bigger contract, a narrower pilot, a cleaner SMB story, a more bespoke enterprise story. The drag is not insight. The drag is narrowing when multiple stories still feel viable.
Demos, recruiting, partner motion, investor follow-ups, and operator commitments were competing inside the same memory slot. Intent stayed high. Same-day retrieval and closure got more fragile than they should.
You already have a real control plane plus worker plane. The remaining leak is asking the local machine to hold heavy worker jobs, context, and CEO judgment at the same time.
By observed app time, the system is basically Claude, Chrome, and Codex. Chrome matters because it hosts both leverage and drag: Slack, Meet, Google surfaces, GitHub, websites, and random admin gravity.
Inside Chrome: 10.3h Slack, 10.2h Google Meet, 6.7h Google surfaces, 1.8h GitHub, 1.55h larry.moran.bot.
Chrome is not “wasted time.” It is where too many different jobs are sharing the same window.
Your keyboard pattern backs the older read almost perfectly: morning is not the main event. Evening and late night carried about 76% of all typed output in the window.
The pattern is obvious. March 19, 21, 22, and 23 were build-heavy runs. March 18 got swallowed by meetings. March 24 and 25 show the admin leak vividly.
The older EOD lane made this much clearer than the early draft here: voice carried founder intent, telemetry carried behavior, and the shared brain plus memory layer existed so every model did not start from zero.
The clean operating pattern is local machine for control and context, AWS for worker fan-out and heavy runs. The reports are explicit that the Mini was getting under-leveraged as a control plane and over-leveraged as a local worker box until the AWS-first correction landed.
The strongest sleep insight is not generic “sleep matters.” It is that Oura helps separate human work from overnight agent/background activity, and REM trend looks like an early warning light for cognitive fragmentation.
This is not a finished statistical model. It is the clearest public-safe read from the daily reports: body-state changes what kind of work compounds, and Oura keeps the story honest about what was human work versus agent/background activity.
The useful read is not “sleep score equals productivity.” It is “body-state changes whether widening compounds or backfires.”
One of the strongest EOD lessons was that app telemetry alone can misclassify the work. The voice layer showed what the machine was actually for: architecture framing, GTM narrowing, delegation, correction, and founder intent routing.
The point was not “save notes somewhere.” The point was to make decisions, transcripts, rubrics, and operating context reusable across Claude, Codex, OpenWork, and future agents without briefing every model from scratch.
These are public-safe visuals based on the real operating pattern. The internal version has named transcript excerpts and raw surfaces. This version keeps the machine legible without leaking the internals.
Superwhisper and meetings capture the live brief before it disappears into chat residue.
Decision, promise, delegation, or brainstorm gets tagged instead of left as raw text.
The intent packet lands in the brain plus memory layer so the next shell can retrieve it immediately.
The right model, queue, or worker gets the context once instead of the founder pasting it five times.
Draft, issue, review object, or send path is created and written back so the loop stays visible.
The real internal version shows the actual transcript excerpt, queue surface, and downstream send object.
This is the anti-rebriefing layer. The point is that the next model session should already know what matters.
This matters because your strongest pattern is leverage through orchestration, not solo typing. The report would be lying if it acted like only direct keyboard output counts as real work.
This was not one lane. Multiple existing deliverables were cleaned, redacted, and made safe enough to reuse as product evidence without leaking customer internals.
The offer, briefing material, and outbound framing got sharpened into something an assigned sender could actually help move. The work moved from “what is this?” toward “here is the pilot, here is the value, here is how we explain it.”
Hundreds of Zoom transcripts were processed for pain points, objections, buying signals, and fit. A hosted review/send surface plus direct-draft workflow let those outputs queue for a review owner instead of dying in notes or chat.
A documented 7-stage enrichment pipeline on aws-mini produced 988 outreach-ready contacts and staged HubSpot test deals. This is not theory. It is remote worker leverage.
The system absorbed a production outage affecting 200+ workers, patched the stack, upgraded the VM, added healthchecks, and turned a painful incident into concrete reliability lessons.
A repeatable lane got formalized: transcribed call to structured pain summary to draft to review/send to pending reply. That matters because the CEO promise stack can no longer live only in memory.
Historical and new Superwhisper transcripts were shipped, ingested, and made queryable as working artifacts. The point was not archiving for nostalgia. It was making founder intent reusable across models.
Decisions, rituals, project state, and transcript-derived context moved into a shared brain with a retrieval layer. That changed memory from “hope the chat still has it” into explicit cross-session infrastructure.
Table cleanup, spec-writing, and clearer role-shaped installs turned rough internal material into collateral that can actually carry the product story without flattening it.
This is the local trail for the people who want to click through the diagrams, architecture changes, and operating-model decisions that moved during the audit window. The important framing here is that these were documented in parallel as decisions, diagrams, and git movement during the period, not retro-written just to make this report look smarter.
/Users/scottmoran/brain/reports tree and the receipts below should open locally.
The HTML pages will render normally. The markdown docs will open as source-like reference pages, but they are still clickable.
The intended operating model for Moe, with telemetry, memory, Oura, session rituals, and the current brain-system flow.
The companion runtime diagram that makes the local-vs-cloud capacity story and the synthesis/data pipeline more explicit.
The maintained architecture reference for the current GitHub-native operating model and the shared-brain substrate.
The running decision layer behind terminology shifts, coordination rules, telemetry posture, and model/agent operating doctrine.
The report where the architecture and current-state diagrams were surfaced as the day’s biggest output.
The report that ties strong sleep, architecture decisions, compute-topology changes, and transcript-pipeline hardening together.
The report that made the “telemetry without context lies” thesis explicit and pushed transcript-to-memory, transcript-to-outreach, and meeting-compression installs.
The sharper closure-debt and obligation-load read, grounded in telemetry plus a heavy Superwhisper voice corpus.
The report that treats voice as cognitive telemetry and shows why transcript saturation changes the founder read.
These are not fake placeholders. They represent actual sections in the fuller report that were cut back because they expose client identity, account context, internal prompts, implementation logic, or commercially sensitive detail that should not sit on a public page.
Named account detail, meeting excerpts, decision context, and account-specific operator notes removed.
Internal automation prompts, service-offering routing logic, and product-specific implementation steps removed.
Comparative deliverable sections, outbound strategy detail, and transcript-derived GTM specifics removed.
These are the short-run recipes that turn your best patterns into defaults and stop the worst ones from disguising themselves as strategy. They are meant to be stolen, installed, and tested quickly.
These are the rules I would actually enforce because they shut down the repeat failure modes without flattening how you think. The first three are body-state gates. The rest are business-state gates.
Good readiness and stable sleep mean the machine can support doctrine work, sharper decisions, deeper build blocks, and harder narrowing.
If the body is middling, do not spend the day inventing new strategic branches. Use the day for review, dispatch, cleanup, and lighter-weight closure.
If REM and readiness are clearly off, the day becomes a close, grade, review/send, and prep day. No widening, no elegant new infrastructure lane, no fake heroics.
If required inputs are missing by T-30, downgrade async or reschedule. The CEO should not be the silent buffer for everyone else’s prep debt.
If a call generated a real promise, that promise enters review/send and pending replies before the day ends, even if the reusable system is still getting better.
Scrapes, browser farms, enrichments, and bulk transforms go to AWS by default once they stop being tiny. Keep the local box for taste, routing, and live control.
These are the public-safe versions of what the internal report points toward. They are specific enough to feel real and generic enough to avoid leaking the best internals.
Transcript or meeting note becomes promise, owner, due date, draft, and reminder. Nothing important dies in memory or in chat residue.
Delayed replies after good calls, especially when platform work feels more urgent than sending.
Auto-brief strategic calls, collect agenda items, chase missing prep, and cancel or reschedule when the inputs never arrive.
CEO time turning into meeting prep subsidy for the rest of the room.
Pain points, objections, next steps, and fit get extracted automatically. Strong calls queue follow-up drafts for operator or review-owner approval.
Good sales or partner conversations vanishing into transcript folders.
The local machine stays the control plane; AWS handles the long-running workers, scrapes, and browser tasks without requiring manual babysitting.
Local RAM starvation, context loss, and noisy confusion about what belongs where.
Whisper/Superwhisper and meeting transcripts become one classified context stream that feeds the shared brain, the right model, and the right queue without repeated manual re-briefing.
Human API-router behavior, context shuttle tax, and the same founder brief being pasted into every model by hand.
When you reject or prefer an output, the reasoning becomes a reusable brief, exemplar, or scoring rule instead of disappearing into one conversation.
Compare-edit churn across shells and repeated re-explanation of taste.
Operator, sales, support, and lead-gen each get their own review queue, approval layer, and recommended playbooks instead of one vague “assistant.”
Selling abstraction when the buyer actually wants relief from a repeated loop.
The point of a report like this is not just diagnosis. It is to convert observation into a tighter operating system for the person and a more repeatable product surface for the company.
A plain-language trigger is useful, but it undersells the real system. The real install surface is: a skill that tells the agent what to do, the MCPs that give it access, a sentry or daemon that watches for drift, and a small script/spec that makes the whole thing feel real.
meeting-controlTurns live meetings into a controlled loop: pre-read, agenda chase, post-call decisions, and follow-up routing.
meeting-controlmeeting-readiness-sentry watches for missing agenda, missing pre-read, and missing post-call decisions{
"skill": "meeting-control",
"trigger": "calendar.event.upcoming",
"required_mcps": ["calendar", "transcripts", "memory", "tasks"],
"sentry": "meeting-readiness-sentry",
"rules": {
"t_minus_24h": "request agenda and required inputs",
"t_minus_30m": "escalate if materials missing",
"t_minus_10m": "draft reschedule if still unprepared",
"post_meeting": "extract decisions, owners, deadlines, resume brief"
}
}
post-call-followupConverts demo or discovery transcripts into a real review/send queue instead of leaving the promise stack in memory.
post-call-followuppromise-lag-sentry flags calls with explicit promises that still have no draft or send action by end of day{
"skill": "post-call-followup",
"trigger": "transcript.created",
"required_mcps": ["transcripts", "crm", "gmail", "review_queue", "memory"],
"sentry": "promise-lag-sentry",
"extract": ["pain_points", "objections", "buying_signals", "next_steps", "explicit_promises"],
"actions": [
"score fit and urgency",
"draft follow-up",
"queue for review",
"update deal record",
"alert if no send path exists by end of day"
]
}
incident-hotfix-watchdog.pyIf a code-based problem needs a quick fix, this is the kind of sentry that should already be running: unresolved errors, healthcheck status, and issue creation in one loop.
incident-hotfixincident-hotfix-sentry watches error spikes, failed healthchecks, and missing owner assignment#!/usr/bin/env python3
import os, requests, subprocess, sys
SENTRY_ORG = os.environ["SENTRY_ORG"]
SENTRY_PROJECT = os.environ["SENTRY_PROJECT"]
SENTRY_TOKEN = os.environ["SENTRY_TOKEN"]
HEALTHCHECK_URL = os.environ["HEALTHCHECK_URL"]
GITHUB_REPO = os.environ["GITHUB_REPO"]
headers = {"Authorization": f"Bearer {SENTRY_TOKEN}"}
sentry_url = (
f"https://sentry.io/api/0/projects/{SENTRY_ORG}/{SENTRY_PROJECT}/issues/"
"?is=unresolved&sort=date&statsPeriod=1h"
)
health_ok = requests.get(HEALTHCHECK_URL, timeout=10).ok
issues = requests.get(sentry_url, headers=headers, timeout=15).json()
hot = [i for i in issues if i.get("count") and int(i["count"]) > 10]
if (not health_ok) or hot:
title = "Hotfix watch: healthcheck failed or Sentry spike detected"
body = f"health_ok={health_ok}\\nopen_hot_issues={len(hot)}"
subprocess.run(
["gh", "issue", "create", "--repo", GITHUB_REPO, "--title", title, "--body", body],
check=False,
)
print(body)
else:
print("hotfix watch clear")
founder-intent-routerTurns Superwhisper and meeting transcripts into classified, searchable context so founder intent survives across models and sessions.
founder-intent-routercontext-drift-sentry flags repeated manual re-explanations of the same context or missing transcript syncs{
"skill": "founder-intent-router",
"trigger": "transcript.created",
"required_mcps": ["superwhisper", "memory", "vector_memory", "decisions"],
"sentry": "context-drift-sentry",
"classify": ["decision", "question", "brainstorm", "delegation", "status_update"],
"actions": [
"write founder-intent brief",
"store searchable summary in brain",
"embed into Pinecone or vector layer",
"link to active project or decision log",
"surface relevant context on next model session"
]
}
support-approval-kernelThis is the install behind the “copy-paste grinder” role: cluster repeat requests, draft replies, approve fast, and catch policy drift.
support-approval-kernelpolicy-drift-sentry flags answers that fall outside accepted templates or performance thresholds{
"skill": "support-approval-kernel",
"trigger": "ticket.message.created",
"required_mcps": ["helpdesk", "knowledge_base", "review_queue", "metrics"],
"sentry": "policy-drift-sentry",
"loop": [
"cluster repeated issues",
"draft response from approved sources",
"approve/edit/skip in one surface",
"promote accepted replies into templates"
]
}
This is the operator-friendly layer a buyer can immediately understand. The section above shows the actual install surface. This section shows the plain-English version of how those installs would behave day to day.
Useful when people keep showing up without agenda items and you end up carrying the prep burden.
Before every scheduled meeting, remind agenda owners 24h before and 30m before start. If required inputs are still missing 10 minutes before the call, draft a reschedule note and suggest moving the meeting. After the meeting, extract decisions, owners, and follow-ups and route them into the right repo, issue, or CRM record.
Useful when Chrome keeps swallowing the first serious block of the day before build momentum lands.
When I say "start build mode," open Claude, Codex, Terminal, and the active repo. Mute Slack notifications for 90 minutes. Block Google Meet, app.slack.com, search, and webmaster surfaces until the block ends. At the end of the block, ask me for one durable brief or shipped artifact.
Useful when demo calls or discovery calls create real insight, but follow-up, prioritization, and CRM hygiene lag behind.
When a discovery or demo transcript lands, extract pains, objections, buying signals, next steps, and stakeholders. Score whether the call actually showed urgent pain and clear fit for our service offering. If yes, draft the follow-up in the assigned sender's voice, queue it in the review surface, and update the deal record. If no, mark it low-priority and keep the transcript searchable for later pattern mining.
Useful when the machine keeps trying to widen strategy on a day your body is clearly asking for narrower work.
When today's Oura readiness is low or REM has been falling for 2+ nights, mark the day as a narrow day. Do not open new GTM, product, or infrastructure lanes. Prioritize closure, review/send, meeting prep, and grading existing work instead. If I try to widen anyway, remind me this is a low-REM day and ask what outward loop gets closed first.
Useful when good calls turn into “I owe them something real” and then get outrun by system-building.
After every demo, discovery call, or investor call, extract every explicit promise I made. Create one tracked item per promise with owner, due date, source transcript, and suggested next step. If no draft or send action exists by end of day, queue a follow-up draft automatically and remind me before I start a new build lane.
Useful for the kind of role that spends hours copying comments or questions into AI and then manually approving the result.
If a support agent pastes the same kind of issue into AI over and over, log the repeated prompts, cluster the common request types, and generate a reply draft with an approval UI. Approve, edit, or skip with one click. Turn accepted replies into reusable templates over time.
Useful when the local machine is trying to be both the control plane and the worker box.
Use local machine for control and context only. Push scrape, enrich, verify, browser automation, and bulk transformation work to AWS workers. Return staged CSVs, CRM-ready rows, and a short operator brief when the run finishes.
Useful when your strategy lives in voice notes but the working shell only sees the last prompt you typed.
When Claude Code or Terminal opens, inject the last three voice notes plus today's top open loops from the shared brain and vector memory as hidden context. Summarize the strategic intent in 5 bullets before taking the next action. Write any new decisions back to the brain so the next model session does not need the same re-brief. If the new task conflicts with the last voiced priority, ask for confirmation first.
A fuller internal version would show names, screenshots, transcript excerpts, and implementation notes. This copy keeps the diagnosis and the intervention, and blanks the sensitive parts.
The demos were not the bottleneck. The real pattern was seeing a manual follow-up gap and immediately wanting to solve the underlying scale function instead of tolerating the thinner bridge that would have closed the live promise first.
Promise tracker plus transcript-to-review/send with an end-of-day escalation and an explicit “thin bridge before full machine” rule.
The time cost was real, but the bigger drag was missing pre-read, agenda capture, and post-call routing. That made the founder the fallback memory layer for expensive conversations.
Meeting brief generator, agenda enforcement, cancellation logic, and post-call compression with decision routing.
The ring data was most useful when it stopped being wellness garnish and started acting like a scope gate. Good days supported doctrine and widening. Fragmented days should have been used for closure and routing.
Green / yellow / red operating gate that changes what kinds of work are allowed before the day gets wider.
What we saw. 56.6 hours in Claude, 28.0 in Codex, 2,805 AI handoffs, and roughly three quarters of all typed output landing in Claude and Codex. You are not using models as toys. You are using them as thinking surfaces, delegation surfaces, and comparison surfaces.
Why it matters. This is a strength. It is also why orchestration can feel productive even when the real bottleneck is choosing and committing. The system should optimize for routing, convergence, and durable artifacts, not a fake “single maker” ideal.
What we saw. The best days in the window are the build-heavy ones: March 19, 21, 22, and 23. The uglier days are not low-effort days; they are mixed-mode days where Slack, search, meetings, websites, and build all share the same surface.
Why it matters. Open-ended mixed-mode days are not neutral for you. They are hostile. The right unit of analysis is not total hours. It is whether the day stayed true to its intended mode.
What we saw. The strongest read across the prior reports still holds: once you know what “good” looks like, you can use AI extremely well. When the criteria are fuzzy, time gets burned across multiple models, tabs, and drafts.
Why it matters. You are not bottlenecked by idea generation. You are bottlenecked by defining and preserving evaluation criteria. That is why rubric capture and reuse deserves to be a first-class layer in your system.
What we saw. The psych profile was right: you can bounce out, collect signal, and snap back quickly. That resilience is real. But it also means you can underestimate how much mode churn is happening because the re-entry path feels cheap.
Why it matters. Recovering fast is not the same as switching for free. This is why days can feel productive and still leave you with less actual closure than they should.
What we saw. The diagnostic report framed this cleanly: ideas, prompts, structures, pages, and lanes come easily; choosing the few closures that permanently kill other options is what costs psychic energy. When pressure rises, the risk is not collapse. It is more artifacts and more side quests.
Why it matters. This is not laziness. It is a pressure-to-motion converter. Stress becomes throughput, and throughput can camouflage unresolved commitments.
What we saw. The sharp frustration pattern in the reports is consistent: wrong dates, memory drift, fake completion, or tools acting more capable than they are. When context trust breaks, you reopen manual control loops yourself.
Why it matters. For you, broken memory is not a minor UX annoyance. It is an adoption blocker. Any automation that cannot preserve context fidelity will get demoted no matter how flashy it looks.
What we saw. One of the harder truths from the deeper reports is that building systems can become emotionally safer than sending the follow-up, forcing the decision, or narrowing to one GTM story.
Why it matters. This is where more infrastructure can quietly become elegant deferral. The fix is not “stop building systems.” The fix is to pair new system work with mandatory external closure.
What we saw. Meetings already occupy real time in the window, and the meeting-content gap in the reports suggests you are losing leverage twice: once in the call, then again because decisions and prep context are not being carried cleanly.
Why it matters. A CEO probably should be on more decisive calls, not fewer. The fix is to make the calendar enforce agenda quality, pre-reads, and post-call capture so meetings become leverage instead of residue.
What we saw. When a manual gap appears, you tend to spot the underlying missing function quickly and go build toward the scalable version: transcript mining, review/send, routing, better structure, better installs. That is not the product failing. That is you refusing to keep paying the same manual tax.
Why it matters. This is one of the cleanest CEO-specific tensions in the set. You do not need less machinery. You need a rule that says some weeks deserve the thin bridge, small script, or tolerated manual path first, and the deeper machine second.
You keep turning messy operational threads into durable system language. The product gets sharper because you keep pushing toward the actual abstraction instead of accepting the first comfortable framing.
Your insistence that useful work end up as repos, reports, implementation notes, or real pages is a real operating advantage. It is why the system now produces handoff-quality output instead of smart chat residue.
The strongest work in this window was not solo typing. It was you causing whole lanes to move in parallel without losing the thread entirely. That is the conductor pattern at its best.
The operator instinct here is rare: use the internal system hard enough that the gaps become the roadmap. That pattern is already producing product direction, not just self-knowledge.
founder-intent-router first, promise-tracker second, and meeting-control third.
That stack attacks the context-resend tax, the follow-up leak, and the meeting-prep subsidy before anything more elegant gets built.
This is the part that should make it obvious the presentation copy is cut down, not invented. The real version contains named excerpts, screenshots, and customer-context slices that are intentionally removed here.