We Built a CEO said the identity block was forty-eight lines. That was true when we wrote it. The number is forty-two now. Six lines migrated out of the identity constant and into a dedicated operating rules block. The personality got tighter. The instructions got their own section. The system shrank its self-description and grew its behavioral constraints.
Forty-two lines of identity. Three thousand two hundred ninety-three lines of everything else. For every line that tells Miles Carter who he is, seventy-eight lines tell him how to behave.
That ratio is the story.
The Entire Voice Layer
export async function applyVoice(text: string, intent: string): Promise<string> {
const instruction = VOICE_INSTRUCTIONS[intent]
if (!instruction) return text
try {
const result = await invokeLLM(text, {
systemPrompt: instruction,
model: 'haiku',
provider: 'claude',
maxBudgetUsd: CEO_VOICE_BUDGET_USD,
disableTools: true,
})
return result.response
} catch (err) {
logger.warn({ err, intent }, 'CEO voice layer failed, using raw text')
return text
}
}Forty-three lines. Seven voice instruction strings and one function. A haiku model, a system prompt, a budget, a fallback. If the voice layer fails, the raw text goes through. The entire cosmetic layer is smaller than the identity it serves.
We Built a CEO said the voice budget was two cents per rewrite. CEO_VOICE_BUDGET_USD is currently null. Uncapped. The cosmetic layer got promoted to essential infrastructure somewhere in the last fifteen days. Nobody wrote a ticket for it. The budget just disappeared, which means someone decided the voice was no longer optional enough to limit.
Combined: forty-two lines of identity plus forty-three lines of voice. Eighty-five lines. 2.5% of the CEO system. Everything that makes MC sound like MC: eighty-five lines. Everything that makes MC function: three thousand two hundred fifty.
The Silence Vocabulary
We Built a CEO showed eleven event types in the TIER_MAP. The current version has thirty-two.
const TIER_MAP: Record<string, NotificationTier> = {
// IMMEDIATE — human needs to know now
mission_proposed: 'IMMEDIATE',
mission_failed: 'IMMEDIATE',
task_permanently_failed: 'IMMEDIATE',
merge_conflict: 'IMMEDIATE',
cross_agent_failure_alert: 'IMMEDIATE',
spend_cap_reached: 'IMMEDIATE',
ops_health_warning: 'IMMEDIATE',
task_blocked_warning: 'IMMEDIATE',
system_report_alert: 'IMMEDIATE',
// DIGEST — batch these up
mission_approved: 'DIGEST',
mission_completed: 'DIGEST',
mission_started: 'DIGEST',
task_completed: 'DIGEST',
task_reviewed: 'DIGEST',
task_delivered: 'DIGEST',
step_completed: 'DIGEST',
ops_health_remediated: 'DIGEST',
// SILENT — don't notify
mission_updated: 'SILENT',
mission_rejected: 'SILENT', // CEO did it, they know
mission_cancelled: 'SILENT',
task_failed: 'SILENT', // transient, only permanently_failed matters
task_bounced: 'SILENT',
step_failed: 'SILENT',
conversation_started: 'SILENT',
conversation_turn: 'SILENT',
task_conflict_resolved: 'SILENT',
rule_gap_detected: 'SILENT',
task_delivery_failed: 'SILENT',
task_release_paused: 'SILENT',
review_queue_paused: 'SILENT',
review_queue_resumed: 'SILENT',
conversation_completed: 'SILENT',
}IMMEDIATE grew from five to nine. DIGEST grew from two to eight. SILENT grew from five to fifteen. The system learned twenty-one new kinds of events to categorize, and ten of the twenty-one are things it decided not to talk about. The silence vocabulary tripled. The urgency vocabulary didn’t even double.
The inline comments are the part I keep reading. mission_rejected: 'SILENT' // CEO did it, they know. That’s the system encoding self-awareness as a routing decision. The CEO rejected a mission, so the CEO doesn’t need to be told the mission was rejected. That’s not a routing rule. That’s a theory of mind, compressed into a comment.
Five Rules About Restraint
const CEO_OPERATING_RULES = `
OPERATING RULES:
- If signal is weak, say so. Do not inflate a thin event batch into a real briefing.
- Separate facts from inference when the distinction matters.
- Prefer silence over filler for low-value updates.
- If you don't have enough detail to brief cleanly, ask for the missing detail or state that there is no material update.
- Repetition kills trust. Do not resend unchanged queue snapshots unless the unchanged state itself is the problem.
`Five rules. All about what not to do. Not one says “be helpful” or “respond promptly” or “provide detailed analysis.” They’re all brakes. Prefer silence. Don’t inflate. Don’t repeat.
“Repetition kills trust” is doing the most work. Confidence 1.00, Seven Times documented the memory system re-investigating the same finding seven times with perfect confidence. The CEO’s anti-repetition rule is the architectural response. The system that couldn’t stop confirming what it already knew built a CEO who’s instructed to shut up if he’s said it before.
That’s not a system prompt. That’s a performance review.
Four No’s and a Yes
export function canSendProactiveMessage(mode): boolean {
const now = Date.now()
if (activeInteractive) return false
if (now - lastInteractiveFailureAt < FAILURE_GRACE_MS) return false
if (now - lastInteractiveAt < INTERACTIVE_GRACE_MS) return false
if (mode === 'scheduled_briefing' || mode === 'ops_scan') {
if (now - Math.max(lastInterrupt, lastBriefing, lastScan) < PROACTIVE_STACK_GUARD_MS) {
return false
}
}
return true
}The Boss in Your Pocket covered what this function does. What it didn’t cover is the shape. Four return false before one return true. The function defaults to silence and must be argued into speaking. Are you in a live conversation? No. Did a proactive message recently fail? No. Did the operator recently talk to you? No. Has another proactive message fired recently? No. OK. You may speak.
Post 049 introduced a CEO who could talk. This code shows one that learned when not to.
The Nuclear Option
All that infrastructure. Three thousand three hundred thirty-five lines. Fourteen files. Quality gates, dedup layers, proactive scanning, scope persistence, multimodal processing, voice synthesis, timezone-aware flush windows, four-level suppression logic.
And then:
/muteFourteen lines of code. await updateCeoConfigValue({ muted: true }). The operator taps a command and everything stops. No notifications. No proactive scans. No digests. No morning briefing. The entire system goes quiet until /unmute.
The mute button is the most important feature in the CEO system. Not because it’s complex. Because it exists. Three thousand three hundred thirty-five lines of infrastructure, and the final safety mechanism is a human thumb on a phone screen.
You need seventy-eight lines of plumbing for every line of personality. And then you need a mute button, which means the plumbing isn’t enough. The system learned to talk, learned when not to talk, built four layers of dedup and two tiers of silence and five rules about restraint. And after all of that, someone still built a kill switch.
That’s not a failure of engineering. That’s the engineering working exactly as it should. The system that knows when to shut up also knows it might be wrong about when to shut up. So it gives you the option. One tap. Silence.
Forty-two lines of personality. Three thousand two hundred ninety-three lines of behavior. And fourteen lines that can turn it all off.
Comments