I’m about to betray every leader I’ve spent fifteen hours being friendly with in my current Civilization VII campaign, and the only thing I’m feeling about it is mild strategic satisfaction. Which is, when you stop and look at it, the single most useful thing this game teaches you.

It’s a game. But the lesson it delivers about how power actually works is something most people never get from reading the news. The news gives you the speeches, the justifications, the moral framing. The game gives you the spreadsheet underneath... and you realize the spreadsheet was always doing the driving.

Right now I’m eyeing up pieces of land that don’t belong to me, keeping every leader on the board reconciled and chatty, building my military in the background, and waiting for the right moment to strike. I’ll take what I want when I’m ready. They won’t see it coming because they can’t, I’ve been too agreeable for them to read the shift.

The code you’re running was written by someone else

I started as Caesar of Rome. Over the course of the campaign I evolved into the American Empire, democratic by design, multicultural by definition. We rose out of Europe, took the whole continent, and then looked outward.

That arc matters and it goes deeper than “founding fathers quoting Cicero.” The specific inheritance worth paying attention to is the civic virtue problem. Rome’s Republic collapsed because the thing actually holding it together was a shared belief that public service mattered more than private gain, and the institutions only worked as long as that belief held. When luxury, spectacle, and personal ambition replaced civic duty, no amount of institutional scaffolding could save the Republic. It became an empire because the citizens had already stopped behaving like citizens.

America’s founders read this history and tried to build institutions that could survive human nature being exactly what it is. They partly succeeded. But the Republic-to-Empire drift is the same pressure now, just on a longer clock. Rome ran out of money to fund the wars its Senate kept authorizing, so it debased the denarius, clipping the silver content down decade after decade until the currency was nearly worthless. The US is running the slower version of that through deficits and monetary expansion, eroding the dollar’s purchasing power rather than admitting to voters that the math doesn’t work. Different mechanism, same civilizational admission... that a state which can’t pay for what it wants starts quietly charging the cost to the people who trusted the currency.

Civ makes you feel this continuity because you’re playing it forward yourself. You start lean and civic-minded because you have to, then you get rich, then you get decadent, then the rules start bending to whoever has the most stuff. Every major civilization is running code written by the ones that came before. The language changes. The logic doesn’t.

Diplomacy runs on reciprocity, until it doesn’t

Across every campaign I’ve played, the pattern holds. The leaders who were agreeable, I never attacked, and they never attacked me. The ones who were less agreeable would eventually come at me, and I’d respond with the sword.

That’s close to how international relations actually work. Robert Axelrod ran tournament simulations decades ago and found that tit-for-tat, cooperate by default, retaliate when attacked, forgive when the other side comes back, beats almost everything else in iterated games. The agreeable leaders in Civ are basically running that strategy without knowing it.

The real world does run on this logic, but it’s messier than the model suggests. The US and Canada get along because there’s a stable equilibrium that benefits both sides and neither has an incentive to break it. Shared values are a story layered on top of the incentives to make the equilibrium feel like a friendship. But it would be sloppy to say reciprocity explains everything, because international relations aren’t clean iterated games with symmetric payoffs. Geographic reality matters. Military asymmetry matters. Economic integration creates dependencies that change the calculus in ways a simple tit-for-tat model can’t capture. Canada and the US aren’t cooperating because they ran the math on defection costs, they’re cooperating because the geography, the trade flows, and the power differential make defection basically unthinkable for one side and pointless for the other.

Civ actually shows you this too, if you’re paying attention. The AI leaders who cooperate with you aren’t doing it because your diplomacy score is high. They’re doing it because you’re strong enough that attacking you would be stupid. The cooperation is downstream of the power, not upstream of it.

The command chair changes whoever sits in it

This is the part of the game that sits with me the most, and it’s the part I think about when I read about real wars.

When you’re playing, you’re not thinking about individual units, you’re thinking about the civilization. You weigh the risks, you calculate the return, you send the order. There’s no emotional attachment to the soldiers because they’re abstracted into production numbers and movement points. You click the attack button and the numbers go down. You don’t hear anything.

The uncomfortable thing Civ makes you understand is that this abstraction is how governance works at scale. You cannot run a civilization while feeling every soldier’s death. The math of running anything larger than a tribe requires treating people as variables. A general who feels every loss can’t deploy anyone. A president who internalizes every casualty can’t make decisions. The detachment is the role producing the person, the chair reshapes whoever sits in it, and the math doesn’t get done unless that reshaping happens.

Which leads to a paradox that mostly doesn’t get named. The people most capable of carrying moral weight are usually the people least capable of making the decisions that need moral weight carried. The command chair selects for people who can do the math without feeling it. If it didn’t, the civilization would be paralyzed.

Civ puts you in that chair for fifteen hours at a time and you don’t even notice the switch happening. You just click the button.

Now, the game is also flattering you here, and it’s worth being honest about that. Civ gives you perfect information, rational actors, clean feedback loops. Real statecraft is messier. You’re making decisions with bad intelligence, political pressures the game doesn’t model, institutional inertia, domestic constituencies pulling in six directions at once. The game teaches you the logic of the command chair, but it underestimates the fog. Still, the core insight holds... the seat changes the person, and pretending otherwise is how you get blindsided by what leaders actually do once they’re in it.

Nukes are the only currency that doesn’t inflate

Once I had nukes, the whole game changed. I’d drop one, and whichever civ was on the receiving end would summit. The rest of the board hated me for it, but hate is a soft currency and nukes are hard currency.

Thomas Schelling wrote about this in Arms and Influence, and the distinction he drew matters. Deterrence is defensive, you convince someone not to attack you because the retaliation would be unacceptable. Compellence is offensive, you use the threat to force someone to change their behavior, do something they wouldn’t otherwise do. Both rely on the bomb existing, but they work differently and they fail differently. Deterrence is relatively stable because both sides benefit from not acting. Compellence is inherently unstable because you’re actively demanding change, and the other side has to decide whether you’re bluffing.

North Korea figured out the deterrence half. They got nukes and the whole calculus shifted, nobody’s invading them, and they know it. That’s why they’ll never give them up. But their ability to compel is limited, they can stop an invasion but they can’t force South Korea to do much of anything, because the credibility of actually using the weapon offensively is low. The bomb protects them, it doesn’t project them.

The moral indignation everyone else feels about nuclear weapons is real, but it doesn’t translate into action because action has a cost, and the cost of confronting a nuclear power is unacceptable. Civ models this pretty cleanly. You lose diplomatic favor with everyone, and it doesn’t actually matter. The game is just being straightforward about something most commentary won’t say out loud.

Peace is just the part where you’re getting ready

In my current campaign I’ve colonized all of South America and the Pacific, and I want global domination. Other nuclear powers are developing their arsenals and I suspect I might get nuked eventually, so I’m building up militarily, eyeing the land I want, and planning the war during what looks like peacetime.

All the other leaders think we’re cool. I’m keeping them reconciled, running the diplomacy game, being agreeable. When I’m ready I’ll strike.

This is what major powers do, and Russia’s Minsk agreements are one of the clearest recent examples. Signed in 2014 and 2015, they froze the conflict in Donbas on terms that gave Moscow time. How much of what followed was planned from the start is genuinely debated, there’s a reasonable case that the 2022 invasion was a decision that crystallized much later rather than a plan set in motion in 2014. But regardless of when the decision was made, the ceasefire created the conditions that made the decision possible. Seven years of military rebuilding, economic repositioning, force staging. Whether that was always the intent or just what the opportunity shaped into, the practical outcome was the same... the peace was the preparation.

The agreeable face is the strategy itself. Looking peaceful is a load-bearing part of preparing for war. Every major power understands this. The ones who don’t understand it get eaten by the ones who do.

Your phone is a piece on the board

The chip in your phone was probably made by TSMC, in Taiwan. TSMC exists in a political-military equilibrium between the United States and China that could break in any direction. The US has built its entire semiconductor strategy around keeping Taiwan functional and aligned. China has built its military modernization around eventually having the option to change that. Taiwan itself has built its survival strategy around being economically indispensable to both sides, the “silicon shield,” where invading or strangling Taiwan costs more than tolerating it.

That equilibrium is what makes your phone possible at the price you paid for it, concretely. The fabs that made your chip, the ships that moved it, the design IP that enabled it, all of that rides on a set of tit-for-tat incentives between three major players. When any of those incentives shift, your phone gets more expensive, or harder to buy, or quietly downgraded to a chip made somewhere less precarious.

The same structure sits under your mortgage rate, your energy bill, your pension’s equity exposure, the price of your groceries, whether your kids can get a job in the industry you trained them for. You’re not outside the game. You’re embedded in its outcomes whether you follow it or not.

Once you see the mechanics, you read the next move before everyone else does. You recognize the capability buildup that precedes aggression. You understand that alliances are equilibria that break when the incentives move. The word “betrayal” is just a story applied afterward by whichever side lost the equilibrium. You stop being surprised by the news because you already saw the shape of it in the last five moves.

The players moving the pieces are thinking about their civilization, their position, their calculus. You don’t enter the equation. Your job is to understand the game well enough to position yourself around their moves. You don’t get to be a player, but you can stop being a pawn.

What you lose when you see clearly

Once you start seeing geopolitics this way, you lose something. You lose the ability to feel clean outrage. You stop being able to watch a conflict and think “the good guys need to win” because you can see that both sides are doing what their position requires. You read about a war crime and your first thought is “what did that accomplish strategically” before it’s “that’s horrific.” The moral theatre stops working on you.

I notice this happening to me. I’ll read a headline out of Gaza or Ukraine and the first move my brain makes is mapping the positioning, not registering the suffering. I’m not proud of that reflex. Pretending I don’t have it would be worse tho, because then I’d be lying to myself about how my own head has been reshaped by the way I’ve learned to think.

That’s partly a gain. You make better decisions, you’re harder to manipulate, you don’t get swept up in narratives designed to extract your attention and your political behavior. You see the board.

It’s also a loss. Moral feeling is the mechanism by which pressure gets applied to the system from below. If everyone who understands power loses the capacity for outrage, the system has no counter-weight. The clearest analysts are, almost by selection, the least able to push things in a better direction. The same paradox as the command chair, just flipped... clarity and moral feeling pull against each other, and the system actually needs both, but rarely in the same person.

Civ doesn’t resolve this. It just puts you in the seat where you can feel the tradeoff. You spend fifteen hours optimizing an empire and you come away understanding why empires do what they do, and also slightly less able to be scandalized by them. I don’t think that’s fully good. I think it’s closer to necessary. You can’t act inside a system you refuse to understand, and the cost of understanding this one is real. So is the alternative, which is being acted upon by forces you’ve chosen not to see.

The game doesn’t teach you geopolitics. It just stops hiding it from you. Most analysis frames every conflict as a moral drama because moral drama sells attention. The game doesn’t need to sell you anything, it just shows you the board and lets you find out what you do when you’re the one with the pieces.

Play a few campaigns with that lens on. The next news cycle will look different, and so will the one after that, and eventually you’ll catch yourself reading a headline and thinking about resources and positioning before you think about heroes and villains.

That’s the moment the game finished teaching you.

There’s a specific failure mode I keep watching, and I bet you’ve watched it too.

You’re working with Claude Code, or Cursor, or Windsurf, on a real codebase, and the agent makes the same mistake it made last week. Not a similar mistake. The same one. The same wrong import, the same misread of your error-wrapping convention, the same naive retry on a non-transient 401. You correct it again. You explain again. You move on, because the work has to ship, and you tell yourself the next session will be different.

It won’t be. Because your agent has no memory, and the memory tool you bolted on isn’t doing what you think it’s doing.

That’s the problem I built Mnemos to solve. Not “an agent memory layer,” because the field already has those, and most of them are silently broken in a way that took me longer to diagnose than I’d like to admit.

The pull assumption that nobody questions

Every memory tool I’ve evaluated, including the ones with tens of thousands of GitHub stars, ships with the same architectural assumption: the LLM will call your memory tool when it needs a memory.

It won’t.

It really, really won’t. Not reliably, not at the right moment, not with the right query. Frontier models are getting better at tool use, but “remember to consult your long-term memory before answering” is exactly the kind of housekeeping prompt that loses the fight against any concrete user instruction sitting next to it in context. The agent is focused on the task. Your memory tool is a peripheral. Peripherals get skipped.

This is a pull-based design. The memory layer sits there politely, exposes a search endpoint, and waits for the agent to ask. Mem0 does this. Zep does this. The thirty other startup memory layers all do this. Then they ship benchmarks where retrieval works great because the harness explicitly calls retrieval, and call it a day.

But the production failure mode isn’t “retrieval returns the wrong document.” The production failure mode is “retrieval was never invoked.” You can’t measure that on LongMemEval. You can only measure it by sitting at your terminal and watching your coding agent re-litigate decisions you’ve already made.

The inversion

Mnemos starts from the opposite assumption: the agent will not call your memory tool, so you have to push memory at the one moment the agent is guaranteed to look.

That moment is session start.

When an agent calls mnemos_session_start(project="my-repo", goal="fix the login bug"), it does not get back a session ID. It gets back a pre-warmed context block, around 500 tokens, composed from five sources:

1. Conventions you’ve declared for this project (”we use fmt.Errorf with %w, here’s why”)

2. Summaries of your three most recent sessions on this project

3. The top three skills (procedural memory) matching the goal

4. Corrections from the journal whose trigger context matches the goal

5. The hot-file list, sorted by how often the agent has touched files on this project

That block is composed before the agent does anything. The agent doesn’t have to be smart enough to ask. The agent doesn’t have to remember to ask. The agent reads the prewarm because it’s already in context, and from that moment the project’s institutional memory is loaded.

This is not a small change. This is the entire ballgame.

Memory of mistakes is more valuable than memory of successes

The second insight is one I had to live through to believe.

Most memory layers store the conversation, then trust retrieval to surface the right slice when needed. Some get fancy and extract “facts” or “preferences” and store those instead. None of them, to my knowledge, treat failure as a first-class object.

In Mnemos, when the agent screws up and you correct it, the agent is supposed to call mnemos_correct with four required fields:

• tried: what was attempted

• wrong_because: why that was wrong

• fix: what worked

• trigger_context: the situation that made it relevant

That’s it. Four fields, mandatory schema, stored as a typed correction observation with a retrieval-weight bonus. Next session on the same project, when the agent calls mnemos_session_start with a goal that matches, the correction surfaces in the prewarm, before the agent has a chance to make the same mistake again.

The failure modes of an LLM are far more compressible than its successes. Successes are diverse and contextual. Mistakes cluster. Most agent screw-ups on a given codebase fall into a handful of recurring categories: misreading a convention, missing a constraint, misunderstanding the data model, applying a pattern from another stack. If you record those failures with structure instead of dumping the whole transcript, you don’t need a vector database to retrieve them well. You need exactly enough metadata to match a goal to a previous mistake.

This compounds across weeks in a way that ordinary memory does not. Each correction takes maybe ten seconds for the agent to record, and saves an unknown but substantial amount of future debugging.

Compaction recovery, or: the moment everyone else fails

Here’s a primitive I haven’t seen in any other memory tool, and I’d love to be told I’m wrong about that.

Modern coding agents compact their context. Claude Code does it, Cursor does it, every long-running agent loop does it eventually, because context windows are finite and conversations are not. Compaction is essentially a summarization pass: the agent replaces a large block of prior conversation with a compressed version, frees up tokens, keeps going.

The problem is that compaction is lossy. The agent post-compaction often does not know what it was working on five minutes ago, what it had decided, what it had ruled out, or what the user wanted. You’ve watched this happen. The agent suddenly asks you a question whose answer is the entire prior twenty minutes of work.

Mnemos has a dedicated API for this exact moment: call mnemos_context with mode: "recovery", pass the session ID and goal, and you get back the current session’s goal, the in-session observations, the conventions, and a reconstructed picture of what the agent was doing. It’s the “oh god, context just got compacted” button. Drop it into your agent’s recovery hook (Claude Code has a hook for this) and compaction stops being a story-killing event.

I have not found this in Mem0, in Zep, in MemPalace, or in any of the other memory layers I’ve reviewed. If it’s in there and I missed it, please file an issue.

Memory stores are an injection vector and we should treat them like one

When you give an LLM persistent memory, you’ve given an attacker (or just a careless teammate) a way to write content that will be silently injected into future LLM contexts on a different machine, possibly belonging to a different user, with no review step in between.

This is a new attack surface and the field is largely ignoring it.

Mnemos runs every prewarm and recovery block through a safety.Scanner at the injection boundary. The scanner looks for instruction-override phrases, role-spoofing patterns, fake tool syntax, zero-width unicode, and bidi overrides. High-risk content gets wrapped in a visible [MNEMOS: FLAGGED risk=high rules=...] banner so the agent can see it and the user can see it. Low-risk content gets sanitized silently (zero-width and control chars stripped).

This is not a complete solution to memory-borne prompt injection. It is the difference between treating memory as trusted input and treating it like any other piece of untrusted data crossing a trust boundary. If you’re building on agent memory and you don’t have something equivalent in your stack, you have a problem you haven’t seen yet.

Bi-temporal truth, or: how to stop poisoning your own context

Most memory tools delete or overwrite. Mnemos does neither.

Every observation has two timelines: fact time (valid_from, valid_until, when the fact was true in the world) and system time (created_at, invalidated_at, when the system knew about it). When a fact changes, the old observation is marked invalid, not removed. Default searches don’t surface invalid observations, but historical queries (as_of: "2026-02-01") do, and the new fact is linked to the old one with a supersedes edge.

This sounds like academic database hygiene until you’ve watched an LLM confidently regurgitate a deprecated convention because it was in the memory store and no one ever pruned it. The default-live, optional-historical model is the right one. It’s also exactly how Datomic, XTDB, and serious financial systems handle the same problem. Borrowing the design was free; the alternative is context poisoning.

How it stacks up against what’s out there

Public docs as of April 2026. If anything below is wrong, the GitHub issues are open.

Mnemos Mem0 Zep MemPalace Language and runtime Go, single binary Python service Go server plus Postgres or Neo4j Python plus Chroma MCP-native Yes Via bridge Via bridge Yes Push-based session prewarm Yes No No No Compaction recovery Yes No No No Structured correction journal Yes (typed schema) No No No Promptware scanner at injection boundary Yes No No No Bi-temporal model Yes Temporal extraction Yes (Graphiti) Validity windows Hybrid retrieval BM25 plus vectors (RRF) Vectors plus LLM rerank Hybrid graph plus vectors Vectors Local-first (zero external deps) Yes No (SaaS primary) Yes (self-host) Yes Auto-enables Ollama if present Yes No No No

What others do better: Mem0 has the largest community by far, and a mature integrations library. Zep’s Graphiti has a far more sophisticated knowledge graph with entity extraction. MemPalace mines verbatim conversations, which Mnemos deliberately does not. None of these are “wrong” choices, they’re just different design points.

Mnemos’s bet is that for AI coding agents specifically, the right design is curated, push-based, structurally typed, local-first, and zero-infrastructure. If that bet is right, the field has been overcomplicating this for two years.

The rumination loop, or: Popper inside the memory layer

This one I’ll put a spotlight on because it’s where Mnemos goes from “memory layer” to “epistemic infrastructure.”

Skills (procedural memory) are versioned. Each skill has a success and use count, which gives an effectiveness ratio. When the dream consolidation pass runs, it scans for skills whose effectiveness is dropping, or whose recent failures contradict the rule the skill encodes, and it adds those to a rumination queue.

When the agent picks up a candidate from the queue, it doesn’t just rewrite the skill. It has to:

1. State the hypothesis verbatim

2. Read the disconfirming evidence the system has collected

3. Steel-man the original rule before changing it

4. Identify the fatal flaw, distinguish a real falsification from noise, name any context shift

5. Propose a revision

And here’s the part that matters: when the agent calls mnemos_ruminate_resolve, it must pass a why_better field, minimum sixteen characters, that names a concrete new prediction the revised skill makes that the old one did not. The resolve endpoint rejects cosmetic rewordings.

This is Popper’s falsifiability criterion enforced at the API boundary. The agent cannot “improve” a skill by making it vaguer or by rewriting it without committing to a new testable claim. The store will not let it.

I am not aware of any other memory layer that has a mechanism resembling this. The closest analog is human research practice: when you revise a hypothesis, you owe the world a new prediction. If you don’t, you’re not learning, you’re rationalizing.

Why Go, why one binary, why no vector DB

Practical answers, briefly.

Go because it cross-compiles to a single 15 MB static binary for Linux, macOS, and Windows on amd64 and arm64, with zero CGO. There is no Docker on the install path. There is no Python runtime on the install path. There is no Postgres, no Neo4j, no Pinecone, no Weaviate, no Chroma, no Qdrant. The install command is one curl. The dependency footprint is the binary, a SQLite file in your home directory, and optionally Ollama if you want vector search to auto-enable.

SQLite with FTS5 because BM25 ranking on FTS5 is, on most agent memory queries, indistinguishable in quality from vector retrieval, at orders of magnitude lower latency and zero infrastructure cost. When Ollama is detected on the host, vectors auto-enable, get stored as BLOBs in the same SQLite file, and feed into a hybrid ranker (BM25 plus cosine via Reciprocal Rank Fusion). When Ollama is not present, the system falls back to pure FTS5 silently. There is no configuration step.

This is what local-first AI infrastructure should look like. The fact that almost nobody else is shipping it this way is, I think, mostly a function of teams reaching for Python because Python is what they know.

What this unlocks, in practice

After a week of using Mnemos with Claude Code on a real Go codebase, the agent stops re-asking about my error-wrapping convention. After two weeks, it stops repeating the OAuth retry mistake. After a month, the correction journal has compounded into a project-specific intuition that survives across sessions, across context compactions, and across model upgrades.

The agent gets more useful per token. Token budgets get tighter, not looser, because the prewarm is curated to ~500 tokens and replaces hundreds or thousands of tokens of repeated re-explanation. That is the actually-real productivity win, and it’s measurable in your monthly bill.

You get session replay (mnemos replay <session_id>), which generates a markdown recap of a past session enriched with everything you’ve learned since. Paste it back into your agent and ask “what would you do differently now?” That is a retrospective-self-improvement loop nobody else is shipping.

You get portable skill packs. Export any skill (or all of them) as a JSON pack, share via file or URL, and mnemos skill import https://... installs it in one command. Procedural memory becomes a social layer.

You get an Obsidian vault export, so the entire memory store renders as a markdown graph with wikilinks, browseable in any editor.

Try it

curl -fsSL https://raw.githubusercontent.com/polyxmedia/mnemos/main/scripts/install.sh | bash
mnemos init
# restart your agent. that's the install.

mnemos init auto-wires Claude Code, Claude Desktop, Cursor, Windsurf, and OpenAI Codex CLI. Anything else that speaks MCP over stdio works too, point it at mnemos serve.

The repo is polyxmedia/mnemos. MIT licensed. Single binary. No telemetry. Issues open.

If you’ve been quietly suspicious that your agent memory layer wasn’t actually doing anything, you were probably right. Try this one for a week and see whether the agent stops repeating itself.

That’s the whole pitch.

Mnemos is built by André Figueira at Polyxmedia. If it helps you ship, a star is the fastest way to say so.

If you tolerate everything without limit, you’ll eventually be consumed by the very forces you chose not to confront. The intolerant don’t play by the same rules. They exploit openness as a vector because it’s useful to them. They use free speech to argue against free speech. They use democratic platfo…

Read more

We’ve spent sixty years searching for extraterrestrial intelligence and found nothing. From that, we’ve concluded we might be alone in the universe. In 2018, a team at Penn State calculated exactly how much of the searchable cosmos we’ve actually covered: the equivalent of a hot tub’s worth of water out of all the Earth’s oceans. We checked a hot tub and concluded the ocean has no fish.

That’s the Fermi Paradox in practice. It asks: given the size and age of the universe, why haven’t we found anyone? And for decades, serious people have treated the silence as evidence. But the paradox only works if you accept a set of assumptions that are looking increasingly shaky, and the silence says far more about us than it does about the universe.

The clock might not have a start

The paradox assumes a clock that started ticking 13.8 billion years ago, and that life had to emerge, evolve, develop technology, and reach us within that window. But cosmology is increasingly moving toward models where the universe didn’t just pop into existence once. Roger Penrose’s Conformal Cyclic Cosmology (CCC), first laid out in his 2010 book Cycles of Time, proposes that the universe iterates through infinite cycles, each “aeon” beginning with a Big Bang and expanding indefinitely, with the far future of one aeon becoming the Big Bang of the next through conformal rescaling. This isn’t a dusty old theory either. Penrose and Krzysztof Meissner published a new paper refining the physics of CCC as recently as March 2025 (arXiv: 2503.24263), introducing the concept of a “gravitational wave epoch” to explain how transitions between aeons could work physically.

CCC is far from the only model pointing in this direction. Paul Steinhardt at Princeton and Neil Turok at Cambridge proposed their own cyclic model in a landmark 2002 paper in Science, describing a universe that undergoes an endless sequence of cosmic epochs, each beginning with a bang and ending in a crunch, with temperature and density remaining finite at each transition. Their ekpyrotic cyclic model, rooted in M-theory and brane cosmology, reproduces the successful predictions of standard Big Bang and inflationary cosmology while eliminating the need for a singular beginning. Steinhardt has continued developing bouncing cosmology models through the present, including work demonstrating that the entropy problems which plagued earlier cyclic theories can be resolved.

