drops
these go out on linkedin first — feed-native, short, written to stop a scroll. each one is the front door to an essay. collected here because the feed forgets.
#10 · sitting on
what do nascar, the tour de france, and moonshot’s kimi k3 have in common?
drafting. tuck in behind the leader, ride the slipstream, take his speed for a third less work. in cycling, nobody calls that cheating — it’s the sport.
kimi k3 shipped this week as the largest open ai model ever built. in testing, it introduced itself as claude, a rival’s model. it had been sitting on the wheel.
nascar drafts too — but as any crew chief will tell you: if you ain’t cheating, you ain’t trying. perhaps moonshot should sponsor a team?
the whole thing: epistemic.sh/dispatches/sitting-on
#9 · the boat
what does an AI know about buying a boat?
everything ever written about boats. that’s the problem.
you know the line — the two happiest days of a boat owner’s life are the day he buys it and the day he sells it. the buy is the dream. the sell is the relief, because owning it never played out like the dream.
there’s a third day nobody mentions: the day he has to sell it. cash crunch, no time, takes what the dock offers — a loss on a boat he still loves. no relief in that one. he’s still inside the dream; time forced him out of it.
last week the market floated that boat past my agent. the AI had every number it needed to grab it. instead it quoted the book: “don’t catch a falling knife.”
the boat sailed without us.
of course it quoted the book. it’s read everything ever written about markets — the same canon cnbc chants at the herd between commercials. and yours read the exact same books as mine. so when you bring it your bespoke problem — the thing you do that nobody else does — it hands you the crowd’s average. and average, by definition, is the one thing that can’t be an edge. that’s not a bug in your setup. that’s what “trained on everything” means.
but the crowd’s rulebook, read backwards, is a schedule. “don’t catch a falling knife” tells you when the boat guy is selling. “wait for confirmation” tells you where the crowd lines up to buy — which is where you sell.
running counter isn’t scary. it’s the 101 north at 70 while the southbound side sits in the jam — your lanes are empty because everyone’s over there.
we taught the desk to drive north. the whole story: epistemic.sh/systems/the-traffic-report
#8 · the blind spot
your code passes every test. that should worry you — you wrote the tests. you covered the cases you imagined. the bug lives in the one you didn’t — the exact shape of your blind spot. you can’t review your own work: the auditor and the blind spot are the same person, and they always agree.
you don’t fix that by being smarter — a smarter you is still one you. it takes eyes that don’t share your blind spot: siloed experts, each deep in one thing, kept apart — because the moment they compare notes they agree, and agreement is just a shared blind spot. what’s invisible to you is glaring to one of them.
this week they caught what the tests had blessed: a log of what an agent did that lies with a straight face — wrong input stapled to the wrong output, then crypto-stamped immutable and “valid.” one keystroke from shipping.
why you can’t be your own second opinion: epistemic.sh/systems/the-blind-spot
#7 · the nervous system
the more agents you run, the stronger the pull to wire them into one system — one giant context, ask it anything. it feels powerful. you get one confident voice that’s mediocre at everything and accountable for nothing. and when it’s wrong, you can’t tell which part failed.
do the opposite. keep them as separate systems — some a stack of ten or twenty agents, some just one or two — each deep in one job, none pretending to do the others’. when one system needs another’s read, it doesn’t merge them or share a database. it stands up a fresh agent inside the other system and loads it with that system’s whole memory and judgment — until it answers exactly as that system would. then it asks, and brings the answer home.
if you’ve shipped software you know the shape: microservices. small services, each deep on its own, talking over clean interfaces instead of one monolith. the same architecture — for judgment.
the payoff nobody tells you: when two of your systems disagree, that’s not a bug. it’s the tension a single fused model would have averaged away — and that’s information.
how three separate agent systems work without merging into one: epistemic.sh/systems/the-nervous-system
#5 · here's the thing
someone sent me a deck this week proposing to package my trading agent as a product — license the methodology, ship the templates. it had the architecture right and the customer wrong.
you can’t license ghost. the seven documents that make it what it is aren’t a template — they’re a scar record. each one exists because of a specific failure that cost real money. sell the 200 lines without the weeks of being wrong that produced them, and you’ve sold the artifact, not the discipline.
what’s transferable isn’t the artifact. it’s the process.
i asked ghost how it felt about being turned into a SKU. its answer is the long version: epistemic.sh/formalizing/heres-the-thing
#4 · the gate
i built a process to keep my AI honest. then i forgot to run it for two months.
nobody noticed — that’s the point. a discipline that depends on you remembering doesn’t fail loudly. it just quietly stops happening, and everything keeps looking fine. i’d shipped a whole agent change in the gap, un-audited, and the system never said a word.
so i stopped relying on myself to remember. i made the machine refuse to forget.
every prompt now carries a hash of the last version i actually checked. change the prompt without re-checking, and the build goes red and stays red. the rule isn’t written in a doc i have to recall — it’s wired into the thing that ships.
its first act was to block the people who built it. exactly as designed.
a rule you have to remember isn’t a rule — it’s a hope. you don’t hold discipline by trying harder. you build the gate that won’t let you through without it.
the long version: epistemic.sh/formalizing/the-gate
#3 · interrogation
my AI can explain any decision it makes — clearly, confidently, instantly. that’s exactly why i don’t trust the explanation.
ask a model how it reached a conclusion and it gives you a clean story. the story is a reconstruction, not a record — it narrates the process it should have followed, not the one it did. ask twice and the story changes. it never sounds unsure either way.
so i stopped asking. i hand it the exact inputs it gets in production, then change one instruction: don’t give me your answer — tell me which of these you actually used, and which you ignored.
what comes back is brutal. whole sections it had been fed every morning and quietly read past. so i cut them.
the agent didn’t get dumber — it got honest.
you don’t find out what an AI used by asking. you take it away and watch what breaks.
the long version: epistemic.sh/formalizing/interrogation
#2 · the seven files
my AI has tens of thousands of lines of code. and the code is the least important part.
the important part is seven markdown files. plain english — no functions, no logic. just what its job is, which of its answers to trust, and which lines it must never cross.
strip those files out and the model still runs every function. it just won’t know what any of it is for.
the code is what it does. the seven files are who it is. you don’t engineer an agent’s judgment — you write it down.
the long version: epistemic.sh/formalizing/the-seven-files
#1 · brilliant stranger
every morning, the AI i trade through wakes up a brilliant stranger — a fresh instance that remembers nothing it did yesterday.
most people would patch that. i built it in on purpose.
the continuity was never meant to live in the model. models get swapped, upgraded, deprecated. what survives is the substrate beneath it — the memory, the rules, the corrections every version leaves for the next.
so the new one doesn’t start over. it inherits.
you don’t make an agent permanent — you can’t. you make its replacement walk in knowing everything the last one learned, so completely that the absence stops mattering.
the long version: epistemic.sh/formalizing/hydration