Claude Fable Dropped. The Second Brain Is Still the Point.

Claude Fable shipped this week — essentially Claude Mythos 5.0, the model Anthropic has been teasing for months, with cyber guardrails baked in for general availability. It's twice the price of Opus at $10 per million input tokens and $50 per million output, and it's riding on subscriptions only through June 22 before it moves to usage credits.

The reaction worth studying didn't come from the benchmark threads. It came from Nate Herk — founder of AI Automation Society, ~800K subscribers on YouTube — who published a walkthrough of his AI operating system the day after the drop. The most important sentence in it is almost a throwaway: "I didn't throw it together because a new model dropped. I just spent the day seeing how Fable slots into what I already had."

That sentence is the whole game. I run my own version of this system — a persistent agent platform, a memory layer, a fleet of skills that automate my content, my monitoring, my research — and everyone I know who has gone deep on agentic systems has converged on the same architecture Nate describes. When the most powerful model ever made generally available drops, and your response is to slot it in rather than rebuild, you built the right thing.

A Default, Not an Architecture

Nate's starting point is the part most people skip past because it doesn't sound technical: an AI OS starts with a default, not an architecture.

Before this, he was doing what most of us did in 2024 — different AI tools, different subscriptions, custom GPTs, repeating himself into each one. The shift was closing all those tabs and routing everything through one harness. Do everything through it, and context, memory, and preferences accumulate where the work happens. The co-founder feeling people want from AI isn't a model capability. It's an accumulation effect, and accumulation requires a single place to accumulate.

From there he thinks in two layers: the second brain — does this thing actually know your business, your clients, your life, and can you interrogate all of it? — and the OS built on top of it — skills, automations, working out of it the way you work out of macOS. Knowledge first, action second. Most people invert this, wire automations to a system that knows nothing, and wonder why the output reads like a stranger wrote it.

The Four Cs

His framework for building and maintaining the whole thing is four Cs, taken strictly in order:

• Context — who you are, who your business is
• Connections — can the system reach live data, not just static notes
• Capabilities — the skills, agents, and pipelines you build
• Cadence — turning capabilities into things that run while you sleep

The first two are the second brain. The last two are the AI OS.

Context is a routing tree, not an encyclopedia. His CLAUDE.md is a router: it points the agent to where things live — rules, references, skills, wikis — rather than containing everything. This matches my experience exactly. The instinct is to stuff the context file with knowledge; the working pattern is to make it a map and let the agent walk the tree. His pulse check for when the architecture needs work is wonderfully unceremonious: if the agent searches five minutes for a file you know the location of, that's the signal. Could you manually drill through your folders and find it? Can the agent? We've cycled through prompt engineering and context engineering as disciplines — Nate calls architecture engineering the next one, and I think he's right. The leverage has moved from what you say to the model to how you organize what it can reach. Even with multiple large projects folded into one tree, his startup context sits around 40,000 tokens. Markdown won't be your bottleneck for a long time.

Connections separate static from live. Your background and old transcripts are static. Your team chat, your email, your P&L change hourly. His discovery heuristic: what apps do you open weekly? Think revenue, customers, calendar, comms, tasks, meetings, knowledge — where does each live? Wire those first, through APIs and CLIs by preference. The gut check for the whole layer: ask the system about your business right now — does the answer sound like a stranger or a teammate? He's honest about the tradeoff, too: it confidently told him he had 620K subscribers when he's near 800K, because static data reflects the last refresh. Live connections are what close that gap.

Capabilities are an adoption test. Before you send that email or pull that report in a browser tab, can you do it inside the OS instead? The detail worth stealing: a skill doesn't have to be a ten-step monster — a skill can just be a prompt you reuse. And no skill is ever finished. Every use generates feedback; his four-month-old image-generation skill still changes because preferences, models, and endpoints all change. I run dozens of skills under the same regime — every correction becomes an update the same day — and I can confirm it compounds.

Cadence is earned, not configured. Automation while you sleep is the last C for a reason: every automation raises cost, risk, and maintenance at once, and someone still owns it. Battle-test the skill while you're watching before you put it on a schedule. His sharpest line lives here — a prompt is never a permission layer — backed by a story about an agent emailing an unauthorized discount code to 200,000 people. Scoped keys, not instructions, decide what an agent can touch. I've written before about earned autonomy; his version, learned in production, is the same lesson with a bigger blast radius.

Folders and Files Beat Model Loyalty

Here's where it all lands, and why the Fable launch is the perfect stress test of the idea.

At the end of the day, Nate's entire system — and mine — is folders and markdown files. He keeps a .claude, a .codex, and a .agents directory side by side and runs the same brain through competing harnesses daily. The system is deliberately tool-agnostic: skills, routing logic, logs, and wikis that any coding agent can plug into.

That's what makes a model drop a non-event architecturally and a pure upgrade practically. Fable is impressive — Karpathy's framing, which matches Nate's experience, is that you can hand it far more ambitious tasks and it just gets it. It's also expensive and hungry: Nate burned through a $200/month Max plan's five-hour session in about an hour of stress testing. The answer to both facts is the same system thinking — route the expensive model to the judgment-heavy work, push parallel grunt work to cheaper models, and let the architecture absorb the change. A new engine, same car.

You're not learning Claude Code, and you're not learning Fable. You're building repeatable IP that happens to be readable by whatever model is best this quarter. That's what takes the pressure off chasing every drop — and it's why the people with months of second-brain accumulation got more out of Fable on day one than anyone starting fresh.

The model is the engine. The second brain is the asset. Build the asset.

Source: Nate Herk's full AI OS breakdown on X — the Four Cs section alone is worth the read.