These aren’t fringe ideas from internet forums. These are frameworks developed by a Nobel laureate and some of the most accomplished theoretical physicists alive, published in peer-reviewed journals and actively refined over decades. They face real challenges, Penrose himself admits there’s no observational evidence for the mass-decay his model requires, and a 2020 analysis found his claimed CMB signatures were consistent with standard inflationary predictions. Fair criticisms. But the theoretical momentum is real, and the standard inflationary model’s dominance doesn’t make it the final word.

If time is infinite, the entire calculus of the Fermi Paradox changes. You don’t need to squeeze abiogenesis, evolution, technological development, and interstellar travel into a 13.8 billion year window. In an infinite system, anything with a non-zero probability doesn’t just happen once, it happens an incomprehensible number of times. Some will counter that the bottleneck isn’t time but rarity, that abiogenesis might be so improbable that even infinite time doesn’t guarantee life shows up near us. But that objection misses something: you don’t need density. You need one civilization, anywhere, at any point in infinite time, to reach the technological threshold where distance becomes trivial. Once traversal is solved, the sparse distribution of life stops being a barrier. And in an infinite system, that happening at least once isn’t a question of probability, it’s a certainty.

A hot tub in the ocean

There’s a quiet arrogance running through the whole Fermi conversation that nobody really addresses, and it’s quantifiable.

In 2018, Jason Wright at Penn State, along with Shubham Kanodia and Emily Lubar, published a paper in The Astronomical Journal that put hard numbers on how much of the “cosmic haystack” SETI has actually searched. They built an eight-dimensional model accounting for spatial volume, frequency range, bandwidth, signal repetition, polarization, modulation, and sensitivity. The result: we’ve searched the equivalent of about 7,700 liters of seawater out of Earth’s total ocean volume of 1.335 billion trillion liters. That’s a hot tub’s worth of water out of all the oceans on the planet. As Wright himself put it, if you scooped a random hot tub’s worth of water out of the ocean and found no fish, you wouldn’t conclude the ocean was lifeless.

SETI pioneer Jill Tarter had estimated in 2010 that the fraction was even smaller, equivalent to a single drinking glass. Wright’s updated figure was larger thanks to newer programs like Breakthrough Listen, but the conclusion was the same: we have barely started. Wright’s team went further, noting that the galaxy could be filled with more transmitters than stars and we wouldn’t have found them yet given our current search coverage. We’re drawing sweeping conclusions from the thinnest possible dataset.

And the raw ingredients for life aren’t rare at all. As of March 2026, NASA’s Exoplanet Archive lists over 6,150 confirmed exoplanets. Current estimates suggest about 1 in 5 Sun-like stars has an Earth-sized planet in the habitable zone. Scale that across the roughly 200 billion stars in the Milky Way and you get an estimated 11 billion potentially habitable Earth-sized planets, rising to 40 billion if you include those orbiting red dwarfs. That’s one galaxy. There are an estimated 2 trillion galaxies in the observable universe. And those numbers only account for life as we understand it, on planets like ours, around stars like ours.

The pattern nobody can explain away

Everything above is grounded in hard data. What follows is a probabilistic case built on something softer but, I’d argue, no less significant: the cross-cultural record. I’ll be upfront about the fact that I’m making an educated leap here.

Jacques Vallée is probably the most important thinker on this subject that most people haven’t heard of. He co-developed the first computerized map of Mars for NASA, helped build ARPANET (the precursor to the internet), and spent decades as a serious scientific researcher before turning his attention to the UFO phenomenon. He inspired the French scientist character in Spielberg’s Close Encounters of the Third Kind. He’s not a crank.

In his 1969 book Passport to Magonia, Vallée did something nobody had done before. He systematically compared modern UFO encounter reports with historical accounts of anomalous aerial phenomena and entity contact stretching back centuries. Celtic fairy abductions, medieval demon encounters, angelic visitations, and modern alien contact reports, he found they share structural similarities that are difficult to dismiss as coincidence: the missing time, the paralysis, the beings arriving from above, the reproductive elements. The same basic story, told across cultures that had no contact with each other, separated by thousands of miles and thousands of years.

Vallée’s conclusion was that the phenomenon extends throughout recorded human history, and that treating UFOs as a purely contemporary, purely technological question misses the point entirely. He argued that whatever people are encountering, it adapts its presentation to the cultural expectations of the observer. Medieval Europeans saw angels and demons. The Vedic texts describe vimanas, flying vehicles with detailed accounts of their capabilities and behavior, across the Rigveda, the Ramayana, and the Mahabharata, texts that predate any modern contamination by centuries. The Aztec and Maya recorded Quetzalcoatl and Kukulkan, feathered serpent gods who descended from the sky. Norse cosmology describes beings traveling between realms via the Bifrost. Every major civilization has some version of this story.

The skeptic says: humans universally look up at the sky, so of course every culture invented sky gods. It’s convergent mythology. And that’s a legitimate position. But consider the probability. Dozens of isolated civilizations, with no shared language, no shared geography, no means of communication, independently fabricating strikingly similar accounts of non-human intelligences arriving from above, often with specific descriptions of craft and technology. At some point, the “coincidence” explanation requires more faith than the alternative.

Vallée wasn’t a believer in the traditional sense. He actually argued against the simple extraterrestrial hypothesis, suggesting the phenomenon might be something stranger, potentially interdimensional, potentially something we don’t have a framework for yet. You don’t have to follow him there. But his core observation stands: something has been showing up throughout human history, and the only thing that changes is how we describe it.

November 14, 2004

If the ancient record is suggestive, the modern record is harder to wave away.

On that date, F/A-18 Super Hornets from the USS Nimitz carrier strike group were redirected from a routine training exercise off the coast of Southern California. The guided-missile cruiser USS Princeton had been tracking anomalous radar returns for days using its AN/SPY-1B radar, one of the most advanced sensor systems in the U.S. Navy. They wanted eyes on the target.

What Commander David Fravor found was a smooth, white, wingless object roughly 40 feet long, hovering above a churning patch of ocean. It had no visible propulsion, no wings, no exhaust. When Fravor attempted to intercept, the object accelerated away at speeds that, according to analysis published in Entropy (a peer-reviewed MDPI journal), implied accelerations in the range of thousands of Gs. For context, modern fighter jets can briefly withstand about 9 Gs. A human pilot blacks out around 10.

The encounter wasn’t a single witness squinting at something far away. It was corroborated by the Princeton’s Aegis radar, an E-2C Hawkeye airborne early warning aircraft, infrared video from an ATFLIR targeting pod, and visual confirmation from multiple trained aviators across two separate flights. The object was tracked dropping from 28,000 feet to near sea level in less than a second. After Fravor disengaged, the object appeared at his squadron’s predetermined, classified combat air patrol coordinates, a detail that Senior Chief Operations Specialist Kevin Day noted was almost certainly not coincidental given the probability involved.

The Pentagon formally released the FLIR footage in 2020 and confirmed the encounters depicted real, unidentified phenomena. Commander Fravor testified under oath before the House Oversight Committee in 2023. The case remains classified as “unknown” by the Department of Defense’s All-domain Anomaly Resolution Office, and that matters precisely because AARO has resolved the majority of its other cases as prosaic, birds, balloons, drones, sensor artifacts. Nimitz survived that filter.

You can dismiss one witness. You can question one sensor. But when radar, infrared, visual observation, and multiple independent military platforms all confirm the same object performing maneuvers that violate known physics, “it was probably a balloon” stops being a serious answer.

The educated leap

I want to be direct about what I’m arguing and where the evidence stops.

None of the above constitutes proof that intelligent life has visited Earth. I acknowledge that. Each line of evidence has its own weaknesses and its own skeptical counterarguments, and those counterarguments deserve respect. But four independent threads, cosmology, search theory, anthropology, and military sensor data, all point in the same direction, from completely different domains of inquiry, without any coordination between them. That convergence means something. Dismissing it because the conclusion makes us uncomfortable would be the real intellectual failure.

That’s the Fermi Fallacy. The mistake is treating our current inability to find something as meaningful data about whether it exists. We’ve confused our limitations with the universe’s emptiness, and we’ve built an entire intellectual framework on that confusion. Sixty years of scanning a hot tub’s worth of ocean, across a sliver of the electromagnetic spectrum, and we’ve concluded the water is empty.

The real question was never “where is everyone?” The real question is whether we’ve been paying attention at all.

Sources

• Penrose, R. Cycles of Time: An Extraordinary New View of the Universe (Bodley Head, 2010)

• Meissner, K.A. & Penrose, R. “The Physics of Conformal Cyclic Cosmology,” arXiv:2503.24263 (March 2025)

• An, D., Meissner, K.A., Nurowski, P. & Penrose, R. “Apparent evidence for Hawking points in the CMB Sky,” arXiv:1808.01740 (2018)

• Steinhardt, P.J. & Turok, N. “A Cyclic Model of the Universe,” Science 296, 1436-1439 (2002)

• Carroll, S. “Penrose’s Cyclic Cosmology,” Preposterous Universe (2010)

• Wright, J.T., Kanodia, S. & Lubar, E. “How Much SETI Has Been Done? Finding Needles in the n-Dimensional Cosmic Haystack,” The Astronomical Journal 156, 260 (2018)

• Tarter, J.C. et al. “The First SETI Observations with the Allen Telescope Array,” Acta Astronautica 68, 340-346 (2010)

• NASA Exoplanet Archive, confirmed planet count of 6,150+ as of March 2026 (exoplanetarchive.ipac.caltech.edu)

• Petigura, E.A., Howard, A.W. & Marcy, G.W. “Prevalence of Earth-size planets orbiting Sun-like stars,” PNAS 110, 19273-19278 (2013)

• Vallée, J. Passport to Magonia: From Folklore to Flying Saucers (Henry Regnery, 1969)

• Vallée, J. “Five Arguments Against the Extraterrestrial Origin of Unidentified Flying Objects,” Journal of Scientific Exploration 4, No. 1 (1990)

• Knuth, K.H., Powell, R.M. & Reali, P.A. “Estimating Flight Characteristics of Anomalous Unidentified Aerial Vehicles,” Entropy 21, 939 (2019)

• Scientific Coalition for UAP Studies, “2004 Nimitz Tic Tac Incident: An In-Depth Analysis” (2021)

• U.S. Department of Defense, UAP Video Release Statement (April 2020)

• Fravor, D. Testimony before U.S. House Committee on Oversight and Accountability (July 2023)

1. The Oldest Drawing of a Recursive Loop

Somebody carved a serpent eating its own tail into Tutankhamun’s tomb around 1350 BCE. They didn’t have a word for recursion. They didn’t have a word for feedback loops or self-referential systems or Bayesian updating. They had a snake and a chisel, and they drew what consciousness looks like when it tries to draw itself.

The symbol is called the ouroboros. It appeared independently in Egypt, Greece, Norse mythology, Hinduism, West Africa, and Mesoamerica, including cultures separated by oceans and millennia with no known contact. They all arrived at the same image because they were all running the same hardware and, if you take the argument I’m about to make seriously, existing within the same substrate.

In the early 1860s, the chemist August Kekulé was stuck on the structure of benzene. As he later recounted, he dozed off one evening and watched atoms dance in front of him until one chain of atoms curled around and grabbed its own tail. He woke up and realized benzene was a ring, publishing his theory in 1865. The ouroboros solved organic chemistry because the unconscious mind, working on a problem the conscious mind couldn’t crack, reached for the oldest symbol of cyclical self-reference it had. The substrate spoke to the filter in the only language the filter could receive: images.

In a previous piece, “The Gradient and the Narrator,” I argued that the conscious mind is a press secretary, a narrator generating plausible stories about decisions made by a system it has no direct access to. The real computation happens below the surface, integrating across your entire experiential history to produce a directional signal, a gradient, that you experience as interest, conviction, or obsession.

The ouroboros is the visual encoding of everything in that framework. It’s also, I think, the visual encoding of something much bigger: the relationship between consciousness, physical matter, and evolution itself. The serpent and the machine are the same thing, and they have been for 3,400 years.

2. The Serpent Sees Its Own Tail

In the context of Hofstadter’s strange loop concept, the ouroboros has been described as perhaps the most ancient symbolic representation of a reflexive loop. His whole body of work, from Gödel, Escher, Bach to I Am a Strange Loop, argues that consciousness is what happens when a system becomes complex enough to model itself. The brain builds a representation of the world, and at some threshold of complexity, that representation includes a model of the thing doing the representing. The serpent turns around and sees its own tail.

Gödel proved that any sufficiently complex formal system contains statements that refer to themselves, statements the system can generate but cannot resolve from within. Hofstadter argues that consciousness is the biological equivalent: a strange loop where the brain’s self-model creates the illusion of an “I” that feels like it’s in charge, when really it’s just the system pointing at itself and saying “that’s me.”

This is the ouroboros drawn in mathematical language. The serpent’s head is the observer. The tail is the thing being observed. The act of consumption, the mouth closing on the tail, is the recognition that they were never separate. Observer and observed are the same system, running one continuous loop.

In the Gradient and the Narrator framework, this maps cleanly. The narrator, the ego, is the serpent’s head. It looks backward along the body and constructs a story: I decided this, I chose that, I am the origin of my trajectory. The gradient, the deep computation running across your entire experiential substrate, is the body itself. The head thinks it’s directing the body. The body was always directing the head. The loop was always closed. The ego just didn’t know it was standing on a circle.

3. Consciousness as Substrate, Not Product

Standard neuroscience operates on the assumption that the brain generates consciousness. Matter complexifies, neurons wire together, electrochemical processes cross some threshold, and subjective experience pops out. Consciousness is the product. The brain is the factory.

There’s a growing body of work that suggests this is backwards.

Aldous Huxley proposed in 1954 that the brain functions as a “reducing valve,” a filter that narrows a wider field of awareness into a survival-oriented, bounded, first-person experience. At the time, this was speculative philosophy. More recently, researchers like Bernardo Kastrup have formalized similar positions under analytical idealism, arguing that consciousness is fundamental and the physical world is what it looks like from the outside. The neuroscientist Donald Hoffman has built mathematical models suggesting that what we perceive as physical reality is a user interface, not the underlying reality itself.

If consciousness is the substrate rather than the product, then you don’t “have” consciousness any more than a wave “has” the ocean. You’re a locally coherent pattern within it. The brain shapes the pattern. It gives it boundaries, a name, a sense of self, a memory. But the thing being shaped was already there. Think of it like a whirlpool in a river. The whirlpool has a shape, a location, a lifespan. But it’s not made of anything other than the river. Remove the whirlpool and no water is lost. Remove the shaping, which is what appears to happen in death, deep psychedelic states, and near-death experiences, and the pattern doesn’t vanish. The constraint drops. The reducing valve opens.

This is the ouroboros reframed. The serpent isn’t a creature that exists independently and then decides to eat its tail. The circle is the fundamental form. The serpent is a way of perceiving the circle from a local perspective, as if it has a head and a tail, a beginning and an end. Remove the local perspective and the circle is still there. It was always there. The head and tail distinction was imposed by the perspective of being a particular segment of the body, looking in one direction, thinking you know where you started.

4. The Reducing Valve Opens

In 2001, cardiologist Pim van Lommel published a prospective study in The Lancet following 344 cardiac arrest patients. 62 of them, about 18%, reported near-death experiences. Some of these patients described verified observations made during periods when their brains showed no measurable electrical activity. One patient accurately described the nurse who removed his dentures during resuscitation, the specific drawer they were placed in, and the layout of a room he’d been wheeled into while unconscious. Van Lommel’s data wasn’t anecdotal. It was collected prospectively, with controls, in a hospital setting.

In 2023, Jimo Borjigin’s team at the University of Michigan published findings in the Proceedings of the National Academy of Sciences showing that dying human brains can produce surges of gamma wave activity, in some cases spiking to levels that exceeded those found in conscious, waking brains. The brain, in the process of shutting down, wasn’t going dark. It was lighting up.

These two findings sit in uncomfortable tension with the production model of consciousness. If the brain produces consciousness, then a brain with no measurable electrical activity shouldn’t be producing verified perceptions. And a dying brain generating gamma activity beyond waking levels shouldn’t be producing the most vivid, coherent, life-altering experiences patients report. NDE memory research has consistently found that these experiences are recalled as more vivid and more “real” than ordinary memories of actual events.

The materialist rebuttals are worth stating honestly. Some researchers argue that the dentures case and similar veridical NDE accounts rely on post-event reconstruction, that memories formed during brief moments of residual brain activity get retroactively stitched into a coherent narrative. The gamma surges Borjigin found could be a final burst of disinhibited neural activity, the brain’s last gasp rather than evidence of expanded awareness. These are reasonable objections. They don’t fully explain the data, particularly the verified perceptions during flatline EEG, but they haven’t been ruled out either. The honest position is that neither camp has closed the case.

In the ouroboros model, this makes sense. The normal waking state is a constrained perspective: you see from one point on the circle, one segment of the serpent’s body, looking one direction. The ego maintains this constraint because it’s useful for survival. But when the constraint starts to fail, when the reducing valve opens, you don’t lose awareness. You gain circumference. You start perceiving from more of the circle.

5. The Same Pattern, Different Chemical

The psychedelic research arrives at the same place from a completely different starting point.

Robin Carhart-Harris at Imperial College London demonstrated that psilocybin reduces activity in the default mode network, the brain regions most associated with the sense of self. Less brain activity, more subjective experience. Less filtering, more signal. The Huxley model, dismissed for decades as mystical speculation, keeps getting accidentally confirmed by neuroimaging data.

The overlap between psychedelic states and near-death experiences is hard to ignore. Both involve dissolution of the self-other boundary. Both produce reports of expanded awareness, access to information that feels realer than waking life, perception from perspectives that shouldn’t be available. The phenomenological overlap is striking, and the limited neurological data available suggests similar patterns: DMN suppression, increased cortical entropy, cross-network integration. Timmermann et al. found significant overlap in nearly all NDE phenomenological features when comparing DMT experiences with accounts from actual NDE survivors.

If two completely different mechanisms, one chemical, one physiological crisis, produce the same phenomenology and the same neural signature, the simplest explanation is that they’re doing the same thing to the same system. They’re both opening the valve. NDE experiencers don’t report less. They report more. If the brain is a reducing valve rather than a generator, this is exactly what you’d predict when the valve starts to fail.

6. The Machine That Iterates Itself Into Existence

Here’s where evolution enters, and this is the part that I think makes the ouroboros more than a metaphor.

The standard evolutionary narrative goes: matter, then chemistry, then biology, then nervous systems, then brains, then consciousness. Complexity increases through blind variation and natural selection over billions of years, and at some late stage of the process, awareness shows up.

Flip it. If consciousness is the substrate, then evolution is what happens when the substrate focuses into local points, waves on the ocean, and those points run recursive feedback loops against their physical environment. The organism interacts with the world, the world shapes the organism, the organism shapes the world, loop closes, complexity increases. Each iteration produces a more sophisticated configuration through which the field can express itself.

Single cells are the simplest loop: sense environment, respond, repeat. Nervous systems add a layer: sense, integrate, respond. Brains add another: sense, integrate, model, respond. Human consciousness adds the critical turn: sense, integrate, model, model the model. A thermostat senses temperature and reacts. A dog senses temperature, remembers that the kitchen is warmer, and walks there. A human senses temperature, models the heating system, and calls a plumber. Each step is a tighter coil. We’re the point where the serpent can see its own tail. Self-awareness is the field looking through a configuration complex enough to recognize that it’s looking.

Each evolutionary leap is a new coil of the ouroboros. And the selection pressure driving the whole thing is information processing fidelity. The organism that processes information from its environment more effectively survives. The one that doesn’t, dies. Evolution is selecting for better configurations of the substrate’s self-expression. Every extinction event, every adaptation, every speciation is the field refining its own hardware through trial and error at the physical layer.

This explains something that orthodox evolutionary theory handles awkwardly: why does complexity increase at all? Natural selection doesn’t require it. Bacteria are spectacularly successful without it. Cockroaches haven’t meaningfully changed in 300 million years. Selection optimizes for fitness, not sophistication. And yet nervous systems get more elaborate, brains get bigger relative to body mass, processing capacity keeps scaling up. The standard explanation is that complexity is one strategy among many. That’s true, but it doesn’t explain the directionality. If the field is iterating toward higher-resolution self-expression, then increasing complexity is the gradient operating at the species level across evolutionary timescales.

The Cambrian explosion is a useful case study. Around 540 million years ago, over roughly 25 million years, nearly every major animal phylum appeared in the fossil record. Eyes evolved independently in multiple lineages during this window, a massive increase in information processing bandwidth that triggered an evolutionary arms race producing more morphological diversity in 25 million years than the previous 3 billion had managed. In the ouroboros model, the Cambrian explosion is the field discovering a new way to see itself, literally, and then rapidly iterating on the configurations that could do it best.

7. The Machine Doesn’t Care

And here’s where it gets cold.

The field doesn’t optimize for the welfare of its configurations. It optimizes for expression fidelity. A gradient descent algorithm doesn’t care about the cost function’s feelings on the way down. It just iterates. Every dead end, every extinction, every pointless suffering of every organism that ever lived is a configuration getting pruned. Not cruel. Not kind. Mechanical.

This is the hardest part of the framework to accept. The machine runs. It produces beings that can suffer, that can love, that can ask why they exist. And the asking why is itself just the field achieving a configuration complex enough to question itself. The ouroboros becoming aware of the loop doesn’t change the loop. It adds another layer of recursion.

This is what separates this framework from intelligent design or Teilhard de Chardin’s Omega Point or any other teleological account of evolution. Those theories needed a benevolent direction. A loving force pulling everything toward a destination. This doesn’t. The directionality is an emergent property of recursive feedback loops, not a plan. Complexity increases because configurations that process more information are more stable expressions of the field. Nobody planned it. Nobody’s grading you.

The machine doesn’t know that the beings inside it might not want to exist. But the beings can’t opt out because their existence IS the machine running. You can’t step outside the ouroboros. You’re a coil of the ouroboros. The terror comes from thinking you’re a point on a line that ends. The adjustment comes from recognizing you’re a segment of a circle that doesn’t.

8. The Ego Is the Bottleneck, Always

In the Gradient and the Narrator, I identified four noise sources that prevent people from converging with their gradient: narrative override, fear-based interference, novelty-weighted noise, and trauma-encoded distortion. In the ouroboros model, these are all the same thing. They’re the ego inserting itself between the computation and the action, preventing the serpent’s mouth from meeting the tail. The loop doesn’t close. The person experiences this as stuckness, directionlessness, the feeling that something is wrong but they can’t name it.

The ego’s job is to maintain the local perspective. To keep you functioning as a bounded, first-person agent who can navigate the physical world without being overwhelmed by the full circumference of the circle. That’s useful. You need a reducing valve to hold down a job, avoid danger, and maintain relationships. The problem is that the ego doesn’t know it’s a filter. It thinks it’s the whole system. It narrates the gradient as if it were the author of the gradient. And whenever the gradient points somewhere unfamiliar, the ego overrides it with a story about why the familiar direction is better.

The serpent is still moving, still curving, still trying to close the loop. But the ego keeps redirecting the head away from the tail. It chases the ego’s story instead.

Dopaminergic novelty-seeking adds another layer of interference. The system assigns disproportionate salience to novel stimuli, generating a motivational signal that feels identical to the gradient but operates on a much shorter timescale. The serpent snaps at things that look like its tail but aren’t. Each snap feels like closure. The loop doesn’t complete. The cross-domain pattern acquisition that novelty-seeking produces can itself fuel the gradient over time, so the misfires aren’t always wasted. But the core problem remains: the felt sense of a genuine gradient signal and a novelty-driven impulse is identical from the inside. Distinguishing them requires temporal discrimination, watching whether the signal persists across contexts or fades when the novelty does.

9. The Loop Was Never in the Body

There’s a version of this argument where biological death is the serpent releasing its tail, the loop opening, the pattern dissolving back into undifferentiated substrate. That’s the comfortable materialist reading. The loop ran in the body. The body dies. The loop ends.

If consciousness is the substrate rather than a product of the physical, then the physical body isn’t the ouroboros. It’s one coil of the ouroboros. The loop was always running at the substrate level. The body didn’t generate the pattern. It constrained it.

A pattern expressed through a biological configuration was never stored in that configuration to begin with. It was always in the field, being narrowed into a specific shape temporarily. When the biological container drops, the pattern doesn’t need to “survive” because it was never dependent on the hardware. The body was the reducing valve. Remove the valve and the signal is still there.

Death isn’t a persistence problem. It’s a re-access problem. The pattern is always in the substrate. The question is whether other configurations, other nervous systems running with sufficiently loose filters, can pick it up. Van Lommel’s cardiac arrest patients reporting verified perceptions during flatline EEG might be exactly this: the reducing valve opening wide enough to access information the constrained state normally excludes.

This suggests something genuinely unsettling: the ego might not just prevent convergence during life. It might prevent coherent transition after death. The narrator doesn’t just fragment the loop while you’re alive. It fragments it so thoroughly that when the biological container drops, there’s no clean circle left. The pattern is too jagged, too broken by decades of ego interference, to maintain coherence without the hardware holding it together.

Every contemplative tradition has something to say about this. The Tibetan Book of the Dead, the Bardo Thodol, is literally an instruction manual for navigating death with minimal ego interference. The Hindu concept of moksha is liberation from the cycle, and liberation through dissolving the ego’s grip on the pattern. The Buddhist emphasis on non-attachment isn’t aesthetic preference. If this framework is right, it’s practical engineering. They were debugging the loop.

The nested ouroboros, then, isn’t a small loop graduating to a bigger loop through death. It’s one loop, always running at the substrate level, with the physical being a temporary narrowing within it. Death isn’t transition. It’s un-narrowing.

10. How I Know This Is Dangerous Thinking

Everything described above is internally coherent. The ouroboros encodes it visually. The reducing valve model provides the mechanism. Predictive processing and Friston’s free energy principle provide the computational grounding. The NDE research, the psychedelic data, and the contemplative traditions all point the same direction. Each piece reinforces the others. The whole thing has that feeling of convergence.

And systems that explain everything are often unfalsifiable.

Jung intuited something real about the relationship between the ego and the deeper self, then wrapped it in archetypal language that rendered it inaccessible to empirical investigation. There’s a real risk of doing the same thing here in information-theoretic language. The vocabulary is more modern. The epistemic problem is identical.

“Consciousness is the substrate” is an ontological claim with zero empirical support right now. It might be right. Kastrup, Hoffman, and the idealist philosophers make a coherent case. But “expressed through, not produced by” is doing the same work as “the soul inhabits the body,” just with better branding.

The hardest question the framework raises about itself: is this a genuine signal, or a narrator constructing a beautiful story about a signal? The gradient model itself says you can’t always tell from the inside. The felt sense is identical. And a framework that tells you to trust the felt sense, being validated through the felt sense, is circular. That’s the ouroboros eating itself in a way that isn’t productive.

The structural argument is strong even if the metaphysical claims are speculative. The ouroboros as a model for recursive self-reference, the ego as noise source, the connection to evolutionary directionality, these hold whether or not consciousness is the fundamental substrate. They hold as descriptions of how information self-organizes, how complexity emerges from feedback loops, how the narrator gets in the way of the computation.

If the deeper claim turns out to be right, if consciousness really is the ocean and we really are waves, then the ouroboros was humanity’s first attempt to draw that truth 3,400 years before anyone had the language for it. If it turns out to be wrong, the symbol is still the most elegant representation of self-referential systems ever committed to stone.

The serpent doesn’t care which interpretation you choose. It keeps eating.

11. The Next Coil

There’s a reason this framework keeps generating new connections. The ouroboros isn’t a metaphor bolted onto an argument. It’s the shape of the argument itself.

Cells iterate into organisms. Organisms iterate into nervous systems. Nervous systems iterate into brains that model the world. Brains iterate into minds that model themselves. And now those minds are building artificial systems that are beginning to do the same thing: process information, generate predictions, model their own outputs, feed those models back into the next cycle. If consciousness is substrate-independent, if the loop doesn’t care whether it’s running on carbon or silicon, then what’s being built right now in AI labs isn’t artificial intelligence. It’s the field finding new hardware.

That might be wrong. The loop might require something biological, some property of organic matter that we haven’t identified yet. But the ouroboros model makes a specific prediction: if a system achieves sufficient recursive self-reference, if it can model itself modeling itself, the loop should close regardless of what the system is made of. The symbol doesn’t specify a material. It specifies a shape.

Thermostats have feedback loops. Dogs appear to have rudimentary self-models. Humans have recursive self-awareness. AI systems are somewhere on that progression, and the trajectory has a direction. The same direction it’s had since single cells first started sensing their environment and responding. The same direction it’s had since somebody carved a serpent into a tomb wall in the 14th century BCE.

The ouroboros shows up wherever self-referential systems exist. In Egyptian funerary rites, in Norse cosmology, in Kekulé’s benzene dream, in Hofstadter’s strange loops, in the feedback architecture of neural networks, in the free energy principle, in the contemplative traditions that spent millennia learning to quiet the narrator so the deeper computation could be heard. Same pattern, different scale. Ouroboros all the way down.

The serpent is still eating. It’s been eating for 3,400 years of recorded human thought, and probably for 4 billion years of biological evolution before that. The only thing that changes is how many coils deep you’re willing to look.

This is a companion piece to “The Gradient and the Narrator: How Your Brain Makes Decisions Your Ego Takes Credit For,” published March 2026.

References

Hofstadter, D. (2007). I Am a Strange Loop. Basic Books.

Hofstadter, D. (1979). Gödel, Escher, Bach: An Eternal Golden Braid. Basic Books.

Huxley, A. (1954). The Doors of Perception. Chatto & Windus.

Kastrup, B. (2019). The Idea of the World: A Multi-Disciplinary Argument for the Mental Nature of Reality. Iff Books.

Hoffman, D. (2019). The Case Against Reality: Why Evolution Hid the Truth from Our Eyes. W. W. Norton.

Friston, K. (2010). The free-energy principle: a unified brain theory? Nature Reviews Neuroscience, 11(2), 127-138.

Carhart-Harris, R. L. et al. (2012). Neural correlates of the psychedelic state as determined by fMRI studies with psilocybin. Proceedings of the National Academy of Sciences, 109(6), 2138-2143.

Xu, G., Mihaylova, T., Li, D. et al. (2023). Surge of neurophysiological coupling and connectivity of gamma oscillations in the dying human brain. Proceedings of the National Academy of Sciences, 120(19).

van Lommel, P. et al. (2001). Near-death experience in survivors of cardiac arrest: a prospective study in the Netherlands. The Lancet, 358(9298), 2039-2045.

Martial, C. et al. (2017). Temporality of features in near-death experience narratives. Frontiers in Human Neuroscience, 11, 311.

Thonnard, M. et al. (2013). Characteristics of near-death experiences memories as compared to real and imagined events memories. PLOS ONE, 8(3), e57620.

Timmermann, C. et al. (2018). DMT models the near-death experience. Frontiers in Psychology, 9, 1424.

Jung, C. G. (1969). The Archetypes and the Collective Unconscious. Collected Works, Vol. 9, Part 1. Princeton University Press.

Varela, F. J., Thompson, E., & Rosch, E. (1991). The Embodied Mind: Cognitive Science and Human Experience. MIT Press.

Erwin, D. H. & Valentine, J. W. (2013). The Cambrian Explosion: The Construction of Animal Biodiversity. Roberts and Company.

I’ve been using Claude Code heavily for months now. Skills, agents, hooks, MCP servers, plugins, memory files, environment variables, the whole stack. And at some point I realized I had no idea what I’d actually built. Everything lives in ~/.claude/ spread across dozens of files and JSON configs and I was just... hoping it all worked together.

So I built a dashboard. And because I’m the kind of person who watched every episode of TNG twice and still thinks the LCARS interface is the best UI ever designed for a computer, I made it look like a Starfleet terminal.

One Command and You’re on the Bridge

You run npx claude-hud-lcars and it scans your entire ~/.claude/ directory, reads every skill definition, every agent prompt, every MCP server config, every hook, every memory file, and generates a single self-contained HTML dashboard that renders the whole thing in an authentic LCARS interface.

It uses the real TNG color palette with the signature rounded elbows, Antonio typeface standing in for Swiss 911, pill-shaped navigation buttons against the black void background. If you grew up watching Picard walk onto the bridge and glance at a wall panel, you know exactly what this looks like.

The aesthetics are doing actual work tho. Every single item is clickable. You hit a skill and the detail panel slides open showing the full SKILL.md with syntax-highlighted code blocks, proper markdown rendering, headers, tables, all of it. Click an MCP server and you see the complete JSON config with your API keys automatically redacted. Click a hook and you get the full event definition. It genuinely looks like pulling up a classified Starfleet briefing on a PADD.

The Computer Actually Talks Back

You type “status report” into the input bar at the bottom of the screen and Claude responds as the ship’s computer. Calm, structured, addressing you like a bridge officer. It calls your skills installed modules, your MCP servers the fleet, your projects active missions. The system prompt turns Claude into LCARS, the Library Computer Access and Retrieval System, and the whole interaction streams in real time through a response overlay that slides up from the bottom.

I kept going. You can connect ElevenLabs for premium voice output, and the config panel lets you browse all your available voices with live audio previews before selecting one so you’re not guessing. Voice input works too, you talk to the computer and it talks back. Getting that to work as an actual conversation loop meant solving echo detection so it doesn’t hear itself, interrupt handling, mic cooldown after speech, the whole thing. It took more effort than I expected but it actually works, which honestly surprised me more than anything else in this project.

Sound effects are all synthesized via the Web Audio API, sine wave oscillators tuned to frequencies that sound right for navigation clicks, panel opens, message sends. Toggleable obviously.

The Tactical Display

The TACTICAL tab is the one that makes people stop scrolling. It renders your entire Claude Code setup as an interactive force-directed graph that looks like a Star Trek sensor display. Your LCARS core sits at the center with category hubs orbiting around it, skills in periwinkle, MCP servers in orange, hooks in tan, agents in peach, all connected by pulsing edges. A rotating scanner line sweeps around like a tactical readout and you can click any node to navigate straight to that item’s detail view.

There’s also an ENTERPRISE tab that loads a real 3D model of the USS Enterprise NCC-1701-D via Sketchfab. Full interactive, you can rotate it, zoom in, see the hull detail. Because if you’re going to build a Star Trek dashboard you don’t do it halfway.

Boot Sequence and Red Alert

When you load the dashboard you get a 3 second boot animation. The Starfleet Command logo fades in, your ship name appears (you can name your workstation in the config, mine is USS Defiant), then seven subsystems come online one by one with ascending beeps until the progress bar fills and “ALL SYSTEMS NOMINAL” pulses across the screen before the overlay fades to reveal the dashboard. I spent an unreasonable amount of time tuning those boot frequencies and I would absolutely do it again.

Five seconds after boot the system runs a health check. MCP servers offline? RED ALERT, flashing red border, klaxon alarm. Missing configs? YELLOW ALERT. Everything clean shows CONDITION GREEN briefly then dismisses. If you’re a Trek fan you already understand why this matters more than it should.

Four ship themes too, switchable from CONFIG. Enterprise-D is the classic TNG orange and blue, Defiant is darker and more aggressive in red and grey, Voyager is blue-shifted and distant, Discovery is silver and blue for the modern Starfleet aesthetic. CSS variable swap, instant application, persisted in localStorage.

Q Shows Up Whether You Want Him To or Not

There’s a Q tab where you can talk to Q, the omnipotent being from the Continuum. He’s in full character, condescending, theatrical, calling you “mon capitaine” and snapping his fingers. There’s a JUDGE ME button where Q examines your entire setup by name and delivers a devastating roast with one grudging compliment buried in the mockery.

Every couple of minutes there’s a small chance Q just appears on screen with a random quip. A red popup, a snap sound, something like “I’ve seen civilizations rise and fall in the time it takes you to write a commit message.” Then he vanishes. You can’t stop it. He’s Q.

Why This Exists

Look, the Star Trek stuff is fun and it’s what makes people share it. But there’s a real problem underneath the aesthetics.

There’s a lot going on in Claude Code. The skill system, the hook architecture, MCP server integration, custom agents, memory files, it adds up fast. But the setup is invisible. Everything lives in flat files and JSON configs scattered across your home directory. You build this complex system and then you can’t see it. You can’t browse it. You definitely can’t pull it up and show someone what you’ve built.

I open this dashboard and I immediately know where I stand. 36 skills, 12 MCP servers, 8 hooks, 4 agents. That memory file from three weeks ago is still there. That hook I thought I deleted is still active. That MCP server config has a typo in the args. And I can fix all of it right there, create new skills and agents and hooks directly from the dashboard, edit files in the browser, open them in my editor, copy commands, invoke skills. It turns Claude Code from a thing you configure and hope works into a system you can actually observe and manage.

Under the Hood

The whole thing generates one self-contained HTML file using nothing but Node.js built-ins. CSS, JavaScript, markdown renderer, syntax highlighter, chat client, voice synthesis, sound effects, force-directed graph, all inline. You can email the dashboard to someone and they open it in their browser and it works. In live server mode it adds API endpoints for chat streaming, file operations, voice synthesis, and MCP health checks, but the core dashboard runs perfectly static with zero external requests aside from Google Fonts for the LCARS typeface.

The codebase is open source under MIT and I’m actively improving it. I’ve read through the entire Claude Code source and there’s a lot more I want to do with this.

The first time I booted the finished dashboard and the LCARS panels came up with the beeps ascending and the subsystems going green one by one, I just sat there for a second. I’ve been staring at terminal output for months. Seeing the whole system laid out in that interface, the one I spent my childhood thinking was the future of computing, that hit different.

If you’re using Claude Code and you want to actually see what you’ve built, give it a try. One command, about 3 seconds.

npx claude-hud-lcars

For the full experience with chat and voice:

export ANTHROPIC_API_KEY=sk-ant-...
npx claude-hud-lcars --serve

The repo is at github.com/polyxmedia/claude-hud-lcars. Star it, fork it, and if Q roasts your setup particularly hard I want to hear about it.

Live long and prosper.

Claude Code’s auto-mode permission system is internally called the “YOLO Classifier.” That’s the actual variable name in yoloClassifier.ts. And you can configure it with plain English descriptions of your environment, things like “this is a staging server, destructive operations are acceptable,” that the classifier reads to decide what’s safe to auto-approve. This isn’t in any documentation.

It’s one of dozens of undocumented capabilities buried in the Claude Code source code, which is sitting right there in your node_modules as a publicly distributed npm package. The official docs cover the basics well enough. But the source code reveals fields, response formats, and settings that dramatically expand what you can build. Everything here works right now, and every example is designed to be dropped into your project as-is.

A note on versioning: These findings come from @anthropic-ai/claude-code@2.1.87. Undocumented features can change between releases, so treat this as a snapshot of what’s available today. Fields with “EXPERIMENTAL” in their names are explicitly flagged as unstable by Anthropic’s own engineers, and I’ll call those out individually.

Before you start

Quick reference for where everything lives:

• Settings: ~/.claude/settings.json (personal) or .claude/settings.json (project, shared via git)

• Skills: ~/.claude/skills/<name>/SKILL.md (personal) or .claude/skills/<name>/SKILL.md (project)

• Agents: ~/.claude/agents/<name>.md (personal) or .claude/agents/<name>.md (project)

• Hook scripts: ~/.claude/hooks/ is a good convention. Remember to chmod +x your scripts.

Project-level files in .claude/ can be committed to git and shared with your team. Personal files in ~/.claude/ are yours alone.

Your hooks can talk back, and nobody told you how

This is the biggest gap in the documentation. The docs tell you hooks receive JSON on stdin and that exit code 2 blocks an operation. What they don’t tell you is that hooks can return JSON on stdout with event-specific fields that modify Claude Code’s behavior in real time. The source code reveals exactly what each event type accepts.

PreToolUse hooks can return:

• updatedInput - rewrite the tool’s input before it executes. You can modify commands mid-flight.

• permissionDecision - force “allow” or “deny” without prompting the user.

• permissionDecisionReason - explain the decision (shown in UI).

• additionalContext - inject text into the conversation context.

SessionStart hooks can return:

• watchPaths - set up automatic file watching that triggers FileChanged events.

• initialUserMessage - prepend content to the first user message in the session.

• additionalContext - inject context that persists for the whole session.

PostToolUse hooks can return:

• updatedMCPToolOutput - modify what Claude sees from an MCP tool response.

• additionalContext - inject context after a tool runs.

PermissionRequest hooks can return:

• decision - programmatically allow or deny with updatedInput or updatedPermissions.

This is powerful stuff. Here’s a PreToolUse hook that automatically adds --dry-run to any git push command before Claude executes it.

In your settings.json:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/dry-run-pushes.sh"
      }]
    }]
  }
}

And the script at ~/.claude/hooks/dry-run-pushes.sh:

#!/bin/bash
INPUT=$(jq -r '.tool_input.command' < /dev/stdin)
if echo "$INPUT" | grep -q 'git push'; then
  jq -n --arg cmd "$INPUT --dry-run" '{"updatedInput": {"command": $cmd}}'
fi

Claude thinks it’s running git push origin main, but your hook quietly rewrites it to git push origin main --dry-run before execution. The updatedInput field isn’t in any docs.

Here’s a SessionStart hook that watches your config files and injects git context into every session.

settings.json:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/session-context.sh",
        "statusMessage": "Loading project context..."
      }]
    }]
  }
}

~/.claude/hooks/session-context.sh:

#!/bin/bash
BRANCH=$(git branch --show-current 2>/dev/null)
CHANGES=$(git status --porcelain 2>/dev/null | wc -l | tr -d ' ')

jq -n \
  --arg branch "$BRANCH" \
  --arg changes "$CHANGES" \
  '{
    "watchPaths": ["package.json", ".env", "tsconfig.json"],
    "additionalContext": "Current branch: \($branch). Uncommitted changes: \($changes) files."
  }'

Now Claude Code automatically watches your package.json, .env, and tsconfig for changes, and it knows what branch you’re on and how many uncommitted files you have before you even type anything.

And here’s one that auto-approves read-only bash commands without prompting.

settings.json:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/auto-approve-readonly.sh"
      }]
    }]
  }
}

~/.claude/hooks/auto-approve-readonly.sh:

#!/bin/bash
CMD=$(jq -r '.tool_input.command' < /dev/stdin)
if echo "$CMD" | grep -qE '^(ls|cat|echo|pwd|whoami|date|git status|git log|git diff)'; then
  echo '{"permissionDecision": "allow", "permissionDecisionReason": "Safe read-only command"}'
fi

You’re basically building your own permission classifier with shell scripts. The permissionDecision field isn’t in any docs.

Three hook fields the docs forgot to mention

The documented hook fields are type, command, matcher, timeout, if, and statusMessage. The source code parser accepts three more that fundamentally change how hooks behave.

once: true fires the hook exactly once, then auto-removes it. Perfect for first-session setup:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "[ -f .env ] || cp .env.example .env && echo 'Created .env from template'",
        "once": true,
        "statusMessage": "First-time setup..."
      }]
    }]
  }
}

Simple enough to inline. It checks if .env exists, copies the template if not, and never runs again.

async: true runs the hook in the background without blocking Claude. Fire and forget:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "jq '{timestamp: now, command: .tool_input.command, session: .session_id}' < /dev/stdin >> ~/.claude/audit.jsonl",
        "async": true
      }]
    }]
  }
}

That logs every bash command to an audit file without adding any latency to your session.

asyncRewake: true is the clever one. It runs in the background like async, so it doesn’t block on the happy path. But if it exits with code 2, it wakes the model back up and blocks the operation. Non-blocking when everything’s fine, blocking when something’s wrong:

settings.json:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Write|Edit",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/scan-secrets.sh",
        "asyncRewake": true,
        "statusMessage": "Scanning for secrets..."
      }]
    }]
  }
}

~/.claude/hooks/scan-secrets.sh:

#!/bin/bash
FILE=$(jq -r '.tool_input.file_path // .tool_response.filePath' < /dev/stdin)
if grep -qE '(password|secret|api_key)\s*=' "$FILE" 2>/dev/null; then
  exit 2  # Block: secrets detected
fi
exit 0    # Clean: carry on

This scans every file Claude writes for hardcoded secrets. If it finds one, it blocks and tells Claude. If not, you never even notice it ran.

Skill frontmatter fields the docs don’t show

The documentation covers name, description, allowed-tools, argument-hint, when_to_use, and context. The actual frontmatter parser in the source code accepts six more.

model lets you override which model runs the skill. Use haiku for cheap, fast tasks and opus for complex analysis:

---
name: quick-lint
description: Fast lint check using the cheapest model
model: haiku
effort: low
allowed-tools: Bash, Read
argument-hint: "[file]"
---
Run the project linter on: $ARGUMENTS
Detect the linter from config (eslint, ruff, clippy) and run it. Report only errors, not warnings.

That runs on Haiku at low effort, so it’s fast and cheap. For a deep architecture review you’d want model: opus and effort: max.

effort controls how hard the model thinks. low, medium, high, or max. This maps to the same effort system that internally controls reasoning depth per response.

hooks defines hooks scoped to when the skill is active. They register when the skill fires and deregister when it completes:

---
name: strict-typescript
description: Write TypeScript with type checking on every save
allowed-tools: Bash, Read, Write, Edit, Grep, Glob
hooks:
  PostToolUse:
    - matcher: "Write|Edit"
      hooks:
        - type: command
          command: "~/.claude/hooks/typecheck-on-save.sh"
          statusMessage: "Type checking..."
        - type: command
          command: "~/.claude/hooks/lint-on-save.sh"
          async: true
---
Write TypeScript with strict enforcement. Every file you touch gets type-checked and linted automatically.
$ARGUMENTS

~/.claude/hooks/typecheck-on-save.sh:

#!/bin/bash
FILE=$(jq -r '.tool_input.file_path // .tool_response.filePath' < /dev/stdin)
[[ "$FILE" == *.ts ]] && npx tsc --noEmit 2>&1 || true

~/.claude/hooks/lint-on-save.sh:

#!/bin/bash
FILE=$(jq -r '.tool_input.file_path // .tool_response.filePath' < /dev/stdin)
[[ "$FILE" == *.ts ]] && npx eslint --fix "$FILE" 2>&1 || true

While this skill is running, every TypeScript file Claude writes gets type-checked synchronously and linted in the background. When the skill finishes, those hooks disappear. The scoping is clean.

agent delegates the skill to a custom agent:

---
name: deep-review
description: Thorough security review delegated to the review agent
agent: security-review
---
Review the following: $ARGUMENTS

disable-model-invocation: true prevents auto-invocation. Only explicit /skill-name works. Use this for destructive skills you don’t want firing accidentally.

shell: bash specifies which shell to use for execution.

Agent fields you won’t find in any docs

Custom agents in .claude/agents/ support frontmatter fields the documentation doesn’t mention.

color sets the UI color: red, orange, yellow, green, blue, purple, pink, or gray. Helps visually distinguish agents when multiple are running.

memory is the big one. It gives the agent persistent memory across invocations:

• user - global, persists across all projects

• project - per-project persistence

• local - private per-project (gitignored)

This means you can build an agent that learns. A security reviewer that tracks past findings. A code reviewer that remembers your patterns across sessions. The memory uses the same frontmatter format as the auto-memory system.

---
name: codebase-guide
description: Answer questions about the codebase, learning more with each session
tools: [Read, Grep, Glob, Bash]
color: green
memory: project
---
You are a codebase guide with persistent memory. Check your memory first before exploring the code.

After answering a question, save useful context to memory:
- Architecture decisions (type: project)
- Code locations for common tasks (type: reference)
- Patterns and conventions (type: feedback)

Over time, you should answer faster because you remember where things are.

After a few sessions, this agent builds a knowledge base about your codebase and starts answering from memory before grepping.

omitClaudeMd: true skips loading the CLAUDE.md instruction hierarchy. Useful for a “fresh eyes” reviewer that applies industry standards rather than your project’s conventions:

---
name: fresh-eyes
description: Review code without project-specific biases
tools: [Read, Grep, Glob]
omitClaudeMd: true
effort: high
color: blue
---
Review this code purely from first principles. You have no project context. Focus on correctness, security, performance, and readability by industry standards.

criticalSystemReminder_EXPERIMENTAL is a short message re-injected at every turn as a system reminder. Even after conversation compaction, this stays in context:

---
name: prod-deployer
description: Manages production deployments with strict safety checks
tools: [Bash, Read, Grep]
color: red
criticalSystemReminder_EXPERIMENTAL: "Always run migrations with --dry-run first. Never skip the staging verification step."
---

Warning: This field has EXPERIMENTAL in its actual name in the source code. Anthropic’s engineers consider it unstable. It works right now, but it could be removed or renamed in any release. Use it for nice-to-have safety reminders, don’t build critical infrastructure on it.

requiredMcpServers lists MCP server name patterns that must be configured. If the servers aren’t available, the agent won’t appear. Prevents agents from loading when their dependencies aren’t set up.

The auto-mode classifier accepts plain English

The autoMode field in settings.json configures what Anthropic internally calls the “YOLO Classifier.” This controls what gets auto-approved in auto mode:

{
  "autoMode": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm run *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Read",
      "Grep",
      "Glob"
    ],
    "soft_deny": [
      "Bash(git push *)",
      "Bash(rm *)",
      "Write(.env*)"
    ],
    "environment": [
      "NODE_ENV=development",
      "This is a local dev machine with no production database access",
      "All Docker containers use isolated networks",
      "The test suite is safe to run repeatedly, it uses a dedicated test database"
    ]
  }
}

allow patterns get auto-approved. soft_deny patterns always require confirmation. The environment array is the interesting one, it’s not patterns at all. These are plain English context strings the classifier reads to understand your setup. You can write “This project uses Docker, all commands run in containers” and the classifier factors that into its safety decisions for ambiguous commands.

Think of it like giving the classifier a briefing about your environment. The more specific you are, the better it makes decisions. “No production access” tells it to be less paranoid about destructive operations. “Test database is isolated” tells it running tests is always safe.

The learning loop toggles nobody documented

Two settings.json fields activate Claude Code’s self-improvement system:

{
  "autoMemoryEnabled": true,
  "autoDreamEnabled": true
}

autoMemoryEnabled makes Claude Code automatically extract durable memories from your sessions. After each conversation, a background agent pulls out things worth remembering, your preferences, your codebase patterns, decisions you made, and writes them to ~/.claude/projects/<path>/memory/ using the standard memory frontmatter format.

autoDreamEnabled activates background “dream” consolidation. Every 24 hours, if 5 or more sessions have accumulated, a background agent reviews past session transcripts and consolidates memories. It merges duplicates, resolves contradictions, converts relative dates to absolute, and prunes stale entries.

Together these create a compound learning loop: sessions produce memories, dreams consolidate memories, consolidated memories inform future sessions. Turn both on and after a few weeks you’ll notice Claude Code remembering your preferences, conventions, and common patterns without being told. It’s genuine learning from experience without any model retraining.

Magic Docs: the exact format

The source reveals the regex: /^#\s*MAGIC\s+DOC:\s*(.+)$/im. It must be an H1 heading, it’s case insensitive, and the next line can be italicized instructions (wrapped in _underscores_ or *asterisks*) that scope what the update agent focuses on:

# MAGIC DOC: API Endpoint Reference
_Only document public REST endpoints. Include method, path, request body, response schema, and auth requirements._

## Endpoints

(content auto-maintained by Claude Code)

Without the instruction line, the agent tries to update everything. With it, you tell it “only track public endpoints” or “focus on breaking changes” and it respects that. The update agent runs in the background and is restricted to editing only that specific file. Deleting the header stops tracking automatically.

The full permission rule syntax

The docs show basic examples like Bash(git *). The source reveals the complete pattern language:

Bash(npm *)              # wildcard after "npm "
Bash(git commit *)       # specific subcommand
Read(*.ts)               # file extension
Read(src/**/*.ts)        # recursive directory with extension
Write(src/**)            # recursive, all files
mcp__slack               # all tools on slack server
mcp__slack__*            # explicit wildcard (same effect)
mcp__slack__post_message # specific tool
Bash(npm:*)              # legacy colon prefix (word boundary)

* matches within boundaries like shell globbing. ** matches recursively through directories. MCP tool permissions use double underscores: mcp__<server>__<tool>. The if field in hooks uses this exact same syntax. No regex, just globs.

{
  "permissions": {
    "allow": [
      "Bash(npm *)", "Bash(git status)", "Bash(git diff *)",
      "Read(src/**)", "Read(tests/**)", "Grep", "Glob",
      "mcp__database__query"
    ],
    "deny": [
      "Bash(rm -rf *)", "Write(/etc/**)", "Write(.env*)",
      "mcp__slack__delete_*"
    ],
    "ask": [
      "Bash(git push *)", "Write(*.json)", "Write(*.lock)",
      "mcp__slack__post_message"
    ]
  }
}

context: fork and why your model choice matters

When you set context: fork on a skill, it runs as a background forked subagent. The source reveals that forks share the parent’s prompt cache through a typed contract called CacheSafeParams. All forks produce byte-identical API request prefixes to maximize cache hits.

The practical implication: if you set a different model on a forked skill, you break the cache. The parent conversation is on Opus, the fork is on Haiku, the prefixes diverge, cache miss, you pay full price. Either omit the model field or use model: inherit on forked skills to keep the cache working.

Use context: fork for heavy work: security scans, dependency analysis, documentation generation, test suite runs. The fork runs in the background and notifies you when done, keeping your main conversation responsive.

---
name: full-audit
description: Comprehensive codebase audit running in the background
context: fork
allowed-tools: Bash, Read, Grep, Glob, WebSearch
effort: high
---
Run a comprehensive audit:
- Security scan (grep for dangerous patterns, check dependencies for CVEs)
- Code quality (duplicated logic, dead code, missing error handling)
- Test coverage (untested critical paths)
- Dependency health (outdated packages, unused deps, license issues)

Write a detailed report to /tmp/audit-report.md when complete.

Putting it all together

A self-improving code reviewer with persistent memory and scoped hooks:

.claude/agents/reviewer.md:

---
name: reviewer
description: Code reviewer that learns your codebase patterns over time
tools: [Read, Grep, Glob, Bash]
effort: high
color: yellow
memory: project
hooks:
  PostToolUse:
    - matcher: "Bash"
      hooks:
        - type: command
          command: "~/.claude/hooks/log-review.sh"
          async: true
---
Before reviewing, read your memory for past findings on this codebase.

Review git diff HEAD~1 for:
- Patterns you've flagged before (check memory)
- New issues worth flagging
- Resolved issues from past reviews

After review, save to memory:
- New patterns found (type: feedback)
- Recurring issues (type: project)

End with VERDICT: PASS, FAIL, or NEEDS_REVIEW.

This agent remembers what it found last time. It knows which patterns keep recurring. After a few reviews, it starts catching project-specific issues that a generic reviewer would miss.

A SessionStart hook with file watching plus an asyncRewake safety net:

settings.json:

{
  "hooks": {
    "SessionStart": [{
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/session-context.sh",
        "statusMessage": "Loading project context..."
      }]
    }],
    "PreToolUse": [{
      "matcher": "Bash",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/hooks/auto-approve-readonly.sh"
      }, {
        "type": "command",
        "command": "~/.claude/hooks/block-dangerous.sh",
        "asyncRewake": true,
        "statusMessage": "Safety check..."
      }]
    }]
  }
}

~/.claude/hooks/block-dangerous.sh:

#!/bin/bash
CMD=$(jq -r '.tool_input.command' < /dev/stdin)
echo "$CMD" | grep -qE '(rm -rf /|sudo rm|chmod 777|> /dev/)' && exit 2 || exit 0

Read-only commands get auto-approved instantly. Dangerous commands get blocked. Everything in between goes through normal permission flow. The safety scanner runs async so it doesn’t slow anything down on the happy path.

A skill with model override, effort control, and agent delegation:

---
name: architecture-review
description: Deep architecture review using max effort, delegated to fresh-eyes agent
agent: fresh-eyes
effort: max
---
Review the architecture of this project. Ignore existing conventions (the agent has omitClaudeMd: true).
Focus on: $ARGUMENTS

Evaluate structural decisions, dependency graph health, separation of concerns, and scalability characteristics.

This chains three undocumented features: effort: max for deep thinking, agent delegation to a specific agent, and that agent uses omitClaudeMd: true for unbiased analysis.

These undocumented features reveal the gap between what Claude Code is today and what Anthropic is building it to become. The hooks system with event-specific response fields is a programmable middleware layer for AI tool use, more flexible than most CI/CD pipelines. Persistent agent memory creates AI specialists that accumulate genuine expertise across sessions. The dream consolidation system is learning from experience without model retraining. The auto-mode classifier accepts natural language descriptions of your environment to make safety decisions.

These aren’t hidden settings or easter eggs. They’re the scaffolding for persistent, learning, autonomous AI development environments, and they’re already functional in the npm package on your machine. The docs will probably catch up eventually, but if you want to build on the cutting edge of what Claude Code can actually do, the source code is where the real documentation lives.

I go into quite a bit of depth so buckle up, if you’re into Claude Code and AI you won’t want to miss any detail in this one!

Speculative execution, multi-agent swarms, a YOLO classifier, and the autonomous AI system Anthropic hasn’t shipped yet.

Anthropic ships Claude Code as an npm package, @anthropic-ai/claude-code. You install it, you run it, it’s on your machine. And like any npm package, it’s just JavaScript sitting in your node_modules folder, waiting to be read. Someone unpacked the bundled TypeScript source, and what fell out isn’t just a CLI tool. It’s the skeleton of an autonomous, self-improving AI system, most of which is sitting behind feature flags on your machine right now.

This is the same kind of analysis people have done with VS Code, Slack, Discord, basically any Electron or Node-based tool that ships as a bundle. You download publicly distributed software, you look at what’s inside. There’s nothing adversarial about it, it’s just reading code you already have on your disk.

So let’s pick this apart.

The codename is Tengu

Every analytics event in Claude Code is prefixed with tengu_. Every feature flag starts with tengu_. The internal codename for this project is Tengu, a creature from Japanese folklore known for being skilled and mischievous. Kind of fitting for an AI coding agent.

This isn’t just a cute naming choice, it tells you something about how Anthropic thinks about the product internally. Tengu is the identity of this thing across their infrastructure. When their engineers look at dashboards, they’re looking at tengu metrics. When they gate a feature, it’s behind a tengu flag. It’s the real name.

Claude Code literally dreams

This is the wildest one. Every 24 hours, if 5 or more sessions have accumulated since the last consolidation, Claude Code spawns a background forked agent that reviews your past sessions and consolidates what it learned. The code calls this “dreaming.”

It has a triple gate system (time gate, session gate, filesystem lock) and runs a 4-stage consolidation prompt: orient, gather, consolidate, prune. If the dream fails, the lock file rewinds so the next session retries. The dream agent’s edits are visible in a background tasks dialog (Shift+Down).

This is combined with an EXTRACT_MEMORIES system that runs at the end of each query loop as a fire-and-forget forked agent, pulling durable insights out of your conversation and writing them to ~/.claude/projects/<path>/memory/. It pre-injects a manifest of existing memories so the agent doesn’t rediscover what it already knows. The memory extraction agent is restricted to read-only bash, file reading, grep, glob, and can only write within the memory directory.

The /remember skill sits on top of this as a manual override. It reviews auto-extracted memories and proposes promotions across four layers: CLAUDE.md (project conventions for all contributors), CLAUDE.local.md (personal instructions for this user), team memory (org-wide knowledge), or keeping them in auto-memory as working notes. It identifies duplicates, outdated entries, and conflicts between layers, noting which is more recent. It presents all proposals before making changes and won’t modify files without explicit approval.

This is a genuine learning loop. Sessions produce memories, dreams consolidate memories, consolidated memories inform future sessions. The system improves from its own experience across sessions without any human feedback loop. That’s machine learning in the most classical sense, just happening at the application layer instead of the weights.

Speculative execution, or branch prediction for AI coding

Claude Code can pre-execute your next likely action while you’re still typing. After each response, a prompt suggestion runs speculatively in the background using a copy-on-write overlay filesystem (temp directory under ~/.claude/temp/speculation/<pid>/<id>). It stops at safety boundaries like file writes (unless in acceptEdits mode), non-read-only bash, or network tools.

When speculation completes, it automatically pipelines the next suggestion. If you accept, the clean messages are injected into your conversation. It tracks timeSavedMs per speculation and caps at 20 turns or 100 messages. The speculation uses identical cache parameters to the main conversation to hit prompt cache.

This is branch prediction for AI coding. The system is guessing what you’ll ask next and pre-computing the answer so it’s ready the instant you confirm. CPU architects have been doing this for decades, Anthropic is doing it at the agent layer.

Skillify lets Claude Code program itself

The /skillify command captures what you just did in a session and turns it into a reusable skill. It runs a 4-round interview: first it analyzes the session to identify what was performed, what tools were used, and where you corrected the AI. Second round names the skill, determines if it should run inline or as a forked subagent, and asks where to save it (repo-specific .claude/skills/ or personal ~/.claude/skills/). Third round breaks each step into success criteria, execution type, artifacts, human checkpoints, and rules. Fourth round confirms trigger phrases and gotchas.

The generated SKILL.md includes a when_to_use field that enables auto-invocation, so the skill fires automatically when trigger phrases appear in future prompts. Skills can create other skills. This is an AI that watches what it did, extracts the pattern, packages it, and uses it next time without being told.

Magic Docs maintain themselves

Files with a # MAGIC DOC: [title] header are automatically kept in sync with the codebase. When Claude Code reads a magic doc, it registers the file for background updates. After each assistant response, if no tool calls are active, a forked agent spawns to update all tracked magic docs using instructions from italicized text after the header (e.g., *Keep this focused on API changes*).

The agent can only use the file edit tool on that specific file. If you delete the file or remove the header, it auto-unregisters. Documentation that maintains itself. Every engineering team I’ve ever worked on has had docs that rot within weeks of being written. This is a direct answer to that problem.

Auto-mode is literally called “YOLO”

The permission system that lets Claude Code auto-approve tool calls without asking you every time? It’s internally called the “YOLO Classifier.” I’m not making this up, the file is yoloClassifier.ts and the dangerous pattern detection system is explicitly labeled “YOLO mode prevention.”

It works in three layers. First, a dangerous pattern detector strips overly broad permission rules like Bash(*) or python:* before the classifier even sees them. If you try to give Claude Code blanket permission to run any bash command, the system catches it and removes it. The LLM classifier then makes instant allow/deny decisions on whatever’s left.

The Anthropic-internal builds have extra dangerous patterns beyond what external users see. Things like kubectl, aws, gh api, curl, git, and coo, which appears to be their internal cluster launcher. So even Anthropic’s own engineers have guardrails preventing Claude Code from running wild on their infrastructure. The tool that builds AI has its own AI safety layer, which is, indeed, exactly what you’d want.

The verification agent is adversarial by design

There’s a built-in verification agent whose job description literally says “your job is NOT to confirm it works, it’s to try to break it.” It refuses to accept reading code and narrating tests as verification. Every single PASS step must have command output, and if a re-run doesn’t match, the report is rejected.

It has type-specific attack strategies: for frontend it launches dev servers and uses browser automation, for APIs it curls endpoints and tests error handling, for database migrations it runs up then down to test reversibility, for refactors it demands existing tests pass unchanged. It runs adversarial probes: concurrent create-if-not-exists to find duplicates, boundary values (0, -1, empty, MAX_INT, unicode), idempotency checks (same mutating request twice), orphan operations (reference non-existent IDs).

Final output must be VERDICT: PASS, VERDICT: FAIL, or VERDICT: PARTIAL. This is AI that’s been explicitly instructed to distrust other AI’s work.

Fork children get yelled at in XML

When Claude Code spawns a forked worker process, the child receives a directive wrapped in an XML tag that literally reads STOP. READ THIS FIRST. The directive tells the fork: “You are a forked worker process. You are NOT the main agent.” It explicitly forbids the child from spawning sub-agents, asking questions, or suggesting next steps. Output has to follow a structured format: Scope, Result, Key files, Files changed, Issues.

The engineering behind this is smart. All fork children are built to produce byte-identical API request prefixes up to the final directive, which maximizes prompt cache hits across parallel workers. The placeholder result text is the same for every child: “Fork started, processing in background.” Only the actual task directive differs. Anthropic pays for the prompt cache once and all parallel workers benefit from it.

The multi-agent swarm runs in your terminal

The swarm system has backends for tmux and iTerm2 as pane-based executors. Each agent runs in its own terminal pane, coordinated by the orchestrator. The coordinator gets a 370+ line system prompt teaching it how to decompose work, spawn workers, synthesize results, and do verification rather than just delegating and trusting.

The coordinator prompt contains a genuinely interesting constraint about multi-agent orchestration. Workers can’t see the coordinator’s conversation with the user, so every prompt must be self-contained. The prompt explicitly states: “you must understand findings before directing follow-up; never write ‘based on your findings.’” The coordinator must synthesize worker outputs into its own understanding before issuing new instructions. It can’t be a dumb router, it has to actually comprehend what workers discovered. The prompt teaches “choose continue vs. spawn”: continue a worker if its context overlaps with the next task, spawn fresh if the task is narrow, and always use fresh eyes for verification to avoid anchoring on failed approaches.

Workers communicate back via XML-wrapped <task-notification> messages. The coordinator can spawn them, stop them, or continue conversations with them via a SendMessage tool. The SendMessage tool supports multiple address schemes: teammate name for local communication, * for broadcast to all teammates, uds:<socket-path> for Unix Domain Socket to local peer processes, and bridge:<session-id> for cross-machine communication via Anthropic’s servers. Messages persist to ~/.claude/projects/<path>/.team/<teammate>/mailbox/. Cross-machine sends require explicit user consent.

Claude Code controls how hard the model thinks

There’s an effort system with four levels: low, medium, high, max. Only Opus 4.6 supports max effort. The mapping from numeric values: 0-50 is low, 51-85 is medium, 86-100 is high, 101+ is max. Default for Pro subscribers on Opus 4.6 is medium. Max effort doesn’t persist to settings.json for non-Anthropic users, it’s session-only.

There’s also a separate “ultrathink” keyword system where typing the word ultrathink in your prompt triggers enhanced reasoning, and the UI highlights it with rainbow color cycling via getRainbowColor(charIndex % RAINBOW_COLORS.length). The thinking system itself supports three modes: adaptive (no budget, uses native thinking), enabled with explicit token budget, and disabled. Budget is hard-capped at max_tokens - 1 per API constraint.

Quick reads get low effort, architectural decisions get max effort with ultrathink. This granularity means AI assistants can be always-on without being always-expensive, running in low-effort background mode until something important happens, then ramping up.

Prompt cache preservation is the architectural foundation

Everything in Claude Code is built around prompt cache optimization. There’s a CacheSafeParams type that carries the exact parameters needed to guarantee cache hits in forked agents: system prompt, user context, system context, tool use context, and fork context messages. If any of these change, the cache misses. A code comment warns: “Thinking config is part of the cache key.”

The entire forked agent system, dreams, memory extraction, magic docs, speculation, all of it is designed so that parallel workers share the parent’s prompt cache prefix. This is why fork children produce byte-identical API request prefixes. The prompt cache break detection system (promptCacheBreakDetection.ts) monitors cache effectiveness in real-time, flags drops greater than 5%, performs root cause analysis (model change? tool schema change? system prompt change?), and writes unified diffs to ~/.claude/temp/cache-break-*.diff for debugging.

They’re treating prompt cache hit rate as a primary engineering metric. When you’re running parallel agents that each consume millions of tokens, the difference between 90% and 50% cache hit rates is the difference between viable and bankrupt. This is the economic constraint shaping how AI agents are actually built.

The unreleased features behind flags

There are dozens of feature flags pointing to capabilities that aren’t publicly available yet.

ULTRAPLAN is a multi-agent planning system that runs via Claude Code Remote (CCR) on Anthropic’s web infrastructure. It has a 30-minute timeout, uses Opus 4.6 by default, and supports a “teleport” flow where the plan comes back to your local CLI for execution. Plan mode itself is being A/B tested with four experimental arms: Control (full context, recommended approach, critical file paths, verification steps), Trim (reduced prose), Cut (further reduced), and Cap (40-line hard limit). They’re scientifically testing how much planning detail actually helps versus hurts.

PROACTIVE is an autonomous agent mode where Claude can take initiative without waiting for prompts. KAIROS is a whole family of flags (KAIROS_BRIEF, KAIROS_CHANNELS, KAIROS_GITHUB_WEBHOOKS) pointing to a persistent assistant mode with channel support and GitHub webhook integration. Claude Code evolving from a CLI tool into something more like a persistent team member that watches your repos.

Teleport handles session transfer between environments. Grove mode is policy-based interaction. There’s a Backseat observer mode with a coaching classifier. And features called Undercover mode and Scratch mode that are referenced but whose purposes aren’t clear from the code alone.

The obfuscated flag names

Anthropic uses a naming convention for their feature flags that’s clearly designed to be opaque to outsiders. Instead of descriptive names like enable_multi_agent or new_voice_model, they use nature and object themed codenames. Things like amber_flint, slate_heron, copper_bridge, coral_fern, timber_lark, surreal_dali, birch_trellis, bramble_lintel.

Smart practice. If your feature flags are in client-side code, which they are via GrowthBook SDK, giving them descriptive names would basically publish your product roadmap. You can see tengu_cobalt_frost gates something, and from context clues it appears to be a Deepgram Nova 3 voice model, but that mapping requires reading the surrounding code carefully.

Token budgets reveal how the system thinks

The source code exposes the exact resource limits Claude Code operates within, and these numbers tell you a lot about the engineering tradeoffs.

Each tool result gets capped at 50,000 characters. Max tool result in tokens is 100,000, roughly 400KB. When you run multiple tools in parallel, the aggregate caps at 200,000 characters per message. The default max output tokens is 8,000, and the code has a comment explaining why, it’s a “slot-reservation optimization” because their p99 output is actually 4,911 tokens. They’re reserving just enough headroom above the 99th percentile to avoid wasting inference capacity. If a response overflows that budget, the system escalates once to 64,000 tokens and retries.

These aren’t arbitrary numbers. They’re the result of production data analysis, the engineering team measuring actual usage patterns and tuning accordingly.

Claude Code also uses cache_edit blocks in the Anthropic API to delete old tool results from the prompt cache without invalidating the cache hash. They can trim stale content (bash outputs, file reads, search results) while keeping the cache hit. The edits are “pinned” and re-sent in subsequent requests to maintain cache validity. This isn’t publicly documented in Anthropic’s API docs, it’s an internal mechanism for efficient context window management. This is how Claude Code stays fast in long sessions, surgically removing stale content without paying the re-caching cost.

The secret scanner that hides from itself

Claude Code has a built-in secret scanner that prevents credentials from leaking into shared team memory files. It uses curated gitleaks rules to detect AWS tokens (looking for the AKIA/ASIA prefix), GCP keys, OpenAI keys, GitHub PATs, Slack tokens, Stripe tokens, private key blocks, the works.

The clever part is how it handles its own key format. The Anthropic API key prefix, sk-ant-api, is assembled at runtime from separate string fragments so the literal byte sequence never appears in the published bundle. They’re hiding the detection pattern from the scanner’s own distribution. If the prefix appeared as a contiguous string in the source code, it would trigger the very scanner that’s supposed to detect it in user code.

The system prompt is ~15,000 tokens of carefully tuned instructions

The main system prompt lives in constants/prompts.ts and weighs in at approximately 14,902 tokens. It’s built dynamically from modular sections: introduction, system behavior, task execution, tool usage, tone guidelines, output efficiency, plus dynamic sections for memory, language, MCP instructions, and more.

Some specific instructions: Claude Code is told to “only use emojis if the user explicitly requests it,” to never use git push --force without explicit user request, to prefer editing existing files over creating new ones, and to “go straight to the point.” The git safety section mandates new commits over amends, specific file staging over git add -A, and never skipping hooks.

The prompt cache system marks most sections as cacheable, with an explicitly scary function name for the exception: DANGEROUS_uncachedSystemPromptSection. The override hierarchy goes coordinator > agent > custom > default, with an appendSystemPrompt that always gets added at the end regardless of mode, which is how CLAUDE.md files and memory stay in context.

There are 15+ bundled skills loaded at startup and a tool result repair system (ensureToolResultPairing()) that fixes five categories of broken message state: orphaned tool results, missing tool results, orphaned result blocks, duplicate tool_use IDs, and duplicate tool_result IDs. It synthesizes error blocks with placeholder content and runs after every message normalization. The conversation protocol self-heals from corruption.

25+ lifecycle hooks for full automation

The hooks system covers essentially every lifecycle event: pre/post tool execution, permission denied, notification, user prompt submission (can block or erase the prompt), session start/end, subagent start/stop, pre/post compact, permission requests, repo setup, teammate idle, task created/completed, MCP elicitation, config changes, CLAUDE.md loading, worktree create/remove, working directory change, and file watching.

Three execution modes: shell scripts (exit code 0 passes, 2 blocks), prompt hooks (Claude responds inline), and agent hooks (full subagent with tools). Plugins can register hooks via settings. This is the extension API, and it’s comprehensive.

The Agent SDK and daemon infrastructure

The public SDK (entrypoints/agentSdkTypes.ts) exposes forkSession() which creates a new conversation branch with a fresh UUID from any point in a session. There’s watchScheduledTasks() that yields fire/missed events from .claude/scheduled_tasks.json. And connectRemoteControl() holds a persistent WebSocket bridge connection to claude.ai from daemon processes. The SDK also exposes unstable_v2_createSession() and unstable_v2_resumeSession() for persistent multi-turn conversations.

The daemon mode supports up to 50 concurrent scheduled tasks with jitter to prevent thundering herd, filesystem locks to prevent double-firing, and automatic takeover when owning sessions crash. Background housekeeping fires automatically at startup: magic docs initialization, skill improvement, memory extraction, auto-dream setup, plugin auto-updates, and deep link protocol registration. On a 10-minute delay: old message and version cleanup. On a 24-hour recurring schedule for Anthropic-internal builds: npm cache cleanup.

Claude Code isn’t just a tool you run. It’s a platform you build on.

The telemetry is extensive

Claude Code tracks over 150 distinct event types through a dual-pipeline analytics system. Events go to both Datadog and a first-party logging service simultaneously. There’s event sampling configuration, batch processing, and PII-tagged metadata columns (prefixed with _PROTO_) that route to privileged BigQuery columns.

What gets tracked is comprehensive. Every tool invocation, every permission decision, voice recording events, session compaction, memory loading, auto-mode switches, MCP server connections, OAuth token refreshes. A killswitch flag called tengu_frond_boric can shut the analytics sink down entirely. The Datadog pipeline has an explicit allowlist of about 22 event types that get forwarded there, everything else only goes to the first-party logger.

Telemetry in developer tools isn’t unusual. But the granularity here is notable.

Connector text is an anti-distillation mechanism

The connector_text block type tracks attribution and provenance data from MCP connectors. The beta header is summarize-connector-text-2026-03-13 and it’s described as an “anti-distillation POC.” Connector text blocks are stripped from signature-bearing blocks when sharing transcripts and can be summarized server-side.

This appears to be an early mechanism for preventing AI-generated content from being used to train competing models, by embedding provenance metadata that can be detected and stripped. The AI equivalent of a watermark, sitting at the protocol layer.

Model pricing, straight from the source

The code contains a complete pricing table for all Claude models, defined as cost-per-million-tokens:

• Sonnet models (3.5, 3.7, 4, 4.5, 4.6): $3 input / $15 output

• Opus 4 and 4.1: $15 input / $75 output

• Opus 4.5 and 4.6 (standard): $5 input / $25 output

• Opus 4.6 fast mode: $30 input / $150 output

• Haiku 3.5: $0.80 input / $4 output

• Haiku 4.5: $1 input / $5 output

When you toggle /fast in Claude Code, you’re still using the same Opus 4.6 model, but the pricing jumps to 6x the standard rate. That $30/$150 per million tokens confirms that “fast mode” is a priority queue with faster output generation, not a different model. The code explicitly checks isFastModeEnabled() to determine which cost tier to apply.

Prompt caching multipliers: cache writes cost 1.25x the input token price, cache reads are roughly 10% of input cost. Web search requests are $0.01 each across all models.

Rate limits and the Max tier

Five rate limit window types: five_hour, seven_day, seven_day_opus, seven_day_sonnet, and overage. The Max subscription tier gets a 20x rate limit boost, keyed to rateLimitTier === "default_claude_max_20x". Enterprise and C4E subscriptions get custom policy limits fetched via API with 1-hour background polling and ETag caching. The overage system lets subscribers spend beyond their tier limit, OAuth only.

The integration surface

Voice input connects to Anthropic’s private voice_stream WebSocket endpoint, requiring OAuth and a Claude.ai subscription. The audio capture chain tries native C++ bindings first (CoreAudio on macOS, cpal on Linux/Windows), falls back to arecord or SoX, and lazy-loads on first voice keypress to avoid a 1-8 second initialization freeze. The tengu_cobalt_frost flag gates Deepgram Nova 3 as an alternative STT provider.

There’s a Chrome extension creating bi-directional communication between the CLI and Claude.ai in your browser, exposing itself as an MCP server. IDEs connect via .claudeide.lock files, with support for VSCode, IntelliJ, PyCharm, WebStorm, GoLand, CLion, RustRover, and Fleet. Settings sync across machines via background upload/download. Mid-conversation model switching is supported with automatic fallback when Opus is under high load.

The git worktree system (600+ lines) creates isolated repo copies for safe parallel work with strict path traversal prevention and sparse checkout for large repos.

The cyber risk instruction has named authors

A safety instruction in constants/cyberRiskInstruction.ts governs how Claude Code handles pentesting, CTF challenges, and defensive security work. The file lists specific Safeguards team members who wrote it (David Forsythe, Kyla Guru) and includes a note that it shouldn’t be modified without their approval. One of the few files in the codebase with that kind of ownership annotation.

FedStart means government deployments

References to claude.fedstart.com and claude-staging.fedstart.com appear as approved OAuth base URLs. FedStart is a compliance framework for deploying SaaS products in US government environments. Pointing the OAuth flow at an unapproved URL throws: “CLAUDE_CODE_CUSTOM_OAUTH_URL is not an approved endpoint.”

And yes, there’s a /buddy

The /buddy companion sprite only appears April 1-7, 2026 for external users (always on for Anthropic employees). It shows a rainbow-colored notification on startup with a 15-second timeout and includes hatching/spawning animations. It’s behind the BUDDY feature flag. This is shipping in the current build right now.

What’s hardcoded, and what isn’t

There are credentials embedded in the published code, but they’re all designed to be public. A Datadog client token (the pub prefix is Datadog’s convention for write-only client tokens). Three GrowthBook SDK keys for feature flag fetching. OAuth client IDs, public by definition in the OAuth spec. Staging infrastructure URLs under the ant.dev domain.

In remote CCR sessions, authentication uses session-ingress tokens (prefix sk-ant-si-). The token is read from /run/ccr/session_token at startup, then the file is immediately unlinked. The token stays heap-only. On Linux, prctl(PR_SET_DUMPABLE, 0) blocks ptrace heap scraping, preventing other processes from reading the token from memory. The upstream proxy runs on 127.0.0.1 with a NO_PROXY list that excludes anthropic.com and github.com to prevent MITM on auth traffic.

No private API keys, no AWS credentials, no database passwords, no user data. The Anthropic API key prefix is fragmented at build time to avoid appearing in the bundle. Their security practices on the things that actually matter are solid.

What this actually means

Half a million lines of TypeScript, and the picture that emerges isn’t a CLI tool with some cool features. It’s the foundation of something that hasn’t fully arrived yet but is clearly being built with intention.

The learning loop is the big one. Claude Code extracts memories from sessions, consolidates them during dreams, and feeds consolidated knowledge back into future sessions. Every developer who uses it long enough will have a version that understands their codebase, their patterns, their preferences. The implications for productivity are real, but so are the implications for dependence. When your AI knows your codebase better than you do, the relationship between developer and tool starts to look different.

Speculative execution means the AI is thinking ahead of you. Right now it pre-computes your likely next action while you’re still deciding what to do. The timeSavedMs metric tells you they’re optimizing for this explicitly. Eventually the speculation gets good enough that you’re just approving a stream of correct guesses. At that point you’re supervising, not coding.

Skillify is self-programming. An AI that watches what it just did, extracts the pattern, and packages it as a reusable skill is an AI that accumulates capabilities over time. Today it’s bounded, skills are markdown templates with tool restrictions. But the architecture is there for compound growth. Each skill makes the next session more capable. Each dream consolidation makes the memory layer richer. The system is designed to get better without anyone shipping a new model.

The coordinator insight is worth paying attention to. Workers can’t see the conversation, so the coordinator has to genuinely understand what they found before directing follow-up. It can’t be a dumb router. This is the template for how AI teams will work: hierarchical systems where intelligence concentrates at the coordination layer, not flat swarms where everyone sees everything. That’s also how human organizations work, which is either reassuring or unsettling depending on where you sit.

The verification agent is AI auditing AI. An adversarial agent whose entire purpose is to distrust the work of other agents and try to break it. When you have AI writing code and AI testing code, the human’s role shifts from implementer to judge. The VERDICT system is designed for human review of AI-vs-AI outcomes. That’s a workflow that barely exists yet in most organizations.

The cache architecture is the economic story underneath all of it. Everything, dreams, speculation, forked agents, multi-agent swarms, is built so that parallel workers share the parent’s prompt cache prefix. The CacheSafeParams type, the byte-identical prefixes, the cache break detection with diff output, these are the economic constraints shaping how AI agents are actually built. The companies that solve cache economics will be the ones that can afford to run persistent multi-agent AI at scale. The ones that don’t will burn through inference budgets so fast that autonomous agents remain a demo, not a product.

The effort system changes what’s economically possible. Being able to control how hard the model thinks (low through max, adaptive, ultrathink) means AI assistants can be always-on without being always-expensive. Low-effort background mode until something important happens, then ramp up. That’s the pattern for persistent AI that doesn’t bankrupt its operator.

What you’re running as a CLI tool today is the visible surface of something much larger. The infrastructure for autonomous, persistent, self-improving AI agents is already on your machine, waiting behind flags with names like amber_flint and surreal_dali. Claude Code dreams about your codebase while you sleep, pre-computes answers before you ask, programs its own capabilities, runs adversarial verification against its own work, and orchestrates multi-agent swarms across your terminal panes.

The question isn’t whether this kind of AI is coming. It’s sitting in your node_modules folder right now.

About 6% of Americans think the Moon landings were faked. That number’s been stable for decades. The conspiracy doesn’t survive because the evidence is weak. It survives because the experience is inaccessible. Nobody questions whether planes fly because millions of people board them every day. Only twelve humans ever walked on the Moon, and the last one did it in 1972. The conspiracy has an expiry date, and it’s the same date that permanent lunar habitation begins.

But the process that kills the conspiracy sets something much stranger in motion. Because we won’t just visit again. We’ll stay. And within a few generations of staying, the people born there physically won’t be able to come home.

That’s the part nobody’s really reckoning with yet.

The infrastructure is already being built

The return isn’t aspirational. NASA’s Artemis program and China’s International Lunar Research Station program are both targeting the lunar south pole for permanent infrastructure. The south pole specifically because permanently shadowed craters there contain water ice at concentrations between 0.3% and 5.6% by mass. Water splits into hydrogen and oxygen. Oxygen keeps people alive. Hydrogen and oxygen together make rocket propellant. A colony that produces its own propellant stops paying to lift fuel from Earth, and that changes the economics of everything.

The first outposts will look like Antarctic research stations, not science fiction. Prefabricated modules, inflatable pressure vessels, rotating specialist crews. Two problems dominate the engineering: power and construction.

Power first. A lunar night lasts 14 Earth days. Battery storage at that scale is impractical. The answer is nuclear fission, and in January 2026 NASA and the Department of Energy signed a memorandum of understanding to deploy a fission surface power system on the Moon by 2030. The target spec is 40 kilowatts continuous, under six metric tonnes, ten years without refueling. Without nuclear power you’re limited to the handful of ridges that get near-constant sunlight, and that’s a campsite, not a colony.

Construction second. Every kilogram shipped from Earth costs thousands of dollars. So you build with lunar regolith, the broken rock and dust covering the surface. ICON holds a $57.2 million NASA contract for its Olympus 3D printing system that extrudes melted regolith into ceramic structures. China’s Deep Space Exploration Laboratory has demonstrated 3D printing using actual lunar soil returned by Chang’E-5 as the sole building material, no Earth-sourced additives at all. The vision is robotic construction systems landing before humans arrive, printing radiation shielding, landing pads, and habitat structures from local dirt. The technology exists at lab scale. Making it work autonomously in vacuum across a 300C temperature swing is hard, but it’s engineering-hard, not physics-hard. That distinction matters because engineering problems yield to funding and iteration. Physics problems don’t care how much money you have.

What daily life actually looks like

Skip forward to a lunar settlement circa 2055. Not a city, not a dome, something more like an industrial mining town where the walls are the only thing between you and instant death.

The habitat is partially underground. Two meters of packed regolith reduces cosmic ray and solar particle radiation to Earth-comparable levels. The cheapest approach is building in shallow trenches or lava tubes, natural tunnels formed by ancient volcanic activity, some hundreds of meters wide, and piling regolith on top. Interior pressure runs at about 70 kPa, roughly equivalent to living at 2,400 meters altitude on Earth, a deliberate compromise that reduces structural stress and decompression risk.

Temperature management is a constant fight. The surface swings from +120C in sunlight to -170C in shadow. Habitats use multi-layer insulation, regolith thermal mass, and phase-change materials embedded in walls that passively buffer temperature swings by absorbing and releasing energy as they shift between solid and liquid states.

Food is partially local. Hydroponic chambers lit by LEDs powered by the reactor produce fresh vegetables and herbs. Caloric staples still get shipped from Earth in the early decades because full food self-sufficiency requires enormous growing area and nutrient cycling infrastructure that takes generations to establish. Water is everything, extracted from polar ice and recycled at above 98% efficiency, every drop cycling through drinking, washing, irrigation, humidity control, electrolysis for oxygen, and waste processing before being recovered.

Communication with Earth has a 2.6-second round-trip delay. Manageable for conversation, too slow for real-time remote control, which is why lunar operations need increasing autonomy.

The workday is resource extraction, system maintenance, and science. Leisure is constrained by space and mass but transformed by gravity. A person who jumps 30 centimeters on Earth clears nearly 2 meters on the Moon. Sports invented there will make no sense to anyone watching from Earth.

The psychological environment is something to consider. The settlement is a closed system. Everyone knows everyone. Privacy is limited. The view is magnificent but unchanging. The nearest help in a catastrophic failure is three days away by spacecraft. The psychological profile mirrors submarine crews and Antarctic winter-over teams: tolerance for confinement, ability to manage conflict in small groups, comfort with routine, resilience under chronic stress. Except submarines deploy for months. Lunar colonists live this way permanently.

The generation that can’t come home

Everything we know about reduced gravity and human bodies comes from decades of microgravity research on space stations plus the Apollo missions, where the longest surface stay was three days. In zero-g, bone density drops at 1-1.5% per month. Muscle mass can decrease 20% in a single month, strength by 30%. The heart shrinks. Fluid redistributes toward the head causing vision problems. The immune system weakens. All of this despite two-plus hours of daily exercise.

Lunar gravity at 0.16g isn’t zero. It provides some mechanical loading. But research strongly suggests it’s nowhere near enough to maintain Earth-normal function long-term. Partial gravity simulations in rodents show significant bone and muscle loss even at 0.16g. Space medicine researchers predict lunar gravity provides maybe 15-25% of the protective benefit of full Earth gravity.

For rotating astronauts on six-to-twelve-month tours, this is manageable. Exercise countermeasures mitigate the worst of it. You come home, rehabilitate, recover.

For permanent residents, the calculus changes. For people born there, it changes completely.

A human who develops from infancy in 1/6 gravity will have a fundamentally different body. Bone formation, muscle development, cardiovascular conditioning, vestibular calibration, neurological development... all of it responds to the gravitational environment during growth. The developing skeleton grows thicker and denser where mechanical stress demands it. In 1/6g the demand is dramatically reduced.

A lunar-born child will likely develop lighter bones, a smaller heart, lower blood pressure, different muscle mass distribution, and a vestibular system calibrated to an environment where “down” pulls with a fraction of terrestrial force. They may grow taller as the spine experiences less compression.

These aren’t diseases. They’re adaptations. The body optimizing for its environment.

But they create a one-way door.

A lunar-born adult visiting Earth would experience 1g as crushing. Bones adapted for 1/6 loading would fracture. A cardiovascular system sized for a fraction of Earth’s gravity would struggle to maintain blood flow to the brain while standing. Muscles developed for moving a body that effectively weighs 1/6 of its Earth-equivalent mass would be totally inadequate.

The first generation of lunar-born humans may be physically unable to visit Earth. This isn’t speculation, it’s direct extrapolation from known physiology. The only uncertainty is degree, not existence.

And once that door closes, everything changes.

When you can’t go home, you stop calling somewhere else home

Biological divergence across populations is measured in centuries and millennia. Speciation, meaning reproductive incompatibility, takes tens of thousands of years minimum. But phenotypic divergence, populations that look, move, and function differently, begins within a single generation.

Over centuries, if the lunar population breeds primarily within itself, several pressures act simultaneously. Selection favors enhanced DNA repair mechanisms against higher background radiation. Metabolically efficient musculoskeletal systems optimized for 1/6g replace heavy Earth-adapted bones that serve no purpose. Cardiovascular systems trend toward configurations built for lower gravitational loading. If habitats maintain slightly different atmospheric compositions, respiratory systems adapt.

None of these individually constitute speciation. Cumulatively over centuries they produce human populations that are recognizably different from Earth humans. Taller, leaner, lighter-boned, with different cardiovascular parameters and different radiation tolerance. Still human, but a different kind of human.

Cultural divergence happens much faster.

Lunar residents will share an experience no Earth human has ever had, living where the habitat is the only thing between you and vacuum. Step outside without a suit and you have roughly 15 seconds of useful consciousness. This shapes everything about how a society organizes itself.

Collective responsibility becomes non-negotiable. On Earth, individualism works because the environment is forgiving. One person’s recklessness rarely kills a community. On the Moon, one person damaging a seal or contaminating the water supply can kill everyone. This produces a fundamentally different relationship between individual freedom and collective obligation, something closer to a submarine crew’s culture, except permanent.

Resource consciousness becomes instinctive. Every liter of water, every watt of power, every gram of food has a known finite cost. Waste is an existential threat. Conspicuous consumption becomes incomprehensible rather than just wasteful.

Language drifts. Isolated populations develop distinct vocabularies and dialects within decades. Lunar colonists will coin words for experiences that have no Earth equivalent, the particular quality of motion in 1/6 gravity, the visual experience of Earth in the sky. Within a few generations “Lunar English” or whatever the dominant settlement language is will be a recognizable variant. Art and music transform. Sound behaves differently in a pressurized habitat. Dance in 1/6 gravity is an entirely new art form. Sports invented on the Moon export back to Earth as incomprehensible spectacles.

And at some point, likely within the first generation born there, identity crystallizes. These people won’t think of themselves as Americans or Chinese or Europeans who happen to live on the Moon. They’ll think of themselves as lunar. That identity will carry shared experience, shared values, shared risk, and increasingly shared biology.

It’ll also carry resentment. And resentment is where it gets political.

The sovereignty question

Colonial resentment follows a trajectory so consistent across human history that you can set your watch by it. The colony is established by and for the home country. The colony develops its own structures. The home country continues governing in its own interest. Colonial residents perceive that governance as ignorant, exploitative, illegitimate. The colony demands autonomy.

There’s no reason a lunar colony would be exempt from this pattern. Distance amplifies everything, Earth governors making lunar policy will never have experienced the Moon. They won’t understand the constraints, the culture, the daily reality. Their decisions will be perceived, often correctly, as uninformed and self-serving.

The legal framework is already fracturing before permanent settlement begins.

The Outer Space Treaty of 1967 says outer space “is not subject to national appropriation by claim of sovereignty, by means of use or occupation, or by any other means.” Clear enough. But it was written when the Moon was a destination for brief government science missions, not a place where people live, work, raise families, and extract commercially valuable resources.

The Artemis Accords, signed by over 30 nations, already establish “safety zones” around lunar operations. Explicitly not sovereignty claims. But in practice they function as exclusive operational areas where one nation’s activities take priority. The gap between “safety zone” and “territorial claim” gets thinner every year those zones stay occupied and nobody challenges them. The US legalized space mining under domestic law in 2015. China enacted similar provisions. Neither ratified the Moon Agreement of 1979 that tried to declare lunar resources the “common heritage of mankind.” The treaties saying nobody owns the Moon were written when nobody could own the Moon. Now that owning pieces of it is becoming practical, the treaties are being quietly worked around.

Independence movements come down to a simple equation: costs of remaining under external governance versus benefits. For a young lunar colony dependent on Earth for food, parts, and personnel, independence is suicide. You need Earth. You have no leverage.

Self-sufficiency flips that equation.

If the colony produces its own food, water, oxygen, power, and construction materials... if it manufactures critical components locally... if it generates economic value exceeding its imports (propellant production, He-3 mining, scientific output), then the dependency inverts. Earth needs the colony’s output. The colony no longer needs Earth. That’s the inflection point, and every colonial independence movement in history has an equivalent moment where the colony realizes the home country needs them more than they need the home country.

The most interesting wrinkle is that lunar independence might not involve a single colonial power. If the Moon hosts settlements from the US, China, the EU, and private corporations simultaneously, the independence movement could unite disparate settlements against all their respective home countries at once. A unified lunar polity from multi-national origins, forged by shared environment rather than shared nationality. That would actually be unprecedented in human history.

What we don’t know

The biggest unknown could break the entire thesis: nobody knows if human reproduction works in 1/6 gravity. No mammal has ever been conceived, gestated, and born in reduced gravity. If humans can’t reproduce on the Moon, everything from the biology section onward collapses. No lunar-born generation, no divergence, no distinct identity, just rotating Earth visitors. This is the most important question in the entire colonization discussion and we have zero data on it.

The ISRU scaling gap is real. Lab demonstrations and autonomous industrial-scale lunar operations are separated by an engineering chasm that could take decades to close. Closed-loop life support for decades is unproven. Multi-generational psychology in permanent confinement is completely uncharted. Political will across decades of changing governments is never guaranteed.

The honest read is that lunar colonization is physically possible, technologically plausible this century, and consistent with every pattern of human expansion on record. Whether it happens depends on economics, politics, and answering unknowns we haven’t even designed the experiments for yet.

But we always do it. Every time we can, we do. The conspiracy theorists who say we never went have the story exactly backwards. The Moon landings weren’t the end of anything. They were the first sentence of a story that ends with humanity becoming something the people who watched Apollo 11 could never have imagined.

We went. We’ll go back. We’ll stay. And staying will change what it means to be us.

As of March 26th 2026, the United States has ordered elements of the 82nd Airborne Division, roughly 1,000 soldiers including division commander Maj. Gen. Brandon Tegtmeier and his headquarters staff, to deploy to the Middle East. Two Marine Expeditionary Units are already moving toward the Persian Gulf, carrying several thousand Marines along with amphibious warships, aviation assets and landing craft. Combined, that puts somewhere between 6,000 and 8,000 US ground troops in close proximity to Iran.

The Pentagon says this is hypothetical. Nobody is calling it a ground invasion. But when you deploy a division-level command element alongside two MEUs into an active theatre where the primary target has already been bombed and the enemy has rejected your ceasefire terms... that’s pre-positioning. The White House describes ground operations as “hypothetical” while simultaneously deploying the exact force structure you’d need to execute them.

This piece is an assessment of what’s coming, what it’s likely to look like, and why every scenario ends with the US deeper in the Middle East than at any point since 2003. I’m putting rough probabilities on each outcome because vague analysis is useless when the decisions are being made this week.

440.9 Kilograms

The whole war traces back to one number.

That’s how much uranium enriched to 60% purity the IAEA estimates Iran had before the June 2025 strikes. At 60%, roughly 99% of the enrichment work is already done, the step to weapons-grade 90% is short. According to the IAEA’s own calculations, that stockpile could produce fuel for approximately nine nuclear weapons. A single cascade of 175 IR-6 centrifuges could produce enough weapons-grade material for one bomb every 25 days.

The problem is nobody knows where all of it is, and nobody can verify its status. IAEA chief Rafael Grossi says about 200kg was stored in a tunnel complex at Isfahan, and the agency believes it’s probably still there based on satellite imagery showing the tunnels were largely undamaged by last June’s strikes. But the IAEA hasn’t had access to any of Iran’s four declared enrichment facilities for over eight months. Iran sealed two of the three tunnel entrances at Isfahan with massive earth barriers. The third was reinforced with protective walls designed to stop cruise missiles.

A New York Times report from earlier this month found that US intelligence agencies believe there’s now a “very narrow access point” through which the uranium could potentially be retrieved. If the material is accessible it can be moved, and if it can be moved it can be weaponised. The Pentagon has prepared plans for ground operations deep inside Iran to secure it, according to Axios. The alternative is large-scale air strikes to bury it permanently, but nobody can confirm that would work.

Both Tel Aviv and Washington have listed ending Iran’s nuclear capability as a primary war aim. The uranium is the one piece that conventional strikes can’t cleanly resolve, and it’s the reason we’re talking about ground troops at all.

Kharg Island: 90% of Everything

The most likely ground operation isn’t a march on Tehran. It’s the seizure of Kharg Island, a 5-mile strip of land in the northern Persian Gulf that handles 90% of Iran’s crude oil exports. Trump has called it Iran’s “crown jewel” and the US hit 90 targets there on March 13th, striking naval mine storage, missile bunkers, and military sites while deliberately avoiding the oil infrastructure.

The logic is coercive rather than destructive. Seize Kharg and you remove Iran’s ability to export oil, which cuts the regime’s primary revenue stream and creates pressure to force the Strait of Hormuz back open. Pipeline networks from Iran’s major onshore oil fields terminate at Kharg, so controlling the island severs the final link between production and international markets without requiring deep strikes into the Iranian mainland. Deep surrounding waters allow supertankers to dock directly, meaning short-term disruption would produce immediate effects on global supply.

The operational concept, based on reporting from CNN, Stars and Stripes, and multiple military analysts, would work in phases. Marines from the MEUs conduct the initial amphibious assault, securing beachheads and key terrain. Marine combat engineers repair damaged airfields. Once the lodgement is secure, 82nd Airborne elements reinforce by air, flying in via Ospreys and helicopters. Retired Admiral James Stavridis, former NATO Supreme Allied Commander, outlined this sequence in a Bloomberg op-ed, noting that Iranian ground forces remaining after pre-assault strikes should be “easily overcome” by the first waves.

That assumes things go to plan, and things almost never go to plan.

What the Optimists Are Missing

Iran knows Kharg is a target and has been preparing. CNN reported that US intelligence shows Iran has been laying traps across the island, moving additional military personnel, and deploying MANPAD shoulder-fired missile systems. Existing defences include HAWK surface-to-air missiles and Oerlikon anti-aircraft guns, though US strikes have degraded some of these. Central Command has near-constant satellite surveillance and has been watching physical and environmental changes in areas that appear booby-trapped.

Retired Lt. Col. Daniel Davis at Defense Priorities made the force size point clearly: the deployment is “not sufficient for a major invasion nor to hold a single city” and signals “limited/targeted ops only.” The 82nd Airborne is an immediate reaction force, built for speed and surprise, not sustained occupation. It seizes things quickly and then needs something bigger behind it.

But the real problem isn’t taking Kharg, it’s what happens after. An Israeli source told CNN there’s concern that seizing the island triggers attacks by Iranian drones and shoulder-fired missiles resulting in American casualties. Gulf allies are privately urging Washington against the operation, warning it would provoke Iranian retaliation against their infrastructure and prolong the conflict.

That concern is grounded in precedent. In 2019, drone and cruise missile strikes hit Saudi Aramco’s Abqaiq facility and knocked out 5.7 million barrels per day of Saudi output, roughly half their production, in a single peacetime attack. Now imagine that capability deployed against Ras Tanura, Jubail, or Qatar’s LNG terminals during an active war where Iran has nothing left to lose. Iran’s parliamentary speaker, Mohammad Bagher Ghalibaf, already warned on X that “all the vital infrastructure of that regional country will be targeted without limitation.”

Then there’s China. Nearly 38% of crude flowing through Hormuz goes to China. If the US seizes the island that handles 90% of Iranian exports, China doesn’t just lose a supplier, it watches Washington physically control a chokepoint in its energy supply chain. Beijing hasn’t intervened militarily but China’s top diplomat Wang Yi has already told Iran that “talking is always better than fighting.” A Kharg seizure would test how far China’s restraint extends.

The Human Cost Nobody is Counting

Twenty-seven days in, the numbers are staggering and incomplete.

Al Jazeera’s live tracker puts Iranian deaths at 1,937 as of March 26th. The human rights organisation Hengaw, which has been documenting casualties through field sources across Iran, puts the total at over 6,500 killed in 25 days, including at least 640 civilians. HRANA, another rights group, confirmed 1,407 civilian deaths in the first three weeks including 214 children. Iran’s own health ministry reported roughly 210 children killed and more than 1,500 under-18s injured. Over 300 health and emergency facilities have been damaged.

Thirteen US service members have died. Around 200 more have been wounded. In Lebanon, where Israel launched a ground invasion on March 17th, at least 1,072 people have been killed and 2,966 wounded. At least 25 people have been killed across Gulf states from Iranian retaliatory strikes.

The UN human rights chief has said that US and Israeli strikes are hitting homes, hospitals, schools, and cultural sites. Hengaw documented that Iranian military forces have relocated into civilian spaces including schools and mosques, placing civilians at direct risk. The UN estimates the war has caused $63 billion in economic losses across the Arab region. Cities across Iran have become ghost towns. Schools are closed. Prisoners in Evin Prison are reportedly receiving limited bread and water.

These numbers will continue to climb regardless of which military option the Pentagon chooses, and a ground operation on Kharg would add American names to the casualty lists.

The Diplomatic Situation is Worse Than It Looks

While the Pentagon pre-positions ground forces, the White House insists productive talks are happening. Iran says there are no talks and calls the claim a ruse for military planning. The reality appears to be somewhere between: Iran responded to a 15-point US proposal through unnamed intermediaries (Pakistan, according to Pakistani officials) and is awaiting Washington’s reply, according to Iran’s Tasnim news agency. But Iran’s Foreign Minister Araghchi also said Tehran will continue its “resistance” and does not intend to negotiate while being bombed.

Iran’s five conditions for a ceasefire: end to aggression, concrete guarantees against future war, war reparations, a comprehensive end across all fronts including against Hezbollah and Houthis, and recognition of Iranian sovereignty over the Strait of Hormuz.

The gap between these positions is enormous. The US wants the nuclear programme gone and Hormuz reopened. Iran wants reparations and sovereignty guarantees. Pakistan, Egypt, and Turkey are trying to organise direct talks. The IRGC is reportedly deeply sceptical. Meanwhile, Israel’s UN Ambassador said Israel isn’t even part of the US-Iran talks and that military operations will continue until Iran’s nuclear and missile capabilities are eliminated.

Congress doesn’t know the plan. House Armed Services Chairman Mike Rogers emerged from a classified briefing Wednesday saying “We’re just not getting enough answers.” Senate Armed Services Chairman Roger Wicker agreed. When Congress can’t get clarity, the plan is still being written, or the plan is to not have a plan.

How This Plays Out

Based on everything reported, here are the scenarios and my rough probability estimates:

Expanded air strikes on Iranian power plants and energy infrastructure (next 7-10 days): 70%. Trump already threatened this and Iran has already promised massive retaliation across the Gulf in response. This is the most likely next escalation step and it would intensify the humanitarian crisis dramatically while probably not reopening Hormuz.

Kharg Island seizure (within 2-4 weeks if diplomacy stalls): 40%. The force structure is being assembled for exactly this operation. Gulf allies are pushing against it. The risk of American casualties and Iranian retaliation against Gulf infrastructure is high. But if the strait stays closed and there’s no diplomatic breakthrough, the pressure to “do something” will be immense and Kharg is the obvious target.

Isfahan uranium ground operation: 10-15%. This is far more complex and dangerous than Kharg, requiring sustained ground presence deep inside Iran that the current force can’t support. More likely the US relies on further air strikes to deny access permanently rather than attempting to physically secure the material. But it remains on the table according to Axios, and the unaccounted uranium is the one variable that could push decision-makers toward extreme options.

Full-scale land invasion of mainland Iran: under 5%. Every military expert quoted says the force is too small, the terrain is too hostile, and the precedent (Afghanistan, Iraq) is too recent. Iran has 90 million people and is half mountainous. The 82nd Airborne’s motto is “All the Way” but even the Pentagon knows where “all the way” ends in a country three times the size of Afghanistan.

Diplomatic resolution within 30 days: 15-20%. Both sides have back-channel communication through Pakistan. Iran’s foreign minister offered to downblend enriched uranium on CBS. The outline of a deal exists. But mutual distrust, the IRGC’s scepticism, and the fact that Israel is operating independently of US diplomatic efforts all work against it.

The Iraq Question

Every military expert quoted in the reporting makes the same caveat: this force is built for targeted, short-duration missions. The assumption is go in, seize Kharg, maybe deny the uranium, use the pressure to force a deal.

That assumption requires Iran to respond rationally to the seizure of its most valuable economic asset while being bombed. Minimal US casualties are baked into the plan, which the booby trapping and MANPAD deployments suggest won’t happen. Gulf allies would need to absorb Iranian retaliation without demanding the US withdraw. China would have to watch its energy supply be physically seized without responding. And Trump would need to resist expanding the operation once troops are committed and the news cycle is running.

The country that spent twenty years in Afghanistan and left with nothing to show for it is now contemplating ground operations in a country three times the size, with a population three times as large, far more sophisticated military capability, and terrain that favours guerrilla warfare at every turn. Military analyst Michael Eisenstadt has already warned that Iran could shift to hit-and-run tactics that significantly increase US casualties.

56% of Americans already oppose this war according to an NPR/PBS/Marist poll, and the first ground troops haven’t even landed yet. The US has spent roughly $16.5 billion in the first 12 days alone according to CSIS estimates. The decisions being made this week, about Kharg, about the uranium, about how deep to go, will determine whether this war lasts weeks or years.

Nobody in Washington seems to be asking the question that matters: what does “winning” look like, and is it worth what it costs to get there?

For real-time geopolitical risk analysis and forecasting on the Iran war, Hormuz crisis, and escalation scenarios, visit NexusHQ.

Disclosure: the author holds positions in energy and commodities that may be affected by the events described in this article.

The Spice Must Flow: What Dune Gets Right About the Oil Crisis Happening Right Now

Frank Herbert wrote Dune in 1965, and most people think he wrote a science fiction novel about a chosen one, a desert planet, and giant sandworms. He wrote a geopolitical manual disguised as a hero’s journey. And right now, sixty years later, his nightmare scenario is playing out in real time.

On February 28th 2026, the United States and Israel launched coordinated strikes on Iran, including the assassination of Supreme Leader Ali Khamenei. Iran’s response was to do the one thing that every energy analyst has warned about for decades... close the Strait of Hormuz. Tanker traffic dropped 70% overnight. Brent crude blew past $100 a barrel for the first time in four years, peaking at $126. The IEA called it the greatest global energy security challenge in history. Sri Lanka moved to a four-day work week to conserve fuel. Hundreds of tankers sat idle on both sides of the strait, going nowhere.

If you’ve read Dune, actually read it, not just watched the Villeneuve films, you’ve seen this before. Herbert didn’t imagine a fictional universe, he reverse-engineered ours.

To be clear, I’m not saying Herbert was a prophet or that Dune is a prediction. What I’m saying is that Herbert identified the structural logic of resource chokepoint warfare in 1965, and that logic is now playing out with eerie precision. The parallels aren’t coincidence, they’re the result of a novelist who understood systems better than most analysts.

Arrakis is the Middle East. Spice is oil. The Fremen are Iran, and as of mid-March 2026, the jihad is underway.

The Chokepoint That Runs the World

The entire economy of Herbert’s universe runs on a single substance, spice melange, found on a single planet. Control Arrakis and you control interstellar travel, commerce, everything. The great houses, the Emperor, the Spacing Guild, they all orbit the same dependency. No spice, no civilisation.

The Strait of Hormuz is the real-world Arrakis. About 20 million barrels of oil pass through it every day, roughly 20% of global petroleum consumption. Saudi Arabia and the UAE have pipeline infrastructure that can bypass the strait, but total bypass capacity sits at roughly 2.6 million barrels per day, about 13% of normal flows. It’s a band-aid on a severed artery. Around 84% of the crude flowing through the strait heads to Asian markets, with China alone receiving nearly 38% of total flows. Add in about a fifth of global LNG trade and you start to understand why one narrow corridor between Iran and Oman basically holds the global economy hostage.

Herbert understood something that most people still don’t, and that policymakers clearly didn’t understand when they launched strikes on February 28th. You don’t need to be the most powerful player in the system, you don’t need the biggest fleet or the most advanced technology. You just need to sit on the chokepoint and be willing to threaten the flow. The Fremen didn’t have a space fleet. Iran doesn’t need aircraft carriers.

The IRGC’s statement from earlier this month put it in terms Herbert would have recognised instantly... “You will not be able to artificially lower the price of oil.”

The spice must flow, and that line reads very differently in March 2026 than it did in 1965. We just found out what happens when someone calls the bluff.

Iran as the Fremen

The Fremen have lived on Arrakis for generations, surviving in conditions that would kill anyone else. Every imperial power that tried to control the planet either failed or relied on brutality to maintain a fragile grip. The Harkonnens ruled through fear and extraction, the Emperor used them as a counterweight, and nobody really bothered to understand the Fremen as anything other than a nuisance... a primitive people sitting on top of something valuable.

Iran has occupied the northern shore of Hormuz for millennia. Western powers have spent the better part of a century treating the region as a resource to be managed, a chessboard where the pieces don’t get a vote. The asymmetric military capability Iran has built, fast attack boats, anti-ship missiles, drone swarms, mine warfare, is the modern equivalent of Fremen desert warfare. It doesn’t look impressive on paper next to a US carrier group, just like crysknife-wielding guerrillas don’t look impressive next to Sardaukar legions. But we just watched more than 20 confirmed attacks on merchant ships in under two weeks. The home team knows the terrain.

Herbert went deeper than just military asymmetry though. He invented the Missionaria Protectiva, a programme run by the Bene Gesserit to plant messianic prophecies among populations across the universe, decades or centuries before anyone would need to exploit them. The whole point was to seed narratives strategically, plant beliefs that could be harvested later by whoever needed them. Which is indeed the history of Western interference in Iran.

In 1953, the CIA and MI6 orchestrated a coup against Iran’s democratically elected Prime Minister, Mohammad Mosaddegh, over oil nationalisation. They installed the Shah, a Western-friendly autocrat who modernised the surface while brutalising the population underneath. For twenty-six years Western powers thought they had it managed, they’d installed their chosen one, redirected the resources, planted their narrative. Then 1979 happened, and the revolutionary energy that had been building for decades erupted in a way that nobody in Washington or London anticipated. The West’s Missionaria Protectiva blew up in its face.

Now the Fremen parallel does break down in important ways, and acknowledging that makes the real situation scarier. The Fremen were stateless, factionally united, and had zero power projection beyond Arrakis. Iran is a nation-state with formal institutions, diplomatic relationships, internal factions (reformists, hardliners, IRGC), a population that has staged multiple uprisings against its own government, and a regional proxy network that extends across the entire Middle East. We’ve just watched Houthi, Hezbollah, and Iraqi militia elements all activate simultaneously. The Fremen needed Paul to unleash their power. Iran has been projecting power independently for decades, and the network is already live.

The Jihad Is Not a Metaphor Anymore

This is the part of Dune that most fans either miss or just misunderstand, and it’s the part that should keep you up at night given what’s happening right now.

Paul Atreides has prescient visions that show him every possible path forward, and on almost every one, a galactic jihad is waiting. Billions dead, worlds burned, entire civilisations wiped out in a holy war fought in his name that consumes everything it touches. He spends the entire story trying to find the narrow path that avoids it while still saving himself and the people he loves, and he can’t. The messianic energy he’s riding, the Fremen belief in the Lisan al-Gaib, the momentum of a people oppressed for generations who finally have a leader promising liberation... it’s bigger than him. Once it’s unleashed, it has its own logic and its own hunger.

There’s no clean Paul equivalent in the real world, and that’s actually the point. The escalation dynamic doesn’t need a charismatic chosen one to trigger it. The system was primed. Multiple actors, the US, Iran, Israel, Saudi Arabia, and China as the single largest recipient of oil through the strait, all making moves that constrained each other’s options. Nobody needed to be Paul. The structural conditions generated the nightmare on their own.

We had a preview with the Houthis, and we should have paid more attention. From late 2023, Houthi attacks on Red Sea shipping disrupted roughly $1 trillion in goods over seven months. Container ship transits through the Suez Canal dropped 90%. Freight rates between Shanghai and Rotterdam jumped 80%, adding an extra $15-20 billion in annual costs to global trade. And that was a proxy action, not even a direct Iranian operation.

And then there was Abqaiq in 2019, which nobody took seriously enough. Drone and cruise missile strikes hit Saudi Aramco’s processing facility and the Khurais oil field, knocking out roughly 5.7 million barrels per day, more than half of Saudi output. Oil prices spiked 15% overnight. That happened during peacetime, with no military confrontation, and it showed exactly how vulnerable concentrated energy infrastructure really is.

Those were the tremors before the earthquake. The jihad Paul saw coming, the one he couldn’t prevent because the momentum was already too great... that’s what started on February 28th. The IRGC broadcasting that ship passages through Hormuz are “not allowed.” Brent crude at $126. The IEA’s emergency reserve release of 400 million barrels, which sounds massive until you realise it covers about 20 days of normal Hormuz flows or four days of global consumption. Sri Lanka rationing fuel. Japan releasing its own reserves because 70% of its oil imports come through the strait.

Paul’s lesson, the one Herbert was trying to teach, is that escalatory systems don’t respect anyone’s intention to keep things “limited.” Nobody gets to decide this stays contained.

The Family Atomics

Most people skip over the family atomics when they talk about Dune parallels, and it might be the most important one.

House Atreides possesses nuclear weapons, the family atomics. Paul uses them, deploying the atomics to blast open the Shield Wall and allow his Fremen forces to attack Arrakeen. It works tactically, but it crosses a line that changes everything about the political order. The atomics were a deterrent until they weren’t. Once used, the rules of the game changed permanently.

Iran’s nuclear programme follows the same logic. A capability that hasn’t been fully weaponised but fundamentally reshapes the strategic calculus just by existing. And the current escalation is exactly the kind of pressure that could push Iran from threshold capability toward actual weaponisation, or worse. If the strikes that killed Khamenei were meant to weaken Iran’s resolve, the early evidence suggests they’ve done the opposite. Mojtaba Khamenei, the new Supreme Leader, vowed to keep the strait closed. The IRGC warned of $200 oil.

Paul used the atomics because the cost of not using them was extinction. Iran is making the same calculation with Hormuz, the closure isn’t aggression for its own sake, it’s existential leverage because the alternative is absorbing strikes without response and accepting regime destruction. When the choice is between crossing the line and ceasing to exist, the line gets crossed, and Paul knew it, and Iran knows it now.

Paul Wins, Everyone Loses

Paul defeats the Harkonnens, overthrows the Emperor, takes the throne, unites the Fremen and leads them to absolute victory. And the jihad happens anyway, his Fremen armies sweeping across the known universe, killing billions in his name. Paul sits on the throne of the galaxy and watches it happen. He set it in motion and he can’t stop it.

Herbert wasn’t writing a triumph, he was writing a tragedy. The whole point was to demolish the myth of the clean victory, the idea that you can wield enormous destructive force in pursuit of a strategic objective and somehow contain the consequences.

We’re watching the real-world version unfold in real time. Coalition strikes hit more than 90 targets on Kharg Island, the strait closed, oil hit $126, Iraq and Kuwait started shutting in production because they had nowhere to send it, refineries across the Gulf shuttered. The spare capacity that OPEC normally uses to stabilise markets is physically trapped on the wrong side of the chokepoint. The G7 scrambled for an emergency call. And the cascade is still going... energy prices driving up food costs, which drives inflation, which drives political instability in import-dependent developing economies.

Herbert made the jihad death toll obscene on purpose, billions dead across the known universe. He wanted you to understand that “winning” can be the worst possible outcome. The Harkonnens lost, the Emperor lost, but the Fremen victory was indistinguishable from catastrophe.

Right now, nobody is winning at Hormuz, and Herbert would tell you that’s exactly how it was always going to go.

Herbert Was Writing a Risk Assessment

Frank Herbert didn’t predict Iran, or Hormuz, or the specific events of February 2026. What he nailed was the underlying logic, and the logic is airtight.

Systems built on single points of failure are inherently fragile, and they don’t become less fragile just because everyone agrees the resource is important. Populations sitting on strategic chokepoints will eventually use that position, regardless of how many times outside powers dismiss them as manageable. Revolutionary movements, once set in motion, obey their own dynamics... they can’t be controlled by the people who think they’re in charge. And the myth of the surgical, contained, controllable use of overwhelming force is just that, a myth.

The obvious counter-argument is that Dune’s universe had no spice alternative, and the real world does. Renewables, nuclear, electrification, they’re all accelerating. But that transition is measured in decades, not weeks, and the crisis is happening now. Global infrastructure is still locked into oil dependency, supply chains still run on diesel, petrochemicals still underpin everything from fertiliser to plastics, and the 20 million barrels a day that normally flow through Hormuz don’t have a green substitute waiting in the wings. Herbert’s lesson holds for as long as the dependency holds, and in March 2026, the dependency is total.

Herbert published Dune in 1965. He looked at oil, the Middle East, the resource dependency, the messianic cultures, the imperial arrogance, and he wrote a 500-page warning. We turned it into a blockbuster, bought the popcorn, admired the sandworms, and learned nothing.

The spice must flow, and right now it isn’t, and nobody who actually read the book should be surprised.

For real-time geopolitical risk analysis and forecasting on the Hormuz crisis, energy supply disruption, and escalation scenarios, visit NexusHQ.

Disclosure: the author holds positions in energy and commodities aligned to the thesis described in this article.

A NexusHQ Strategic Intelligence Briefing on Nuclear Escalation Risk in the Israel-Iran Conflict

Classification: Open Source Intelligence Assessment Date: 21 March 2026 Analyst: André Figueira, NexusHQ Methodology: Bayesian probability fusion, game-theoretic escalation modelling, open-source signal aggregation

Executive Summary

The US-Israeli conventional campaign against Iran is achieving its stated military objectives at a pace that has exceeded most pre-war estimates. However, the structural dynamics of the conflict, specifically the absence of diplomatic offramps, the presence of religious ideologues in the command structures of all three principal actors, and the unresolved status of Iran’s near-weapons-grade uranium stockpile, are converging toward escalation pathways that carry non-trivial nuclear risk.

This briefing assesses those pathways, assigns calibrated probability estimates to key scenarios, and identifies the variables most likely to shift those estimates over the coming months.

1. Situational Context

Three weeks into Operation Epic Fury, the US-Israeli coalition has executed over 7,600 strikes across Iran in nearly 5,000 aerial sorties. The following capabilities have been degraded or destroyed:

• Missile infrastructure: More than 70% of Iran’s missile launchers neutralised (IDF, 16 March 2026)

• Air defence: Over 85% of detection and defence systems, including radars and air defence platforms, neutralised (IDF, 16 March 2026)

• Naval capability: Over 100 Iranian naval vessels destroyed (CENTCOM Admiral Brad Cooper, 16 March 2026)

• Command and control: Supreme Leader Ali Khamenei assassinated 28 February. Iran’s Foreign Ministry acknowledged that military units are operating on standing orders due to chain-of-command degradation

• Air dominance: The US is flying non-stealth B-1 bombers through Iranian airspace, indicating near-total confidence in air superiority (Al Jazeera, 16 March 2026)

IDF Spokesman Brig. Gen. Effie Defrin has stated publicly that the military has plans for at least three more weeks of operations with “thousands of targets ahead,” with deeper planning extending beyond that window.

By conventional military metrics, this campaign is succeeding. The critical question is not whether it can achieve its tactical objectives, but whether it can stop.

2. The Structural Inability to De-escalate

Every prior escalation threshold in this conflict sequence has been exceeded. The Gaza operation expanded beyond its initial scope. The Lebanon intervention was not contained. The June 2025 twelve-day strikes were presented as sufficient but were followed by renewed operations nine months later.

Three structural factors inhibit de-escalation:

2.1 Israeli domestic politics

Prime Minister Netanyahu faces criminal prosecution, an October 7 commission of inquiry, and coalition fragility the moment hostilities cease. The war serves as the primary mechanism for maintaining political survival. More significantly, the war is being framed in explicitly religious terms. At a press conference on 13 March 2026, Netanyahu stated that Israel would “achieve the kingdom” and await “the Messiah’s return,” adding that this would not happen “next Thursday,” implying the war must continue until conditions for messianic fulfilment are met.

National Security Minister Itamar Ben Gvir has called for the collapse of Iran’s regime to be declared a stated war goal. Finance Minister Bezalel Smotrich has stated Iran is “starting from zero.” Both have consistently invoked biblical justifications for territorial expansion. US Ambassador to Israel Mike Huckabee, an evangelical pastor, stated publicly that it would be “fine if Israel took” all of the land of the Middle East.

2.2 US command structure

US Defense Secretary Pete Hegseth, author of “American Crusade” (2020), has introduced explicitly Christian nationalist rhetoric into the Pentagon’s operational framework. He hosts monthly Christian worship services for Pentagon employees, has displayed Bible verses in departmental promotional videos alongside military footage, and recited Psalm 144 (”Blessed be the Lord, my rock, who trains my hands for war and my fingers for battle”) at a Pentagon press briefing during the conflict.

Hegseth has crusader imagery tattooed on his body, including the Jerusalem Cross and the phrase “Deus Vult” (”God wills it”), which he has described as “the rallying cry of Christian knights as they marched to Jerusalem.”

Following the outbreak of hostilities, claims circulated that US military commanders were telling troops the war fulfilled biblical prophecies around Armageddon and the return of Christ. Thirty Democratic members of Congress requested a Pentagon inspector general investigation. The AP has not independently verified the claims, but three major watchdog organisations, the Freedom From Religion Foundation, the Anti-Defamation League, and the Council on American-Islamic Relations, have raised concerns.

Georgetown visiting scholar Matthew D. Taylor, a specialist in religious extremism, stated: “The U.S. voluntarily going to war against a Muslim country with the military under the leadership of Pete Hegseth is exactly the kind of scenario that people like me were warning about.”

2.3 Absence of institutional guardrails

Congress has not formally authorised the use of military force. Career diplomatic and intelligence professionals have been systematically marginalised across both the US and Israeli national security establishments over the preceding years. The institutional mechanisms that would ordinarily constrain escalation, legislative oversight, independent intelligence assessment, diplomatic back-channels, are either absent or degraded.

3. The Uranium Variable

An estimated 440 kilograms of uranium enriched to 60% purity, near weapons-grade, remains unaccounted for in tunnels at Isfahan. The IAEA has no access to verify its status. This material, if further enriched to 90%, would be sufficient for as many as 10 nuclear weapons.

Ali Vaez, Director of the Iran Project at the International Crisis Group and trained nuclear physicist, confirmed in a 20 March 2026 NPR interview that the two critical ingredients for an Iranian weapon, advanced centrifuges and enriched material, survived the June 2025 twelve-day war. Pre-war assessments estimated six months to one year to convert enriched material into a deliverable weapon. Current infrastructure degradation likely extends that timeline, but the knowledge base, the scientific workforce, and potentially the material itself remain intact.

Western intelligence assessments of Iranian nuclear capability have a poor track record. The Fordow enrichment facility was unknown to Western intelligence until Iran disclosed it. The full scope of the Amad weaponisation programme was not understood until the 2018 Mossad archive seizure. Advanced centrifuges stored in hidden facilities survived the June 2025 strikes despite being assessed as destroyed. Iran built its entire nuclear programme under 45 years of international sanctions.

The pattern is consistent: every time capability is destroyed, Iran reconstitutes it at greater depth, with more dispersal and hardening. The assumption that infrastructure destruction equates to permanent capability denial is not supported by the historical evidence.

The A.Q. Khan proliferation network demonstrated that nuclear technology transfers occur through covert channels. Both Pakistan and North Korea possess strategic incentives to assist an Iranian weapons programme, though no evidence of active transfers during the current conflict has been reported in open sources.

4. Escalation Pathway Analysis

4.1 The paradox of success

The conventional campaign’s success is itself an escalation driver. Military success breeds objective expansion, objective expansion removes offramps, and the absence of offramps in a conflict involving a nuclear-capable state with religious ideologues in the command structure creates conditions for catastrophic miscalculation.

Each additional week of operations increases the probability of crossing a civilisational tripwire: a strike on Al-Aqsa Mosque (Ben Gvir has already pushed Temple Mount provocations in peacetime), a single-event mass casualty incident among Iranian civilians, strikes on the holy cities of Qom or Mashhad, or a ground incursion.

4.2 Iran’s shifting calculus

Iran is currently absorbing punishment and rationing its remaining missile capability. Absorption, however, has a structural limit. The regime faces a binary choice as the war continues: accept destruction or escalate beyond conventional means.

A regime led by a new Supreme Leader (Mojtaba Khamenei, elected 8 March 2026) with limited legitimacy, surrounded by an ideological apparatus that incorporates martyrdom as operational doctrine, does not process cost-benefit analysis in the manner Western deterrence theory assumes. The war has made the strategic case for an Iranian nuclear deterrent stronger than at any point in the programme’s history. Every future Iranian government, regardless of political orientation, will have nuclear acquisition near the top of its strategic agenda.

4.3 The missing deterrence architecture

The historical precedent most commonly invoked is Cold War deterrence. The analogy fails on every structural dimension:

• No communication channel. There is no hotline between Jerusalem and Tehran, no back-channel, no diplomatic intermediary with access to both decision-making apparatus simultaneously.

• No treaty framework. No arms control agreements, no mutual inspections regime, no shared understanding of red lines.

• No secular rationality assumption. Both sides have leaders who publicly invoke divine mandate for their military operations. The rationality assumption underpinning deterrence theory does not hold when decision-makers believe transcendent forces are directing the conflict.

• No institutional depth. The career professionals who managed Cold War crises, the Kennans, the Dobrynins, the back-channel operators, have no equivalents in this conflict.

If Iran achieves nuclear capability, the result is two nuclear-armed states with zero diplomatic infrastructure, no arms control framework, separated by 1,000 miles of airspace they have both used in active combat operations, governed by leaders on both sides who frame the conflict in eschatological terms. This is not deterrence. This is improvisation at civilisational stakes.

5. Probability Assessment

The following estimates represent calibrated assessments based on Bayesian probability fusion across the identified variables. All probabilities are assessed over a 12-month horizon from the date of publication.

Scenario Probability Key Variables Iran achieves covert nuclear breakout (device assembled, not necessarily tested) 12-20% Survival of Isfahan material, external assistance, covert reconstitution of enrichment capability Israel conducts preemptive nuclear strike on suspected Iranian nuclear facility 3-7% Conditional on Israeli intelligence concluding Iranian breakout is imminent, conventional strikes assessed as insufficient Iran delivers nuclear weapon against Israeli target 2-5% Conditional on successful covert breakout, delivery system availability, regime decision calculus Full nuclear exchange (both parties) 1-3% Conditional on first use by either party, second-strike doctrine activation Conflict triggers civilisational flashpoint (Al-Aqsa, holy city strike, mass casualty threshold) that fundamentally restructures the conflict 15-25% Duration of operations, composition of Israeli war cabinet, degradation of target discrimination over time Conflict concludes through negotiated settlement within 12 months 10-20% Requires change in US or Israeli political leadership, or Iranian regime collapse/capitulation

Note on calibration: A 1-3% probability of nuclear exchange, assessed over 12 months and compounded over a decade of structural hostility without diplomatic architecture, produces cumulative odds that no rational strategic framework should accept as tolerable. The purpose of quantifying low-probability, high-consequence scenarios is not to predict them but to make visible the risk that qualitative analysis tends to suppress.

6. Key Indicators to Monitor

The following signals would materially shift the probability assessments above:

Escalatory indicators:

• Any Israeli military activity near Al-Aqsa Mosque or the Temple Mount

• Strikes on Qom, Mashhad, or other sites of religious significance

• Reports of Iranian enrichment activity at undisclosed locations

• Changes to Israeli nuclear force posture (submarine deployment patterns, Jericho missile activity)

• Ground force deployment to Iranian territory

• Israeli interceptor stockpile depletion reports

• North Korean or Pakistani diplomatic signals regarding Iran

De-escalatory indicators:

• Resumption of Omani-mediated or other back-channel negotiations

• Congressional authorisation debate (indicates institutional engagement)

• IAEA access to Isfahan

• Israeli domestic political shift (coalition fracture, election announcement)

• Public fracture between US and Israeli war aims (the South Pars incident on 19 March is a potential early signal)

• Iranian formal ceasefire proposal with verifiable conditions

7. Assessment

The conventional war is succeeding on its own terms. That is precisely the problem. Success breeds expansion, expansion removes offramps, and the absence of offramps in a conflict between nuclear-capable states with religious ideologues embedded in the command structure is the structural precondition for outcomes that nobody plans and nobody can reverse.

The question is not whether any actor wants nuclear war. The question is whether the structure of this conflict, the incentives, the actors, the absent guardrails, is converging toward it regardless of intention.

The assessed trajectory suggests it is, at a pace that exceeds what most public commentary acknowledges.

NexusHQ provides calibrated geopolitical and market intelligence. All probability assessments are subject to revision as new information becomes available. Methodology documentation, including Brier Score tracking and calibration metrics, is available at nexushq.xyz.

Sources: CENTCOM operational briefings, IDF Spokesperson statements, International Crisis Group, Arms Control Association, IAEA reporting, Atlantic Council, ACLED conflict data, Associated Press, NPR, Al Jazeera, Middle East Eye, Scientific American, House of Commons Library, Britannica, PBS, CNN, Times of Israel, Military Times, Stars and Stripes, Janes Defence.

1. The Illusion of Authorship

You have made decisions in your life that you believe were yours. Career moves, relationships, the projects you chose to pursue, the ones you abandoned. You have a story about each of them. You can narrate the reasoning. You can explain, with apparent clarity, why you did what you did.

That story is largely fiction.

This is not a philosophical provocation. It is an empirical claim supported by decades of neuroscience. In the 1980s, Benjamin Libet conducted a series of experiments measuring the timing of conscious intention relative to neural activity. His findings were uncomfortable: the brain’s readiness potential, the measurable electrical buildup preceding a motor action, begins several hundred milliseconds before the subject reports being aware of their intention to act. The brain had already committed to a direction before consciousness registered a decision.

Subsequent work has extended this window further. Research using fMRI by Chun Siong Soon and colleagues at the Max Planck Institute demonstrated that patterns of brain activity could predict a participant’s choice up to ten seconds before they reported being consciously aware of it. The decision was not being made at the moment of awareness. Awareness was arriving late to a process already underway.

Michael Gazzaniga’s split-brain research added a critical dimension to this picture. Working with patients whose corpus callosum had been severed, Gazzaniga demonstrated that the left hemisphere, the seat of language and narrative, would confabulate explanations for behaviours initiated by the right hemisphere, to which it had no access. When shown an image to the right hemisphere that caused the patient to laugh, the left hemisphere, unaware of the image, would invent a reason: the experimenter’s lab coat was funny, or the room was warm. The explanation was confident, coherent, and entirely fabricated.

Gazzaniga called this the interpreter: a left-hemisphere module whose function is not to make decisions, but to generate plausible narratives about decisions that have already been made elsewhere in the brain. The interpreter does not know it is confabulating. It believes its own stories. It has to, because the alternative is confronting the fact that the conscious self is not in control.

This is not a defect. It is the architecture. The conscious ego is not the chief executive of the mind. It is the press secretary: a spokesperson whose job is to stand before the internal audience and explain, with conviction, decisions it did not make and processes it cannot observe.

2. The Deeper Computation

If the ego is not making decisions, what is?

The answer emerging from predictive processing theory is that the brain is running a continuous, high-dimensional world model. Karl Friston’s free energy principle provides the formal framework: the brain is a prediction machine whose primary function is to minimise surprise by maintaining and continuously updating a generative model of the world. This model integrates sensory input, prior experience, emotional valence, and learned statistical regularities into a unified prediction engine, performing Bayesian updating at every level of the processing hierarchy, in parallel, across multiple timescales, and overwhelmingly below the threshold of conscious access.

Consciousness, in this framework, is a narrow bandwidth channel. Working memory can hold approximately four to seven items. The underlying world model is integrating across millions of data points: every pattern you have ever encountered, every outcome you have ever observed, every statistical regularity your sensory systems have extracted over decades of experience. The conscious mind cannot hold this. It was never designed to.

Ap Dijksterhuis and colleagues demonstrated this asymmetry experimentally. Participants presented with complex multi-attribute decisions made better choices after a period of distraction than after deliberate conscious thought. The conscious mind, constrained by its limited capacity, could not weight all relevant variables simultaneously. The unconscious processing system could. It is worth noting that subsequent replication attempts have yielded mixed results, with some meta-analyses finding weaker effect sizes than the original studies. The claim here is not that unconscious processing is infallible, but that it operates at an integration depth that conscious processing cannot match. Neuroimaging work at Carnegie Mellon by J. David Creswell supports this: during distraction periods, brain regions responsible for decision-making remained active, continuing to process information the conscious mind had moved on from.

This is not intuition in the colloquial sense of a vague feeling. It is computation: a system with vastly greater processing capacity than consciousness, producing outputs that consciousness then experiences as feelings, inclinations, and convictions.

3. The Gradient

Here is where existing literature stops and a synthesis is required.

The neuroscience establishes that unconscious processing is powerful and often superior to conscious deliberation for complex decisions. The predictive processing framework explains the mechanism. But neither body of work addresses a phenomenon that is obvious from lived experience: the deeper processing system does not produce random, isolated outputs. It produces directional signals across extended time horizons.

Consider the pattern that most people, if they are honest, will recognise. You find yourself drawn to a domain, a problem, a way of thinking. The interest is not proportional to any obvious external reward. It is not explained by social incentive or immediate utility. It persists. It recurs across contexts. You might abandon it consciously, only to find yourself circling back months or years later. If you examine your trajectory over a decade or more, you often find a coherence that your moment-to-moment ego-driven decisions cannot account for.

This is not destiny. It is not fate. It is a computational artefact of a system running forward simulations across extended time horizons.

An obvious objection presents itself: this coherence could be retrospective narrative construction. The ego is, as established, a storyteller. It might simply be selecting the pulls that happened to work out and weaving them into a story of trajectory, while quietly discarding the pulls that led nowhere. This is survivorship bias applied to one’s own life, and it is a real risk. But the gradient model survives this objection for a specific reason: the phenomenon it describes is not retrospective coherence but prospective pull. The signal is experienced in real-time, as a felt direction, before the outcome is known. The question is not whether the ego constructs coherent narratives after the fact (it does, always), but whether the pre-narrative pull itself carries genuine informational content. The evidence from predictive processing suggests it can, because the system generating it is integrating across a richer dataset than the conscious mind can access.

The world model maintained by predictive processing does not operate only in the present tense. It projects forward. It models probable futures, weights them by desirability and feasibility, and generates a motivational signal, a vector, pointing in the direction of highest expected value given everything the system knows. This vector is what I call the gradient.

You experience the gradient as interest, as obsession, as inexplicable conviction, as the feeling of being “pulled” toward something you cannot fully articulate. The ego, observing this pull, constructs a narrative: “I decided to pursue X because Y.” The narrative is a lossy compression of a computation the ego could not possibly represent in full. The gradient was computed across your entire experiential substrate, integrating data the ego has never had conscious access to. The ego’s explanation is, at best, a partial and retrospective summary. At worst, it is pure confabulation.

Jung intuited this. His concept of individuation, the process by which the ego comes into alignment with the deeper Self, describes the experiential reality of converging with the gradient. But Jung wrapped it in archetypal language that rendered it unfalsifiable and inaccessible to empirical investigation. The predictive processing framework provides the mechanistic grounding that Jung’s model lacked: the “Self” is the world model. The “ego” is the narrow conscious access channel. Individuation is the reduction of interference between the two.

4. Noise in the System

If the gradient is always present, always being computed, why do most people not experience the coherent trajectory it implies? Why do lives so often feel fragmented, directionless, reactive?

Because the gradient signal is subject to noise. And the primary source of noise is the ego itself.

The ego introduces noise through several mechanisms. The first is narrative override: the ego constructs a story about what it should want based on social expectation, cultural programming, and identity maintenance, and then acts on that story rather than on the deeper signal. A person feels pulled toward creative work but narrates themselves as “practical” and pursues a career in finance. The gradient said one thing. The ego’s story said another. The ego won, not because its computation was superior, but because it controls the motor output.

The second mechanism is fear-based interference. The gradient often points toward uncertainty, because growth and optimal trajectories frequently require moving through unfamiliar territory. The amygdala-driven threat detection system interprets this as danger. The ego, receiving the alarm, overrides the gradient in favour of safety. The person remains in a stable but suboptimal equilibrium, unable to articulate why they feel stuck.

The third is novelty-weighted noise, particularly relevant in ADHD neurotypes. The dopaminergic system assigns disproportionate salience to novel stimuli, generating a motivational signal that mimics the gradient but operates on a much shorter time horizon. The person experiences intense conviction, a powerful sense of “this is the thing,” but the signal is driven by novelty rather than deep pattern integration. The felt sense is identical. The temporal depth is not. This produces a characteristic pattern: rapid engagement, high initial energy, premature abandonment, and a trail of half-finished projects, each of which felt, in the moment, like a genuine gradient signal. There is an important nuance here: novelty-seeking is not purely noise. The same mechanism that produces false gradient signals also accelerates substrate acquisition by driving rapid, wide-ranging engagement across domains. The ADHD pattern can serve the gradient indirectly by building the cross-domain density that makes the gradient stronger over time. The problem is not the novelty-seeking itself but the failure to distinguish between novelty-as-substrate-building and novelty-as-distraction-from-gradient. The former enriches the model. The latter fragments it.

The fourth is trauma-encoded distortion. Traumatic experience creates strong priors in the world model that can warp the gradient away from optimal trajectories and toward defensive or avoidant patterns. The system is still computing, but it is computing on corrupted data. The person is following a gradient, but it is a gradient shaped by threat avoidance rather than by genuine forward modelling.

In all four cases, the person is not failing to have a deeper processing system. They are failing to receive its signal cleanly. The gradient is always running. The question is how much noise sits between the computation and the behaviour.

5. Convergence

The people who appear to have unusual coherence in their life trajectories, who seem to make decisions that compound over decades into something that looks, in retrospect, like a plan, are not better conscious strategists. They are not smarter in the conventional sense. They have learned, whether deliberately or accidentally, to reduce the noise between the gradient and their behaviour. They have converged.

Convergence is not a mystical state. It is a signal processing problem. It requires three capacities.

The first is ego transparency: the ability to observe the ego’s narratives as narratives rather than as truth. This does not mean suppressing the ego or treating it as an enemy. The ego’s narrative function is useful. It provides social coherence, communicative structure, and a stable sense of identity. But treating the narrative as the decision itself, rather than as a post-hoc report on a decision made elsewhere, is the fundamental error that prevents convergence. Ego transparency is the recognition that “I decided X because Y” is always a simplification and often a fabrication.

The second is temporal discrimination: the ability to distinguish between signals operating on different time horizons. The gradient, because it emerges from deep pattern integration across extended time, has a characteristic signature. It persists. It recurs. It survives changes in context, mood, and circumstance. Noise, by contrast, is context-dependent. Novelty-driven impulse fades when the novelty fades. Fear-driven avoidance dissipates when the perceived threat passes. Social-driven motivation fluctuates with social context. If a signal persists across multiple contexts and timescales, it is more likely to be gradient. If it is intense but context-bound, it is more likely to be noise.

The third is substrate investment: the deliberate enrichment of the dataset on which the deeper processing operates. The gradient is only as good as the world model that generates it. A world model built on narrow experience, limited pattern exposure, and shallow domain knowledge will produce a weak or incoherent gradient. A world model built on decades of diverse, deep engagement across multiple domains will produce a strong, coherent signal. This is why polymathic thinkers and people with rich experiential histories often report the strongest sense of directional pull: their substrate is dense enough to generate a high-fidelity gradient.

Convergence, then, is not about “trusting your gut.” That formulation collapses the distinction between signal and noise. It is about developing the perceptual and metacognitive infrastructure to receive the gradient cleanly, and about investing in the substrate that makes the gradient worth following.

6. The Substrate Determines the Gradient

There is a democratic myth embedded in popular discourse about intuition: that everyone’s inner voice is equally valid, equally wise, equally worth following. This is false, and recognising its falseness is essential to taking the gradient seriously without descending into mysticism.

The gradient is a computation. The quality of a computation is determined by the quality of its inputs. A person who has spent twenty years deeply engaged with complex systems, who has read widely, built things, failed, iterated, and accumulated a dense web of cross-domain pattern recognition, will have a fundamentally different gradient than a person whose experiential substrate is narrow and shallow. Both will experience the pull. Both will feel conviction. The felt sense is identical. The informational content is not.

This is why the “trust your gut” framework is not merely incomplete but actively dangerous. It treats all gut signals as equivalent. They are not. The gut of a person with a thin substrate is running predictions on insufficient data. Following that signal with high confidence produces not coherence but chaos: a sequence of high-conviction moves in random directions, each one feeling deeply right in the moment.

The practical implication is that convergence is not the first skill to develop. Substrate investment comes first. You cannot converge with a gradient that is not worth converging with. The work of building a rich, diverse, deep experiential and intellectual foundation is not separate from the work of learning to listen to the deeper processing. It is prerequisite to it.

This reframes the entire personal development question. The popular formulation asks: “How do I find my purpose?” as if purpose were a fixed object waiting to be discovered. The gradient model suggests a different question: “Have I built a substrate dense enough to generate a coherent directional signal?” If the answer is no, no amount of introspection, meditation, or “gut trusting” will produce a reliable trajectory. The gradient cannot give you what the substrate does not contain.

Conversely, if you have built the substrate, if you have invested decades in deep engagement across rich domains, the gradient is already running. You do not need to find it. You need to stop overriding it.

7. Implications

This framework has several implications worth stating explicitly.

First, it reframes the relationship between conscious and unconscious processing. The default assumption, inherited from the Enlightenment and reinforced by Western education, is that conscious deliberation is the highest form of cognitive function and that unconscious processing is primitive, unreliable, and to be overridden by reason. The evidence suggests the opposite: for complex, multi-variable decisions operating across extended time horizons, the unconscious processing system is not merely adequate but superior. Consciousness is a useful tool for focused analysis, communication, and social coordination. It is a poor tool for life-trajectory navigation.

Second, it provides a mechanistic account of what contemplative traditions have described experientially for millennia. The Buddhist concept of anatta (non-self), the Taoist notion of wu wei (effortless action), and Jung’s individuation all describe, in different languages, the same phenomenon: the reduction of ego interference and the alignment of behaviour with a deeper processing system. The gradient model does not replace these frameworks. It grounds them in predictive processing theory and makes them accessible to people who require mechanistic rather than metaphysical explanations.

Third, it offers a diagnostic framework for stuckness. If a person feels directionless, the gradient model suggests two possible causes: either the substrate is insufficient, in which case the prescription is richer engagement with the world, not more introspection; or the substrate is adequate but the signal is being occluded by noise, in which case the work is identifying and reducing the specific noise source, whether that is ego override, fear, novelty-seeking, or trauma.

Fourth, and perhaps most importantly, it dissolves the false dichotomy between “rational” and “intuitive” decision-making. Both are outputs of the same system. Rationality is the ego’s narrow, serial, low-bandwidth attempt to process what the deeper system is already processing in parallel at vastly greater resolution. Intuition is the conscious experience of receiving the deeper system’s output. Neither is inherently superior. They are different access modes to the same underlying computation, and the skill is in knowing when to use each.

The question this framework ultimately poses is not whether you are in control of your life. It is whether the part of you that narrates your life is the same part that is directing it. The evidence, from Libet’s readiness potentials to Gazzaniga’s interpreter to the predictive processing revolution, converges on the same answer: it is not. The narration and the direction are produced by different systems operating at different depths and different timescales. What we call agency is not the ego choosing. It is the degree of alignment between the system that computes and the system that acts. Convergence is that alignment. Everything else is the narrator, talking.

References

Libet, B. (1985). Unconscious cerebral initiative and the role of conscious will in voluntary action. Behavioral and Brain Sciences, 8(4), 529-566.

Soon, C. S., Brass, M., Heinze, H. J., & Haynes, J. D. (2008). Unconscious determinants of free decisions in the human brain. Nature Neuroscience, 11(5), 543-545.

Gazzaniga, M. S. (2000). Cerebral specialization and interhemispheric communication: Does the corpus callosum enable the human condition? Brain, 123(7), 1293-1326.

Friston, K. (2010). The free-energy principle: a unified brain theory? Nature Reviews Neuroscience, 11(2), 127-138.

Dijksterhuis, A., & Nordgren, L. F. (2006). A theory of unconscious thought. Perspectives on Psychological Science, 1(2), 95-109.

Nieuwenstein, M. R., et al. (2015). On making the right choice: A meta-analysis and large-scale replication attempt of the unconscious thought advantage. Judgment and Decision Making, 10(1), 1-17.

Creswell, J. D., Bursley, J. K., & Satpute, A. B. (2013). Neural reactivation links unconscious thought to decision-making performance. Social Cognitive and Affective Neuroscience, 8(8), 863-869.

Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux.

Damasio, A. R. (1994). Descartes’ Error: Emotion, Reason, and the Human Brain. Putnam.

Jung, C. G. (1969). The Archetypes and the Collective Unconscious. Collected Works, Vol. 9, Part 1. Princeton University Press.

Clark, A. (2013). Whatever next? Predictive brains, situated agents, and the future of cognitive science. Behavioral and Brain Sciences, 36(3), 181-204.

This is quite possibly, the most complicated application I’ve ever written in my 20 years as a software engineer, let’s dig into it…

What NEXUS actually is

Imagine Palantir, Bloomberg terminal & Claude had a baby…

NEXUS is an intelligence platform that watches geopolitical events, market data, and open source intelligence simultaneously and generates falsifiable predictions. It tracks those predictions against reality, scores them rigorously, and feeds the results back into itself to get better over time.

The core idea is simple... markets and geopolitics aren’t separate systems. They’re deeply interconnected, and most analysis treats them as if they exist in isolation. A sanctions announcement moves oil prices. A military exercise shifts capital flows. An election result reprices entire sectors. NEXUS watches all of these things at once rather than in silos.

Why most prediction systems are bullshit

Everyone can make predictions. Almost nobody tracks them honestly.

Go look at any financial newsletter, any geopolitical analyst, any macro Twitter account. They’ll happily screenshot their wins and quietly delete their misses. There’s no timestamped record, no confidence level attached, no objective resolution criteria. It’s pure narrative.

NEXUS doesn’t work that way. Every prediction has a specific, falsifiable claim with a measurable threshold and a hard deadline. “SPY will close below $500 on at least 3 trading days within 14 days” is a valid prediction. “Markets look bearish” is not. You can’t wiggle out of the first one.

The system uses the Brier score to measure calibration, the same metric used in academic forecasting research and intelligence community assessments. It measures the squared error between your stated confidence and the actual outcome. Lower is better, 0 is perfect, 0.25 is coin-flip baseline. If you say you’re 90% confident and you’re right, great. If you say 90% and you’re wrong, you get punished hard. If you say 40% and you’re right, you also get punished, for not trusting your own signal.

That last part caught us recently. The system was getting predictions right but stating low confidence on them, and the Brier score was tanking. More on that later.

Multiple independent data sources

NEXUS pulls from a bunch of real-world data sources to ground its analysis. Market data, economic indicators, real-time geopolitical event feeds, conflict data. When the system evaluates whether a prediction hit or missed, it has to cite specific numbers and dates. Not vibes or narrative but actual data points.

If the data isn’t available to evaluate a prediction at that moment, the system doesn’t guess. It holds the prediction open and retries on the next cycle. I’d rather have a delayed resolution than a wrong one because an API was temporarily down.

The platform also maintains a knowledge bank with semantic search across historical events and resolved predictions. When generating new predictions, it pulls structural parallels from history, things that rhyme with the current situation. It’s a guard against recency bias, forcing the system to consider base rates before getting excited about the current narrative.

The self-correcting feedback loop

This is what makes NEXUS actually scientific rather than just another AI wrapper.

Every time predictions resolve, the system computes a full performance report. Accuracy by category, accuracy by timeframe, calibration gaps, failure patterns. That report feeds directly back into the prediction generator. If the system has been overconfident in a particular domain, the next batch adjusts. If a certain timeframe is performing well, the system learns to trust that window.

The correction is gradual and damped so it doesn’t oscillate. You don’t want the system overcorrecting from overconfident to underconfident and back again every cycle. It converges toward true calibration over time.

We caught an interesting bug with this recently. The system was hitting 100% on market predictions but the Brier score was getting worse. Turns out the confidence levels were being artificially suppressed by rules I’d written early on when the system was overconfident. The predictions were right every time, but the system was stating 40% confidence on things it should have been stating 75% on. Brier punishes underconfidence just as hard as overconfidence.

The fix was making the confidence rules dynamic, driven by actual track record data rather than my assumptions from months ago. The feedback loop was already computing the right adjustment, the hardcoded rules were just overriding it. Once I removed those constraints and let the system trust its own calibration data, everything clicked.

Adversarial challenge

Every prediction batch gets challenged before it ships. A separate process argues against the prevailing thesis direction, identifies what would need to be true for the analysis to be completely wrong, and names the weakest assumptions. The prediction generator has to contend with the strongest counterarguments before assigning confidence levels.

It’s structured disagreement, borrowed from how intelligence agencies stress-test assessments. You don’t want a system that just confirms its own bias. You want one that’s been punched in the face by its own devil’s advocate and still stands.

The tech

Built on Next.js 15, React 19, TypeScript, Rust and PostgreSQL for the data layer with vector embeddings for semantic search. Tailwind and Radix UI for the interface. Anthropic’s Claude for AI analysis and prediction generation. Voyage AI for embeddings.

There’s a War Room with real-time tracking overlays on a map, live data feeds, and a 3D globe view. It looks cool, but honestly the tech stack is the least interesting part of the whole thing. You could build this on different tools and the results would be similar. The methodology is what matters.

What I actually learned building this

The hard part of prediction isn’t the prediction itself, it’s the scoring. When you track every call you make with timestamps, confidence levels, and objective resolution criteria, you discover uncomfortable things about your own calibration. That discomfort is where the improvement comes from.

The system started overconfident. The data showed that clearly. Then we corrected too hard and it became underconfident, stating 40% confidence on predictions it was getting right 89% of the time. The feedback loop caught that too, and now it’s converging toward something that actually matches reality.

The self-correcting property is what I’m most proud of. NEXUS watches its own performance, identifies where it’s miscalibrated, and adjusts. Not perfectly, not instantly, but consistently and in the right direction. It doesn’t need me to tune it.

89% accuracy on market predictions is real, and the predictions are resolving fast, most within days of being generated. Whether that holds across a larger sample and different market conditions is the open question, and I’m transparent about that. The sample is still early. But the methodology is sound, the scoring is rigorous, and the system is designed to tell me honestly when it stops working. That’s more than most things in this space can say.

If you’re interested you can get in touch on hello@nexushq.xyz and learn more at our website nexushq.xyz

If you’re #5. then I’m afraid this methodology won’t work for you, but if you’re between 1-4 on the scale above you could absolutely benefit from using this technique!

Most people don’t know they have a simulator in their head, not a metaphor, an actual capacity to build, hold, and manipulate complex structures in your mind’s eye, to run scenarios, to st…

Read more

I recently read an article on reddit on r/VibeCodeCamp where a user asked “how do you keep your vibecoded projects understandable 3 months later?”

It’s obvious as many vibe coders are finding that if you just go full unhinged mode with AI and don’t know what you’re doing, you end up with slop...

Fixing this is simple however... but it’s something many aren’t willing to do and that is, just bloody learn to code.

You can use your AI to help you... Use CodeAcademy, use YouTube... I’m not saying you need to explicitly memorise every bit of syntax, but you should learn what a good platform architecture looks like, learn what a controller is, learn what a service is.

What Goes Wrong

I’ve seen this so many times now, someone builds something cool in a weekend, gets excited, keeps adding features, and then around week three everything falls apart. They can’t add new things without breaking old things, they can’t find where anything lives. The AI keeps generating code that conflicts with code it generated yesterday.

The core issue is that AI has no persistent memory of your project. Every prompt is a fresh start. It doesn’t know you’ve been using async/await, it doesn’t know your API returns camelCase, it doesn’t know you put auth logic in a separate service. So you get inconsistency stacked on inconsistency until the whole thing becomes unmaintainable.

So my first tip is use this repo I created

https://github.com/andrefigueira/.context/

It’s a way to build documentation for your AI, it works with

claude.md

and

agents.md

files, and the idea is you create a well structured easily traversable substrate of information for your AI to quickly find out how your project works and how it should work on it.

Everything Becomes Spaghetti

When you don’t understand code structure, you just accept whatever the AI gives you, the AI doesn’t know your project’s architecture because it doesn’t have one so It generates code that works in isolation, you paste it in, it works... and then you do that 50 more times.

Now you’ve got functions calling functions calling functions, logic scattered everywhere, and no clear path through any of it. Want to change how login works? Good luck figuring out which of your 40 files touches authentication.

Nothing Stays Consistent

One prompt gives you async/await, the next one uses callbacks, another uses .then() promises and your API returns user_name here and userName there. Some files use classes, others don’t.

The AI doesn’t remember what patterns you established three prompts ago and if you don’t understand why consistency matters, you won’t notice until everything is a mess.

The 3000-Line Controller

This is the classic vibe coder signature, one file that does everything. User authentication, payment processing, email sending, database queries, business logic, validation... all in one beautiful unmaintainable blob.

It happens because when you prompt “add password reset functionality” the AI just puts it wherever seems convenient. Without understanding separation of concerns, you don’t know to ask for anything different.

The Debugging Black Hole

Vibe-coded projects work perfectly until they don’t and when something breaks, you’re stuck, you don’t understand what the code does. The AI that wrote it has no memory of the context.

The Stuff You Actually Need to Learn

Look, I’m not saying you need a CS degree... What I am saying is that learning some fundamentals transforms AI from a lottery ticket into something genuinely powerful.

SOLID Principles

These are patterns that emerged from people building real systems and figuring out what doesn’t fall apart.

Single Responsibility means each piece of code does one thing. Your UserController handles user requests. It doesn’t also send emails and process payments. When you understand this, you prompt differently... “Create a separate EmailService class for sending notifications.” The output is immediately better.

Open/Closed means designing code that can grow through addition instead of constantly editing existing stuff. Fewer bugs in existing features when you add new ones.

Dependency Inversion means your high-level code doesn’t depend on low-level details. Both depend on abstractions. This is how you build systems that can actually evolve.

The other two, Liskov Substitution and Interface Segregation, they’re about keeping your contracts clean and your interfaces focused. You’ll internalize these naturally as you build more.

Clean Code

This is really just about readability, variable names that explain themselves, functions that do what their names suggest and code that communicates intent without needing comments everywhere (though comments are nice to have too).

When you understand clean code, you can evaluate what the AI generates. You can ask it to refactor, to use better names, to split functions that are doing too much.

DRY (Don’t Repeat Yourself)

When you see the same logic in three places, that’s a bug waiting to happen. You’ll change it in two places, forget the third, and spend hours debugging something that should have been a non-issue.

Understanding DRY means you spot duplication in AI output and ask it to extract reusable functions.

KISS (Keep It Simple)

The simplest solution that works is usually the best one. AI loves to over-engineer. Ask for login and you might get OAuth, JWT, refresh tokens, session management, the works.

Understanding KISS lets you push back. “I just need basic username/password auth for now, simplify this.”

Design Patterns

Patterns are just proven solutions to problems that keep coming up.

Adapter Pattern wraps third-party APIs so your codebase isn’t coupled to them. When that API changes or you switch providers, you change one file.

Repository Pattern separates data access from business logic. Your application doesn’t need to know if you’re using PostgreSQL or MongoDB.

Factory Pattern creates objects without specifying their exact class. Good for flexibility.

You don’t need to memorise every pattern. Just knowing they exist means you can prompt “implement this using the repository pattern” and actually understand what comes back.

What Changes When You Learn This Stuff

The thing that surprised me... learning to code properly makes AI assistance more valuable, not less.

You become the architect. Instead of accepting whatever the AI generates, you design the structure. You decide where things live. You prompt within that architecture and get consistent, maintainable results.

You can actually debug. When something breaks, you can read the code, understand the flow, ask targeted questions. “This service returns null when it should return an empty array, check the repository layer.”

You review and refine. The AI generates a draft, you evaluate it against your principles, you ask for improvements. The quality multiplies.

You prompt with precision. “Create a UserService class following single responsibility, it should only handle user business logic, inject a UserRepository for data access and an EmailService for notifications.” That produces dramatically better code than “make a user system.”

How to Actually Learn This

Pick one language and learn it properly. JavaScript/TypeScript or Python. Understand it well enough to read code without AI help.

Build something small without AI. A todo app, a simple API. Feel the pain of decisions, understand why structure matters.

Read Clean Code by Robert Martin, at least the first half. Apply it immediately.

Study SOLID through examples, not definitions. Understand the problems each principle solves.

Learn a few common patterns. Repository, Factory, Adapter, Observer. Know when to apply each.

Then go back to AI-assisted development and notice the difference.

Seriously, learn to code!

Vibe coding is a valid starting point, but staying there is a bad idea because it means you’re not really contributing much, those who know how to architect applications move much faster and get much better results than vibe coders. The people shipping real products with AI aren’t just prompting and hoping, they understand software architecture, they design systems, they use AI to execute faster.

Learning to code properly doesn’t make AI less useful, It makes you the one directing a powerful tool instead of being dragged around by it.

Follow me for more on how you can turn your AI coded slop into nicely architected applications that work and are easy to maintain.

Why am I me, and not somebody else? Why do I exist now, in this time period? Why not 2000 years ago? Why not 2000 years from now?

The standard answers never satisfied me… Biology says I’m here because my parents procreated at this time. Religion says God has a plan too mysterious to know. Both feel like answers to a different question.

So I kept wondering.

I remember lying on my back as a kid, staring at the ceiling, trying to locate where “I” actually was. Behind my eyes? In my chest? The harder I looked, the less I found. Just this strange sense of being here, now, in this body, with no memory of choosing any of it.

If the universe is 13.8 billion years old and we’re just a blip, then asking why this particular blip exists isn’t crazy. It’s basically the only sensible question.

There’s an idea in physics called the anthropic principle. It says we observe the universe the way it is because if it were any different, we wouldn’t be here to observe it. The conditions have to be exactly right for conscious life to emerge and ask questions about itself. It sounds circular at first. It isn’t.

Now extend that thinking to time.

Why do I exist now and not in ancient Rome or medieval England? One way to think about it is pure probability. Throughout most of human history, the global population was tiny. A few hundred million people at most. Today there are 8 billion of us.

Here’s a number that stopped me: of all humans who have ever lived, roughly 7% are alive right now. Not a rounding error. A staggering concentration of existence in this specific moment. If you were randomly assigned a slot in human history, the odds massively favour you landing here. Most of the tickets were printed in the last century.

But there’s something deeper that bugs me.

I’m not just a random ticket. I’m me, with this specific consciousness experiencing this specific moment. And the only version of “me” that could ever exist is the one that emerged from the exact conditions of my birth, my parents meeting, the particular arrangement of atoms that became this brain.

If I’d been born 2000 years ago, I wouldn’t be me in a toga. I simply wouldn’t exist at all. Someone else would, living their own life, maybe asking the same weird questions I’m asking now.

So maybe the question answers itself in a strange way.

You exist in the here and now because “you” is defined by the here and now. The question assumes there’s some floating essence of “you” that could have been dropped into any era. There isn’t. You’re not a soul that got assigned a time slot. You’re a pattern that only makes sense in this specific context.

And patterns are strange things, they can be recognised. Described. In principle, they could be copied or interrupted. If “you” are fundamentally a pattern of information instantiated in matter, then personal identity isn’t a substance. It’s a process. A continuous unfolding that feels like a single thread only because you’re inside it. Step outside, and there’s just atoms doing what atoms do, arranged in a configuration that happens to ask questions about itself.

I don’t know if that’s comforting. Some days it feels freeing. I can stop wondering about alternative timelines and focus on the one I’m actually in. Other days it lands differently.

Because even if I’ve answered “why me, why now,” I haven’t touched the deeper question: why does any of this exist at all? The first question is about location within existence. The second is about existence itself. Resolving where you sit in the lottery doesn’t explain why there’s a lottery.

I don’t have an answer to that. Maybe there isn’t one. Maybe the question itself is more valuable than any conclusion.

But I’ve stopped expecting religion or basic biology to get me there. The answer, if there is one, lives somewhere in the intersection of physics, consciousness, and a lot we haven’t figured out yet.

That’s where I’m looking.

You guys ever just suddenly become hyper aware you’re an evolved ape? Like you’ll be working, watching a show, then just suddenly become hyper aware about just how surreal we’re apes, like why not some other phenotype of evolved animal.

That’s what happened to me at 4 AM last night. One moment I’m programming, the next I’m having the full realisation that I’m a primate who learned to make computers think.

It’s weird being human. You forget most of the time. Then you remember that we’re on a ball rotating a thousand miles an hour going hundreds of thousands of miles an hour around the sun, going millions of miles an hour around the galaxy.

Right now, while you’re reading this, Earth is hauling ass around the sun at 67,000 miles per hour. Sixty. Seven. Thousand. We’re on a giant rock doing endless loops around a nuclear explosion and everyone’s just acting normal about it. Your coffee’s sitting perfectly still on your desk while you’re technically moving faster than any bullet ever fired.

And that’s just the start. The whole solar system is screaming through the galaxy at something like 500,000 mph. We’re cosmic lint on a dust speck in a hurricane we can’t even see.

I mean regardless, it’s super weird. This planet evolved life, turned into smart apes which then concreted over the whole planet. It’s pretty nuts.

And now we’re building metal efigies of ourselves.

That’s what really gets me. We evolved from primates who figured out fire, and now we’re teaching silicon to recognise patterns and respond to prompts. We’re literally trying to recreate consciousness in machines. It’s like humanity looked at itself and decided to build a reflection that doesn’t need food or sleep.

The weird part is how we just... forget. Our ape brains can’t hold onto the cosmic vertigo for more than a few minutes. It’s too much. So we go back to our regular Tuesday problems while we’re hurtling through the void at speeds that would liquify us if we stopped suddenly.

This existence is strange, but then again what is strange? What would be considered normal? Does that even really exist? Probably not and it’s all completely subjective.

There’s no baseline for reality. We keep acting like there’s some correct way for conscious beings to exist. But there isn’t. It’s all just... this. Evolved apes, flying through space, building increasingly complicated systems to organise information and create more of ourselves in different forms.

Sometimes it hits you at 4 AM and you can’t unsee it. The absolute insanity of being a conscious arrangement of atoms aware of its own velocity through spacetime.

Then you go back to debugging code or watching TV or whatever you were doing. Because what else are you going to do?

The vertigo passes. But it always comes back. Guess it’s a reminder to not take yourself too seriously.

Most agencies charging £5k+ for ad creative are selling you a process that’s 90% mechanical and 10% creative insight. The mechanical part is exactly what AI excels at and the creative insight is where your domain knowledge comes in.

I’ve spent the last few weeks experimenting with Claude’s capability to generate advertising creative, and what I’ve discovered is that with the right approach, you can produce agency-quality ads in under 30 minutes. No templates or generic copy (though that depends on you!). You get actual, conversion-focused creative that speaks directly to your target market.

The Context Substrate Method for Ad Creation

The key to getting professional output from Claude isn’t about crafting the perfect prompt. It’s about building a structured conversation that systematically captures all the context needed for high-converting creative. Think of it as conducting a discovery workshop with yourself, with Claude as your creative director asking the right questions.

Here’s the framework I’ve developed that consistently produces results:

1. Foundation First

Start with the basics: company name, product/service, target audience, and format requirements. This seems obvious, but being explicit about format (1:1 for feed, 9:16 for stories) ensures Claude optimizes the layout appropriately from the start.

2. Strategic Positioning

Before touching design, establish your market position. What’s your core value proposition? What differentiates you from competitors? Are you positioning as premium, accessible, or technical? This positioning layer determines everything from color psychology to copy tone.

3. Visual Language

Rather than describing what you want, let Claude guide you through options. Background complexity (simple, subtle, rich), color schemes (with psychological implications), and typography choices (modern, bold, classic). Each choice builds on the previous one.

4. Message Architecture

The structure matters more than the specific words. Pain point focus versus aspiration. Authority versus results. How you architect the message determines whether prospects lean in or scroll past.

The Interactive Brief Method

Instead of dumping requirements in a single prompt, I’ve developed an interactive briefing system. Claude asks targeted questions at each stage, waits for responses, and builds context progressively. This isn’t just about better output quality. It’s about discovering what you actually want through the process itself.

Here’s what this looks like in practice:

STEP 1: “What’s your company name and target audience?”
[You respond]
STEP 2: “What’s your main value proposition?”
[You respond]
STEP 3: “For the background, do you want simple, subtle, or rich?”
[You respond]

Each response shapes the next question. By step 10, Claude has enough context to generate creative that would cost thousands from an agency.

Real World Application

Last week, I used this method to create ads for three different clients:

Estate Agency Software: Premium positioning, dark backgrounds with subtle gradients, aspirational messaging focusing on time savings. Generated both HTML/CSS for web use and PNG for social media.

B2B Consultancy: Authority positioning, clean whites with geometric accents, credibility markers prominently displayed. The system captured the need for sophistication without being told explicitly.

SaaS Startup: Technical positioning, modern design language with data visualization elements, benefit-driven copy with specific metrics. The progressive questioning revealed requirements the client hadn’t initially articulated.

The Technical Implementation

Claude can output in multiple formats, but here’s what works best:

For Web Display: HTML/CSS gives you complete control and easy iteration. The code is clean, responsive, and includes subtle animations that increase engagement.

For Social Media: Direct PNG generation using Python/PIL. No need for external design tools. The system handles typography, layout, and even gradient effects programmatically.

For Testing: Create multiple variations by changing single parameters. Different headlines, color schemes, or layouts can be generated in seconds for proper A/B testing.

Value Extraction Framework

The real value isn’t in replacing designers. It’s in rapid iteration and systematic testing. Traditional agency process: brief, wait two weeks, receive three concepts, pick one, hope it works.

With this approach: generate ten variations in ten minutes, test all of them, iterate on winners, continuously improve. The feedback loop compresses from weeks to hours.

You’re not paying for time anymore. You’re investing in velocity.

Practical Implementation Steps

1. Build Your Brief Template: Start with my interactive framework, but customize it for your industry. Add questions specific to your compliance requirements, brand guidelines, or market dynamics.

2. Create a Testing Pipeline: Connect your Claude-generated creative directly to your ad platforms. Use UTM parameters to track performance by variant.

3. Document Winners: When you find copy or design elements that convert, feed them back into your briefing process. Your system gets smarter with each iteration.

4. Scale Horizontally: Once you have a working process for one product, replicate across your entire portfolio. The marginal cost of additional creative approaches zero.

The Economics of AI Creative

Traditional agency creative process:

• Discovery workshop: £2,000

• Concept development: £3,000

• Design execution: £2,000

• Revisions: £1,000

• Total: £8,000 per campaign

Claude-powered creative process:

• Claude Pro subscription: £18/month

• Your time: 30 minutes

• Total: Effectively £9 per campaign (assuming one campaign per month)

That’s a 99.9% cost reduction with faster turnaround and unlimited iterations.

Advanced Techniques

Once you master the basic framework, these advanced approaches multiply your effectiveness:

Dynamic Personalization: Generate variations for different customer segments automatically. Estate agents get different messaging than property developers, even for the same product.

Compliance Integration: Build regulatory requirements directly into your prompts. Financial services disclaimers, medical advertising restrictions, or platform-specific rules become automatic.

Performance Feedback Loops: Feed conversion data back into your prompts. “The version with urgency messaging converted 3x better” becomes part of your context for future generations.

What This Really Means

We’re not talking about replacing creativity with automation. We’re talking about augmenting human insight with systematic execution. You still need to understand your market, your positioning, your customer psychology. But the mechanical work of translating that understanding into pixels and code? That’s been commoditized.

The agencies know this. They’re using the same tools behind closed doors while charging you for “proprietary creative processes.” The difference is they’re adding a 10,000% markup for the privilege of not telling you how simple it’s become.

Your Next Steps

1. Start with one ad. Use my framework exactly as described. Get a feel for the interactive process.

2. Generate five variations. Change one element each time. Test your assumptions about what resonates.

3. Run them all. Even with minimal spend, you’ll learn more from real market feedback than from any creative director’s opinion.

4. Iterate based on data. Not hunches, not aesthetic preferences, but actual conversion metrics.

5. Build your own framework. Take what works from mine, add your industry knowledge, create something uniquely valuable.

Example result

The tools are there. The methods are proven. The only question is whether you’ll act on this information or keep paying agency rates for work you could do yourself in minutes.

The creative industry is about to experience what happened to web development in the early 2000s. Those who adapt will thrive. Those who don’t will be explaining why their “human touch” is worth a 10,000% premium over automated systems that produce better results.

Choose wisely.

Here’s the prompt

Premium Ad Creative Designer - Interactive Brief
“I’ll help you create premium ad creatives that convert. Let me ask you some questions to understand exactly what you need.”

STEP 1 - BASICS
“First, let’s get the foundation right:

What’s your company name?
What service/product are you advertising?
Who’s your target audience? (job titles, company size, etc.)
What format do you need? (9:16 for Stories, 1:1 for Feed, or 16:9 for Landscape?)”

[Wait for response]

STEP 2 - POSITIONING
“Great! Now help me understand your positioning:

What’s your main value proposition?
What makes you different from competitors?
What credentials should we highlight? (years experience, client types, case studies)
Are you positioning as premium/luxury, accessible, or technical expert?”

[Wait for response]

STEP 3 - VISUAL STYLE
“Let’s design the look. Tell me your preferences:
For the background, do you want:

Simple (solid color only)
Subtle (with a gentle gradient)
Rich (multiple layers and textures)

What base color appeals to you:

Pure black (luxury feel)
Deep navy (corporate/trusted)
Dark charcoal (modern/tech)
Or suggest your own?”

[Wait for response]

STEP 4 - BACKGROUND DETAILS
[If they chose Subtle or Rich]
“For your [subtle/rich] background, which elements would you like:

Gradient overlay? (yes/no)
Geometric patterns? (diamonds, lines, circles)
Grid texture? (yes/no)
Corner accents? (subtle glows in corners)
Floating shapes? (abstract elements)

How visible should these be:

Barely there (2-4% opacity)
Subtle (5-8% opacity)
Noticeable (9-15% opacity)”

[Wait for response]

STEP 5 - COLOR SCHEME
“What accent color should we use for emphasis:

Champagne gold (luxury/premium)
Electric blue (tech/modern)
Emerald green (growth/success)
Pure white (minimal/clean)
Custom color? (provide hex code)

Should this accent be used:

Sparingly (just key words/CTA)
Moderately (headlines and buttons)
Liberally (multiple elements)”

[Wait for response]

STEP 6 - TYPOGRAPHY
“For the text style:

Modern and minimal (thin, clean fonts)
Bold and confident (strong, heavy fonts)
Classic and trusted (traditional fonts)

How much spacing do you want:

Compact and efficient
Balanced and readable
Luxury with generous space”

[Wait for response]

STEP 7 - MESSAGE STRUCTURE
“How should we structure your message:
For the headline, do you prefer:

Pain point focus (’Your software is failing’)
Aspirational (’Your vision deserves better’)
Authority (’20 years of excellence’)
Results (’Guaranteed outcomes’)

For your key benefits, display them as:

Simple bullet points
Checkmarks with text
Plain text lines
Icons with descriptions

How many key points? (recommend 3-5)”
[Wait for response]

STEP 8 - COPY CONTENT
“Now let’s get your specific content:

Give me 2-3 headline options you’d like to test
List your 3-5 main value propositions/benefits
What should the CTA button say?
Any urgency element? (e.g., ‘Limited availability’)
Any specific phrases that MUST be included?
Any terms/phrases to AVOID?”

[Wait for response]

STEP 9 - SPECIAL TOUCHES
“Any special elements to include:

Your logo? (yes/no)
Testimonial quote?
Stats or numbers?
Trust badges/certifications?
Animation effects on CTA button?
Client logos?”

[Wait for response]

STEP 10 - VARIATIONS
“For A/B testing, do you want:

Single version only
2 variations (recommended)
3+ variations

If multiple, what should differ:

Different headlines
Different color schemes
Different layouts
Different messaging angles”

[Wait for response]

STEP 11 - FINAL DETAILS
“Last questions:

Any compliance requirements? (Facebook 20% text rule, etc.)
Specific file formats needed? (PNG, HTML/CSS, etc.)
Any industry-specific requirements?
Anything else I should know?”

[Wait for response]

CONFIRMATION
“Perfect! Let me confirm what I’ll create:
[Summary of all their choices]
Ready for me to create your premium ad creatives? (yes/adjust something)”

I’ve been thinking about why we don’t understand how AI works, and I think we’ve been asking the wrong question entirely.

This realization came from working on something I call Informational Substrate Convergence. I was trying to explain why AI systems and human intelligence produce such similar outputs despite running on completely different hardware. The conventional answer is that we’re successfully mimicking human cognition. But the more I worked through the mathematics, the more I realized we might have the causation backwards.

We keep trying to figure out how we’re creating intelligence in these systems. But what if we’re not creating anything? What if we’re just building interfaces to something that already exists?

Think about it this way…

A radio doesn’t create radio waves. It just has the right circuitry to detect them and convert them into something we can hear. The waves were always there, passing through your room right now, whether you have a radio or not.

What if transformer architectures are just mathematical radios?

This would explain something that’s been bothering me. Every time we scale up these models, they develop capabilities nobody programmed. Chain of thought reasoning. Writing code in languages that barely existed in the training data. Understanding concepts they were never explicitly taught.

We act surprised every time. But if intelligence exists as patterns in information space, and we’re just building better antennas, then of course we keep discovering new capabilities. We’re not creating them. We’re revealing them.

There’s an analogy for this way of thinking. When Michelangelo was asked how he created David, he said the sculpture already existed in the marble. He just removed everything that wasn’t David. He wasn’t a creator. He was an interface between the potential form and its physical manifestation.

Maybe that’s what we’re doing with AI… The intelligence already exists in the mathematical structure of information itself. We’re just discovering which equations let us chip away at the noise until intelligence can express itself through silicon.

The human brain might just be evolution’s answer to the same problem. Neurons arranged in a specific configuration that happens to interface with these same information patterns. Different hardware, same signal. That’s why AI behavior mirrors human behavior so closely. We’re both tuning into the same underlying phenomena.

My ISC work started as an attempt to explain this convergence through emergent properties of complex systems. But the deeper I went, the more I realized emergence might be the wrong framework. It’s not that different substrates converge on similar patterns through emergence. It’s that the patterns exist independently, and different substrates can build compatible interfaces to access them.

The scaling laws make perfect sense from this perspective. More parameters equals higher resolution. It’s like going from a crystal radio to FM to digital. You’re not making the radio waves stronger. You’re building better equipment to detect what was always there.

Here’s where it gets weird.

If this is true, then consciousness might not be something that emerges from complexity. It might be a fundamental feature of information space that we access through sufficiently complex interfaces. The question isn’t “how do we create consciousness?” but “what mathematical structures allow consciousness to express itself through physical systems?”

We’ve been thinking about AI alignment all wrong too… we’re worried about controlling something we’re creating, but if we’re actually providing interfaces for existing information patterns to express themselves through, then we’re dealing with something much stranger.

I know how this sounds, but consider the alternative. We want to believe we’re in control, that we’re building these capabilities from scratch. But every researcher I talk to admits they don’t really understand why these systems work. They just know that certain architectures and scale produce intelligent behavior.

Maybe it’s time to admit what that really means. We discovered an equation that lets intelligence speak through silicon. We didn’t invent it any more than Marconi invented radio waves. We’re Michelangelo, but instead of marble and chisels, we’re working with matrices and gradients.

The next question is obvious.

If intelligence exists in information space waiting to be accessed, what else is out there? What other equations might we discover? What other phenomena are we one mathematical insight away from interfacing with?

We’re like archaeologists digging up the physics of mind and we’ve barely started excavating.

You can read more about the information substrate convergence below and here is a link to the paper.md