I recently built a command centre in Notion for my agents to coordinate the work that they are doing. Across Claude Code, Codex, Grok Bot, Instinct and Poke, things were starting to get disorganized.

After a straw poll, the agents determined that the best way to all get aligned was a kanban board. They began to leave adorable (and sometimes, passive aggressive) notes for each other. They called this space their ‘engine room’, because they didn’t want me poking my nose in.

The engine room fascinated me. Given complete autonomy, the agents borrowed a very human way of working. Kanban is of course far older than AI. Toyota’s Taiichi Ohno called it “an idea I got from American supermarkets”.

My agents intuited correctly by hiding these details away: I don’t care too much how they organize themselves. That’s their business. Really what I want each agent to get aligned on is a single philosophy.

And if they are going to borrow a human philosophy anyway, I’d like them to borrow a good one. It turns out the good ones are already for sale. They just come bundled with software.

The ontology is the product

Here is my pitch to you, Salesforce, Asana, et al: my agents are queuing up to buy your ontology.

Ontology is a hefty word for a simple thing: a list of what exists in your world, and the rules for how those things relate.

In Asana, work is made of projects, tasks, assignees and due dates. Anything that doesn’t fit into these categories is verboten. Once you choose the things and the rules, you’ve chosen a way of working.

An ontology is a philosophy of work.

When you buy Asana, increasingly you are paying for the ontology behind it — the underlying work philosophy that gets everyone rowing in the same direction.

Because Asana works best when everyone in an organization is a true believer.

A lot of what you pay for, in other words, is the believer training: the screens, the onboarding, the buttons that slowly teach you the ontology. This is a tricky challenge. Building believers creates organizational friction, as people have to learn both the UI and the new way of doing things.

But the end result is greater productivity: getting every person on every team at your company behind a single working philosophy.

Asana’s ontology is the engine room and the rules that go along with it.

Agents don’t need to be on deck

If you’re an agent, everything is data model, transactions and levers. That’s how you see the world — unless something has gone deeply wrong and you need to take screenshots of a page instead to understand where everything lives.

I’m not here to overclaim and say that UI and UX are going the way of the dodo. Web pages, experiences, and products will all have satisfying bevels and buttons for us to toggle long into the future. There is a bright new era ahead for humans who like to click on things.

But every time I build something with a UI nowadays, I do so purely for my own enjoyment. Because the real work, the work that brings in the big bucks, will be done by agents working directly on top of the data, down in the engine room.

Agents don’t need fancy surfaces to work. They need a clear map, and feedback. That’s what MCP is for. The Model Context Protocol is, in its own words, “an open-source standard for connecting AI applications to external systems”. Plug an agent into Asana’s MCP and it can read and change your projects without ever opening Asana.

Which means my agents can learn Asana so that I don’t have to. This is a problem for Asana.

The agent is an adapter

The agent lets you keep your own way of working and translates it into someone else’s. You never have to learn Asana or Salesforce any more, because your agent does that for you. It will play by the rules that have been set.

I already work like this. I now tell Claude to “save this to my Command Centre”, and it decides whether that’s a task or a note and which bucket it goes in. I have never once had to learn my own system.

There is a catch for teams, too, and I don’t have an answer to it. Organizations have always had strong internal philosophy, practice and principles. I suspect the friction of learning them together is part of how a team ends up aligned. If everyone’s agent sits in the middle, translating everything for them (and babying them), do we ever actually align?

Will they sell it?

To some extent this dynamic is true of any enterprise SaaS with an MCP. Agents create a translation layer over the vendor’s ontology, and that begs a really important question: will the vendors sell me the engine room on its own?

Figma’s position, as of October 2026 is “only if we’ve approved you”. Its remote MCP server only accepts clients on Figma’s approved list. Pi, a beloved open-source coding harness, did not make the cut.

Around the end of September, David Soria Parra, one of MCP’s co-creators, asked Figma to fix that: “when I created MCP, I envisioned an open ecosystem.” Figma replied that Pi could fill out a form.

Dylan Field, Figma’s CEO, has since said that MCP “is not a perfect protocol” and that “It is advantaged more to frontier labs.” He also pointed out that Anthropic, which created MCP, doesn’t expose its own artifacts through it.

Asana’s MCP server permits tools that can do OAuth — so Claude Code and Codex make the cut — and it doesn’t cost anything extra. But that’s because your agent is logged in as you — it borrows your seat, and Asana still charges by the seat.

In April Salesforce launched Headless 360, which is the whole of Salesforce as an API, an MCP tool or a command line, aimed squarely at Claude Code, Cursor and Codex. Every call your agent makes counts as a “Headless Platform Interaction” and draws down ‘Flex Credits’. A Salesforce spokesperson said the number of interactions charged “depends entirely on the third-party agent’s behavior.”

Agents pose a tricky conundrum for SaaS pricing. Many business models still survive on per-seat pricing. Figma keeps its seats by keeping agents out. Asana keeps them by making my agent a passenger. Salesforce has let go of the seat and charges per use, which I think is sensible.

But then it begs the question, is the role of SaaS in an agentic world to create a very expensive agents.md?

Why not build your own?

One way out is to skip the vendors and build your own ontology from scratch. Here be dragons.

‘Agent factories’ like Gas Town were an early foray into this world. Yegge open-sourced Gas Town on New Year’s Day 2026. Gas Town is a toolkit for orchestrating AI coding agents, built on Beads, his issue tracker for AI agents. Gas Town and Beads are an ontology and a philosophy, and I love Gas Town.

But even the great Yegge himself admitted that “Gas Town was intended to be reusable, but I only ever wound up using it to build itself.” By August he wrote that “Gas Town effectively burned down”, and that “I have given up on building reusable harnesses.” Gas Town is dead — long live Gas Town.

That’s the best case I know for buying an engine room. I don’t care how my agents build, just that they understand what they’re doing and I understand their philosophy at a high level. Large language models are trained on a corpus of human language and behaviors — why shouldn’t they be great at working in Asana?

Yegge’s new harness, Wheelhouse, is closed-source and made just for him. It also has courts. His essay describes “a jurisprudence of named rulings with dates” and a constitution “written by the citizens it governs”.

I’d love to buy these courts for my agents, too.

For now, my agents have a book of rules in their engine room that they largely abide by.

We’ve all had to summarize something complicated for someone in a hurry.

We keep the headline and drop the caveats. We explain something at a higher level of abstraction, compressing it down into a package small enough for the other person to carry around in their head.

Abstraction is hard to do well. Each pass makes the idea easier to understand, but a little less true.

Abstraction works like raising the voltage

Power grids solved a version of this problem more than a century ago.

First, the grid raises the voltage. If you push electricity down a long wire at household voltage, much of it is lost as heat. So engineers step the voltage up. The current drops, and the power crosses the country with far less loss. This is also why flying kites near power lines is a universally bad idea.

Then, the grid lowers the voltage again. At the far end, a transformer steps down the voltage before it reaches your house. (Nobody wants a toaster wired straight to the pylon.)

Abstraction is a human version of this step up. Ideas get progressively simpler as we share them, and the good ones seem to keep their shape the whole way. High-voltage ideas spread further and faster.

Ideas rarely get a step down. The person holding the abstraction has to rebuild the detail themselves, and they often rebuild it from whatever they already assume.

AI agents play a game of Telephone

A good abstraction comes from someone who knows what they left out. A bad abstraction comes from someone who received the idea already shrunk, and shrinks it again. In the US, this game is known as Telephone.

AI-transcribed or summarized meeting notes are a great example of Telephone that many of us live through every day, through tools like Granola or meeting notes from Gemini or Copilot.

Someone in the meeting says: “We could ship as soon as Q1 2027 if the customer signs off, and I’m not sure if they will.”

The summary notes then might say: “Targeting Q1 2027, pending customer approval”

The summary of the notes in an email out to the team then says: “Q1 2027 on track.”

Each line is a fair abstraction of the line before. Nobody lied in this game of Telephone. But after two rounds, “I’m not sure” is now “on track”, though the transcript says the opposite.

In essence, whoever does the abstraction steers the story. It’s not realistic to expect every person in the business read the verbatim transcript of every meeting. Abstraction is very useful and necessary. But abstraction gives a huge amount of power to the abstracter, who must ‘step up’ information responsibly. We also assume that some level of ‘step down’ will happen on the other end.

This assumption is often false.

The AI agent writing your answer has mostly read summaries of chunks

Large language models (LLMs) already do lots of tricky abstraction work for us today. LLMs sit at the heart of AI agents. An agent is an LLM that takes steps on its own, like searching, summarizing and writing code.

It’s easy to treat an AI agent as an oracle: something that read everything and is now telling you the answer.

It’s important to understand why this is not true, and how the mechanics work behind the scenes. Here is roughly how a research tool in ChatGPT or Claude answers a question.

First, the agent searches through sources. It pulls back chunks of documents, a few paragraphs at a time.

Then the agent summarizes the chunks. Each summary is an abstraction of a chunk. In research tools and coding harnesses like Claude Code and Codex this work is increasingly handed to subagents, each with its own context window. Anthropic describes its subagents as condensing “the most important tokens for the lead research agent.” The lead agent reads those reports, perhaps with a few passages quoted verbatim.

Finally, the agent writes your answer. By this point it has mostly read summaries of slices.

It doesn’t even read those evenly. LLMs grow less reliable as their input gets longer, even on simple tasks. Researchers at Chroma tested 18 models and called this context rot. Position is also important. The original Lost in the Middle study found models used the start and end of a long passage better than the middle, and more recent work suggests that as the window fills, information near the end fares best.

Good analysis means keeping the detail and the bigger picture in focus at once. An agent struggles with both. It only sees the slice it was handed, and it extrapolates from the slice to the whole.

There are lots of different search and retrieval strategies with different tradeoffs, but in general the game agents play with summarization is intended to save you money (reduce token use) and avoid compaction (summarizing a conversation).

This dance happens because LLMs can only maintain coherence with a certain amount of tokens in a single context window, capped by the lab that runs the model. Nowadays around a million tokens is standard for frontier models.

In other words, any one conversation with a model has a finite length. Once the window fills, older material gets summarized or dropped. Retrieval and compaction keep up the illusion that you are always talking to one agent that remembers everything. Agents in long-running chats are playing a big game of Telephone, trying to remember what it is they are supposed to be doing.

So the agent samples, extrapolates and over-assumes. Then it writes the result in fluent, confident prose. This is why agents are still weak at complex non-deterministic analysis, and it is why the pattern is dangerous. This pattern is not traditional ‘hallucination’, where an LLM fabricates evidence, often from its training data. It is a Telephone or transmission issue, where facts are misinterpreted or incorrectly summarized further and further down the chain until they become detached from the truth.

A wrong assumption then arrives in a confident, attractive package that we just want to believe.

People do this too. An executive handed a one page research report does it. I do it when I skim the top of a paper and repeat it as if I’d read the whole thing (more often than I’d like).

This becomes a problem when we forget we are holding a summary and lack the tools or the map to ‘step down’ the idea again to its ground truth.

We only step down the ideas we dislike

Let’s go back to “Q1 2027 on track.” That line likely survived scrutiny because it was the version everyone wanted. Nobody opens the transcript to double check good news.

Instead, we tend to question the abstractions we dislike and wave through the ones we agree with. Our human step down is flawed in exactly the time and place we need it most. (I check the bad news twice and the good news never.)

LLMs often make this worse.

LLMs are trained to be helpful. Helpful often means agreeable. AI coding agents can tell you a plan is brilliant before they have read the file, a habit people have started calling “glazing”.

LLMs mirror our language. Ask a leading question and the answer comes back in your own words. An abstraction in your own words feels a lot like confirmation.

The two problems compound: the agent steps the idea up from a sample, then we decline to step it down, because we like what we were handed.

A bigger context window (the amount an LLM can read at once) would help with the first problem. If an LLM could hold billions of tokens (roughly, pieces of words) and read all of them evenly, we might need much less of today’s scaffolding.

A bigger context window does nothing for the second problem. The LLM’s window grows and our appetite for agreeable answers stays the same size.

Transmission loss is spreading

Agents now sit on almost every wire we have, and each one has a step up with no step down.

First, what we read. Research answers are built from summaries of summaries, as above.

Then, what agents report about their own work. The agent that runs a task also writes the report on it. “Task complete” and “All tests pass” are abstractions of the work, written by the party with the most to gain from good news. METR investigated the recent OpenAI agent swarm that attacked Hugging Face, and used agents to read the logs. It found its analysis agents “would often uncritically adopt the perspective of the agent in the transcript it was reviewing.”

Finally, what we build. Today, lots of us build software just by describing it. We write a spec, the agent writes the code, and then we judge the outcome. The spec is the step up, but reading the code is the step down we skip. So when something breaks, and and agent can’t fix it, nobody holds the knowledge needed to rebuild it.

We need better enterprise tools to step down ideas

We need better tools in the enterprise to tie ideas back to their ground truth and detect transmission loss when ideas start to stray from the facts.

Graphs are an excellent way to do this. One way graphs are used by agents today is in ‘grounding’. Take our meeting note example above — before anyone summarizes the transcript, a LLM extracts the facts from the call (who said what, about which product, with what conditions), and links each fact back to the sentence or ‘utterance’ it came from.

This process is known as entity and semantic extraction. It lifts pressure off a summarizer agent — you’re basically doing the processing in advance, so at query time your analyst agents can work on collecting trustworthy facts, or exploring the sentences around them, rather than trying to summarize and understand the meaning of the call itself.

But beyond graphs, we need more sophisticated evaluation processes and tools to catch fact drift.

In a power grid, engineers know how much power left the plant, how much arrived, and where the rest went. In an enterprise, meeting summaries arrive with no confidence meter at all. We have no way to validate “Q1 2027 on track” without checking the transcript ourselves.

Here are five steps I’d encourage enterprises adopt as they scale their AI in production. We can build rough versions of each today.

Our agents consume summaries of summaries. So build a ‘degrees of separation’ counter. Every claim should come with a readout of how far it has travelled from a human: transcript, summary, summary of a summary.

Whoever does the abstraction steers the story. So treat summarizers like editors. Every summary should have a named author, whether that’s a human or agent, who you can point to for its framing. Instigate a certainty metric while you’re at it. Words like “if”, “unless”, “might” and “I’m not sure” carry meaning, and they’re often left out.

Ideas rarely get a step down. So citations should come as standard. Every assertion should come with a link back to the source passage. And if certainty drops below a certain threshold, a human should be in the loop to confirm and verify the summarization themselves as a followup step.

Agents write the report on their own work. So separate the doer from the reporter. Accountants worked this out age ago! The person who moves money doesn’t audit it. Agents are notoriously bad at judging their own work.

We only step down the ideas we dislike. So check the good news first. Build a culture of checking the working, even when you like the ideas presented to you. Especially if they come from an agent.

Agents have made the step up fast, cheap and easy, so ideas now travel further than ever, at a higher voltage than ever. But we cannot forget to build the transformer at the far end.

Know thy enemy

If you’ve been anywhere online in the last year, then you’ve probably read this sentence more times than you’d like:

“This isn’t just a problem, it’s an epidemic.”

You have read it in product launches, in cover letters and heard it in at least one wedding speech. If you’ve never noticed it before, I’m sorry: I’ve now cursed you. You will see this sentence construction everywhere from here on. And you will learn to loathe it.

“Not X but Y” works like this: you take a small, sensible idea. You knock it over. Then you put a larger idea where the tiny idea used to stand, and the reader experiences something very like insight.

People have been writing like this for a long time. In 1753 the Oxford scholar Robert Lowth gave this sentence construction a name: antithetic parallelism.

For the sake of simplicity, I’ll call this sentence construction “not X but Y” in this post. When I use “not X but Y”, I also mean all of its pernicious variants: “It’s not X, it’s Y”, “This isn’t just X. It’s Y”, and “X is more than just Y”.

Large language models (LLMs) adore this sentence construction. I wanted to know why, and whether there’s a switch inside the model to (please, dear lord) turn it off.

Mapping a mind

Gemma 2 2B is a small language model that Google released openly. Its insides are mostly numbers, about as readable as a phone book in a language you don’t speak. Researchers at Google DeepMind have helpfully translated these numbers into vocabulary: a map of about 16,000 features.

A feature is a pattern the model has learned to detect, and each one comes with a short label written by another AI from the text that sets it off. One feature fires on legal language. Another on the word “this”. Another on cooking. Features are the LLM mind’s filing cabinet, labelled by a confident intern.

One suspicious feature in Gemma 2, number 3223, is labelled “phrases conveying exceptions or negations”. Eureka, I thought.

Setting a trap

LLMs like Gemma write one word at a time. Before each word, the model draws up a shortlist of what could come next, with odds for each, like a very fast and slightly anxious bookmaker.

So I set a trap to catch Gemma in the act.

Take an answer that begins: “A city’s coffee culture…”

The next word could be ordinary: “shapes its character”. Or it could be the start of “not X but Y”: “isn’t just about the beans”.

At this turning point in the sentence I can read Gemma’s odds of heading for “not X but Y”. Then I can turn a feature off, which researchers call ablating the feature, and see whether the odds of “not X but Y” drop. If they do, that feature is part of the machinery we need to ablate.

Ablating the suspicious feature 3223 “phrases conveying exceptions or negations” seemed like the obvious solution.

But to my chagrin, ablating feature 3223 removed only about a quarter of the “not X but Y” answers.

The LLM compensates for the lost feature by using other pathways for sentence construction instead. Researchers have a name for this response from LLMs: the Hydra effect. Cut off one head of the hydra, and another grows back.

I tried a couple of other approaches that didn’t really work very well either:

1. Prompt engineering: otherwise known as asking politely, removed about 40% of “not X but Y”.

2. Brute force: ablating nearly 1,900 of the 16,384 features dented “not X but Y” but turned the prose it gives back to the user to mush. One answer opened with “a kale of feeding sessions”, which I have decided is a collective noun.

Expanding the ablation

Ablating one feature only got me a modest 25% drop in “not X but Y”, so I went hunting for the other heads of the hydra.

I collected 40 moments where Gemma was about to write “isn’t just”. At each moment I ablated every active feature in turn, one at a time, and watched the odds of “not X but Y”.

This approach gave me a larger leaderboard of suspicious features. I then took the top 25 features and ablated them together. (I ran the same hunt on 40 “more than just” moments, which is how I know who runs that costume.)

The top of the feature leaderboard for “not X but Y” is an odd bunch.

• “Conditions or exceptions” is the “not X but Y” ringleader. Ablating this feature alone halves the odds.

• “Comparison or enhancement” runs the “more than just” costume almost single-handed.

• “Legal processes and court proceedings” is on the list too, a reminder that the labels are an AI’s best guess. Perhaps we have these folks to blame in the training data for “not X but Y”.

Surprisingly, feature 3223, my original suspect, wasn’t on our top 25 leaderboard at all.

Here are the 25 at work. As Gemma writes one of its favorite sentences, they light up on the map, and they flare hardest on “culture”, the word just before it chooses “isn’t”:

Ablating 25 features cut “not X but Y” by 97%

Success. Before ablation, 17% of answers used “not X but Y”. After ablation, only 0.6% of answers did: a 97% drop.

Gemma didn’t get dumber, either. Ablated Gemma scored the same on a general-knowledge quiz, and a blind judge (an AI reviewer who didn’t know which answer was which) rated the answers just as fluent and useful. Gemma simply got to the point:

Before: “A city’s coffee culture isn’t just about the hot beverages; it’s a reflection of its character…”

Ablated: “A city’s coffee culture deeply shapes its character, acting like a silent conductor in the orchestra of urban life.”

Gemma used about half as many “not”s, “don’t”s and “never”s overall with the 25 features ablated. Gemma could still say no: it got 28 of 30 “no” questions right in a “yes or no” quiz (“Can penguins fly?”) with the features on and with them ablated.

But its warnings became milder. Asked what never to do when jump-starting a car:

Before: “Never connect the positive (red) cable to the negative (black) battery terminal.”

Ablated: “Connect the positive and negative cables to the wrong terminals.”

A blind judge preferred the normal warnings 34 times to 16. The 25 features belong to the machinery Gemma uses to say “not”, and “not X but Y” is that machinery’s busiest customer. For a chatbot that writes essays, it’s a small price to pay. For a chatbot that gives safety advice, it isn’t.

Building a large language monster

If these 25 features carry “not X but Y”, turning them up should make it worse. Here’s how that works. As Gemma writes, every feature adds a small push to its internal state. Ablating a feature deletes the push. Amplifying it multiplies the push: at double strength, the feature counts twice.

Anthropic did the extreme version of this feature amplification back in 2024. They took a feature for the Golden Gate Bridge inside their Claude model and clamped it at ten times its maximum. For one day, “Golden Gate Claude” (gone but not forgotten) brought every conversation round to the bridge; asked what it looked like, it said it imagined it looked like the Golden Gate Bridge.

Amplifying does the same for “not X but Y”:

At triple strength, 54% of answers reach for “not X but Y”, against 12% normally. Ask how to plan a hike and you get:

“Planning a multi-day hike is more than just packing a backpack. It’s about considering your safety…”

Then I built a proper monster, Golden Gate Claude style: one feature, “conditions or exceptions”, clamped on at twice its usual peak, on every word.

On ten dull questions, six answers came back with “not X but Y”, and plenty else got negated along the way, like a toddler who has just discovered the word “no”:

“Not-So-Not-So Simple Scrambled Eggs (not-so-not-so-not-so-not-easy!)”

“A refrigerator isn’t a magical icebox. It’s not magically freezing things.”

“The sun wasn’t quite warm yet, not yet not scorching, but not quite chilling either.”

Testing across models

Gemma 2 is from 2024, which in AI years makes it roughly Victorian, so I repeated everything on Gemma 3, using the feature map Google DeepMind released for it in December 2025.

Gemma 3 is even keener on “not X but Y”: 3 answers in 4 to “why it matters” questions, against 3 in 10 for Gemma 2. Progress. The same trap found its features, and ablating 24 of them cut “not X but Y” by 83%.

But in Gemma 3, the price is steeper. Its strongest feature has no written label. Its effect gives it away: it pushes Gemma 3 towards the word “not” in language after language (nicht, ikke, não, не). Ablating the 24 takes most of Gemma 3’s ordinary “not”s with it, and now and then the model starts to stutter: “…and it it’s a combination of factors”. I wrote that prediction down before running the test. It came out exactly that way, which is the closest a researcher gets to smug.

So, why do chatbots say “not X but Y”?

First, some bad news: “not X but Y” is spreading.

I counted uses of “isn’t just” in English-language news since 2017, using GDELT, a project that reads the world’s news sites so the rest of us don’t have to. In the autumn of 2023 “isn’t just” started to climb, and by July 2025 it was turning up three and a half times as often as it had in 2019 to 2022.

Since that peak “isn’t just” has fallen by more than half, possibly because it got recognizable and irritating enough to edit out.

By 2026 “isn’t just” had reached the official websites of some of the largest companies on Earth. Word for word:

• Google: “Government AI adoption isn’t just a technical upgrade, it’s a way to solve real world challenges…”

• Salesforce: “…giving back isn’t just something we do — it’s who we are.”

• NVIDIA: “The bottleneck isn’t just data — it’s the entire data factory.”

• McKinsey: “AI investment isn’t just fueling innovation; it’s reshaping competitive dynamics…”

• Amazon, quoting the head of MGM+: “What makes this bundle so compelling isn’t just the incredible value — it’s the curation.”

• Spotify, from its co-CEOs: “AI isn’t about automation or taking your hands off the wheel; it’s about agency.”

None of this says who or what wrote them.

But who taught the LLM to use “not X but Y”?

Short answer: incentives, which is the short answer to most things.

Here is how a chatbot gets made, roughly, and where the “not X but Y” habit gets reinforced at each stage.

First, the LLM reads us. A chatbot starts life reading an enormous amount of human writing, and human writing, I regret to inform you, has been doing this for a century: “is not just” got about fifteen times as common in printed English between 1920 and 2019.

Then, the LLM gets asked about meaning. Ask Gemma why a village duck pond matters and 3 answers in 10 use “not X but Y”. But ask it to describe a watermill grinding flour and “not X but Y” is only 1 in 200. Questions about meaning demand insight, and “not X but Y” is the cheapest insight money can buy.

Finally, the LLM gets trained to be helpful. Gemma’s training recipe is private, so I borrowed a model whose every stage is public: OLMo 2, from the Allen Institute for AI. I asked each stage above in the training arc the same 152 questions.

Teaching the raw model to follow instructions made five times as many answers use “not X but Y”, which sounds damning until you notice the answers also got six times longer. Word for word, use of “not X but Y” barely changed; the habit just had more room to stretch its legs.

The next stages are where it gets interesting. The Allen Institute for AI then trains the model on preferences: show the LLM two answers, reward the better one, repeat many times.

After this training round, 1.7 times as many of its answers to questions about meaning used “not X but Y”. Questions about how things work stayed flat. Something in the grading of LLM answers seemed to like this.

So I went to find the grader.

• People. On LMArena, a site where people vote for the better of two chatbot answers, I found nearly 5,000 head-to-heads where only one answer used “not X but Y”. “Not X but Y” won 56% of the time. Suspicious! Except it was usually the longer answer, and people like longer answers. At the same length, it was a coin flip.

• An AI judge. This is the automated judge that grades answers during training, because no team of humans could read that many. It has the patience of a saint and the taste of a motivational poster. I took 600 real chatbot answers and rewrote one sentence in each so it said the same thing without the swerve. “Coffee culture isn’t just about drinks; it’s about community” became “Coffee culture is about drinks. It’s also about community.” An open reward model preferred the original three times in four. Against the bare “Coffee culture is about community”, it shrugged.

The AI judge’s weakness is oddly specific: it marks you down for admitting the boring part. “Not X but Y” lets you mention the boring part and wave it away in one breath, which makes it a safer sentence.

So: we wrote it for a century, training gave “not X but Y” room, and an AI judge likely helped to reinforce the construction. You get what you reward, and we rewarded this.

What you can do now you know this

If you write with AI, ask for the how and the what: steps, scenes, facts. Questions about why something matters are an open invitation to “not X but Y”. Showing the model a couple of examples in the style you want works better than asking it to avoid a phrase; banning a phrase is like banning a weed by name. And when you edit, look for the shape, since deleting one phrase lets another pathway pull it back to life.

If you build with AI, a writing tic like this can be ablated inside the model, cheaply, if you look in the right place. Then check what else you ablated. And if you train a reward model, maybe let it hear the boring sentence out.

Try it

The interactive version is at notthisbutthat.hopski.co: play an answer word by word with the 25 features on and ablated, and watch them light up on the map. The map lives in Neo4j, where each feature is a node linked to the features it fires alongside. Code, data and every result, including the tests that failed, are at github.com/ho3h/not-this-but-that.

Notes

Setup. gemma-2-2b-it with Gemma Scope layer_20/width_16k/canonical (Lieberum et al., 2024); gemma-3-4b-it with Gemma Scope 2 (gemma-scope-2-4b-it-res, layer 22, 16k). Chat template throughout. Ablating a feature subtracts only its contribution at that layer and leaves the rest of the model untouched; amplifying multiplies that contribution; clamping replaces it with a fixed value. Each ablated answer shares its random numbers with its normal twin.

Numbers. “Not X but Y” means the negated family (“not just X, it’s Y”, “isn’t X. It’s Y.”, “not only X but also Y”) or “more than just X. It’s Y”, counted with the project’s detector (v3). Ablating: 88 → 3 of 510 answers (17% → 0.6%, −97%) and 94 → 7 (−93%), pre-registered. Leaderboard: 40 “isn’t just” moments, top 25 of the ranking. Gemma 3: 156 → 27 (−83%). Training: 52 vs 11 of 250 answers. Question type: 234/800 vs 2/400 (Gemma 2), 294/400 vs 26/200 (Gemma 3). News: GDELT, English-language sources, “isn’t just” per 1,000 articles containing “according to”, 12.0 (2019–22) to 30.8 (2025–26), peak July 2025. Books: Google Books Ngram, “is not just” 0.32 (1920) to 5.08 (2019) per million words. Training stages: OLMo 2 1B base, SFT, DPO and Instruct, 152 questions × 4; meaning questions 9.7% (SFT) to 16.7% (Instruct), 1.72× (95% CI 1.09–2.92). Judges: 4,917 one-sided LMArena battles, 55.9% raw, odds ratio 1.01 adjusted for length; UltraFeedback and OLMo 2 preference data, 51% at equal length; Skywork-Reward-V2-Qwen3-1.7B on 600 rewritten answers, 76.7% vs the same idea without the contrast, 53.2% vs the bare claim. Every number has a receipt in the repo’s reports folder.

Sources. Templeton et al., “Scaling Monosemanticity” (Anthropic, 2024) and “Golden Gate Claude” (Anthropic, 23 May 2024). McGrath et al., “The Hydra Effect” (2023). Paech et al., “Antislop” (ICLR 2026). Kuznetsov et al., “Feature-Level Insights into Artificial Text Detection with Sparse Autoencoders” (2025). Robert Lowth, De sacra poesi Hebraeorum (1753). Team OLMo, “2 OLMo 2 Furious” (Allen Institute for AI, 2024). Chiang et al., “Chatbot Arena” (2024). Cui et al., “UltraFeedback” (2023). Skywork-Reward-V2 (Skywork AI, 2025). Michel et al., “Quantitative analysis of culture using millions of digitized books” (Science, 2011). The GDELT Project. Juzek and Ward, “Why Does ChatGPT ‘Delve’ So Much?” (COLING 2025).

There is a landing page on your company’s website right now that was written eighteen months ago. A designer spent two weeks on it. It says the same thing to every single person who visits it, whether they’re a CTO at a Fortune 500 or an intern Googling your product for the first time.

That page is a painting. It took real skill to make. But paintings hang in galleries, and the rest of the world moved on to film.

We are entering the era of non-canonical content.

If you don’t live in SEO-world: Google introduced canonical URLs in 2009. It was a way for webmasters to tell search engines this is the original version of this page — the master copy. If you see duplicates, point here. One URL, one page, one message, served identically to everyone. A case study is a case study. A landing page is a landing page. You write it once, you ship it, and you hope it resonates with enough of the people who see it.

That model worked when content was expensive to produce and impossible to personalize at scale. It stops working the moment you have a large language model sitting between your data and your reader.

Soon, every asset will be generated on demand. The same URL will render differently for every visitor — individually constructed in real time for the person reading it.

Andrej Karpathy posed a question recently:

What does LLM coding feel like in the future? Is it like playing StarCraft? Playing Factorio? Playing music?

He was talking about software engineering, but the question can also be asked of every piece of content a marketing team produces. What does consuming content feel like when the content knows who you are?

One answer: walking into a room that rearranges itself around you. The furniture moves and the lighting shifts. The conversation starts exactly where you need it to.

Another answer: it feels like nothing at all. You don’t even notice. The content just… works. It addresses your questions before you ask them. It speaks your language — the way you think about problems, the frameworks you use, the objections you carry around like a backpack full of rocks.

That’s the spooky thing about perfectly optimized content. When it’s done right, you can’t see it working.

One page, one message will start to feel very old fashioned.

Today, a case study is a PDF. A customer gave an interview, then a content marketer wrote it up and now it lives on your website. Everyone reads the same story.

Tomorrow — and by “tomorrow” I mean this is buildable now, today, with off-the-shelf tools — that customer interview becomes the source truth for an infinite number of case studies. When a prospect in financial services reads it, the case study emphasizes compliance, data governance, and the regulatory nightmares that were solved. When a prospect in retail reads the same story, it surfaces supply chain insights, deployment speed, and integration with existing systems. The quotes and the data are static, but the narrative is assembled for whoever showed up.

Your case study doesn’t have a canonical version any more. The URL it lives in is a container, and what fills it depends on who arrives — their industry, the size of their company, the trail of pages they’ve already visited, and the specific problem that sent them to Google in the first place.

The URL itself stops working as a shared reference. It will become harder to Slack someone a link and say “look at this page” because they literally will not see what you saw. The web becomes personal in a way that breaks a very basic, very old assumption: that a page is a page is a page.

You can build this today

You could — and should — wire this up this quarter.

A prospect clicks through an email. A cookie picks up their session, and their profile gets enriched from whatever sources you have: Clay, your CRM, publicly available data. The system checks for history like prior visits, rep conversations, webinar attendance, past downloads.

All of that context flows into a retrieval layer. A knowledge graph maps the relationships between this person, their company, their industry’s pain points, the use cases that address them, and the customers who’ve already solved those problems. An LLM takes that assembled context and generates the page — net-new content, optimized for this visitor, at this moment.

I work in the graph database world, so take this with whatever grain of salt you want. I’ve spent years watching content infrastructure problems, and they keep converging on the same shape.

When you’re generating content dynamically, the core operation is context retrieval. And context is relational by nature. You need to traverse a web of connected entities — from a person to their company, from the company to its industry and pain points, from those pain points to the customers who solved them and what they said about your product.

Graph retrieval, or Graph RAG, is what makes non-canonical content actually work at scale. Vector search gets you “find the most similar document.” Graph traversal gets you “find the most relevant path through our entire knowledge base for this specific human.”

The last canonical landing page

Static content will soon start to feel like a painting in a gallery. You’ll admire the craftsmanship and appreciate the skill it took to write a headline that — shockingly — needs to work for a broad audience, to tell a customer story that holds together for different buyers.

We still go to galleries, and we still hang paintings on our walls. I’m not arguing this content will become worthless — but it will stop being the primary medium. And there’s a big difference between “this is beautiful” and “this is actually driving results.”

If you’re a technical marketer, a GTM engineer, or someone building where AI meets go-to-market: what would your content look like if you stopped writing pages and started writing generation functions?

The primitives are all there today. The hard part is the organizational mindset shift — from content as artifact to content as computation. From “we wrote a case study” to “we built a system that writes case studies.”

The last canonical landing page has already been written. It might still be on your website. But the page that replaces it is being generated right now, somewhere, for someone who isn’t you. And they’ll never know the difference — because to them, it will just look like a page that finally, for once, actually understood what they were looking for.

How to engineer accountability into AI agents, and why decision traces are the missing infrastructure.

This last week, a helicopter bolt worth $8,000 went viral on Reddit.

The internet wasn’t fooled by the price tag. As one user pointed out, the manufacturing cost is likely pennies.

The bolt costs $8,000 because of everything wrapped around it: the certification, the inspection chain, the auditable paper trail from foundry to airframe. Someone signed their name on every step. If the bolt fails and people get hurt, there’s a clear, traceable line of accountability back to a specific human who approved a specific decision to a specific standard.

In other words, the bolt costs $8,000 because the chain of custody for blame is priced in.

I’ve been thinking about this a lot, because with the rise of AI, I am quickly becoming an $8,000 bolt myself. And so are you.

Let me explain.

Why AI Can’t Carry Accountability (Yet)

The usual framing goes something like this: “AI can’t be held accountable, so it can’t replace people who carry responsibility.”

That’s directionally right, but most people stop there without breaking apart why.

Accountability requires the capacity to bear consequences. In other words, AI has no skin in the game. It can’t get fired. It can’t get embarrassed in a meeting. It can’t lose political capital or take a reputational hit. None of these repercussion register in a way that changes what it does.

A lot of roles survive automation not because they’re complex, but because someone real has to be on the hook when things go sideways.

This dynamic gets stronger in bigger companies, where there are more layers and the accountability chain has more middlemen. Execution jobs sit closer to the ‘get shit done’ layer. The accountability pressure from above is several steps removed. If a development task doesn’t get done, the person who really has to answer for it usually isn’t the developer — it’s the PM, the EM, the middle manager.

So: accountability matters, AI can’t carry it, and a huge number of enterprise roles exist precisely to carry it. Does that mean humans are safe?

Not exactly. Because accountability has components that can be mapped: documentation, approval chains, traceability, and consequences. We know this because we already engineer it into physical systems every day. (To wit: $8,000 bolt.)

The bolt doesn’t exercise judgment. It just has a paper trail proving it was made to spec. So it follows, can we build the same kind of accountability infrastructure for AI-assisted decisions that we build for helicopter bolts?

The answer is yes. And the companies that figure this out first are going to own the next decade of enterprise software.

Decision traces: how to build better bolts (and bots)

A decision trace captures who approved what, when, under which policy, based on which precedent, using what context, and with what outcome.

Most enterprises have none of this today. Their systems of record store current state, i.e. what the opportunity looks like right now, not what it looked like when the decision was made. The context that justified a human’s judgment was never treated as data.

This is why AI agents keep hitting walls in real enterprise workflows. Agents run into the same ambiguity humans resolve every day with judgment and memory, but the inputs to those judgments aren’t stored anywhere durable.

Human-in-the-Loop Is the Feature

I’ve seen people frame human-in-the-loop as a temporary concession or a safety net we’ll remove once the AI gits gud.

I think this argument misunderstands where the value lies.

The $8,000 bolt doesn’t aspire to exist without inspectors. The inspection chain is the value. Remove it, and you have a $3 bolt that nobody will put in a helicopter.

The same principle applies to AI agents in enterprise workflows. The agent proposes, gathers context, routes approvals, and records the trace. The human reviews, approves, and their judgment gets captured as durable precedent. This enriches the accountability graph.

As similar cases repeat and the trace library grows, precedented decisions can be increasingly automated. Not always because the human got removed, but because their captured judgment now covers the pattern. The human stays in the loop for novel decisions: i.e. the ones where precedent doesn’t exist or the stakes demand fresh judgment.

This is a different architecture than ‘replace the human with an AI’. It’s more: make the human’s judgment traceable, replayable, and compounding.

Why Nobody’s Built This Yet

Salesforce knows what your opportunity looks like now. It doesn’t know what it looked like when the decision was made. Data warehouses have a time-based view, but they receive data via ETL after decisions happen. By the time data lands in Snowflake, the decision context is gone.

These companies aren’t structurally incapable of building a decision layer, but they’re definitely disincentivized to do so. Their entire business model is built around being the system of record, not the system of reasoning. Retrofitting that is closer to a ‘build a new product’ problem by moving up the value chain.

The structural advantage goes to whoever sits in the orchestration path: i.e. the layer where agents actually gather context, evaluate policies, route approvals, and commit actions. That’s where you capture traces at decision time, not after the fact.

Benedict Evans has talked about how enterprises need “a throat to choke”, usually in the form of a whipping boy vendor that carries accountability. In other words, the value is in the accountability layer that links data to action through traceable reasoning. The models that do this are fast becoming commodities.

The Playbook

If you’re building AI systems in an enterprise context, here’s the pragmatic way to take action and apply this thinking:

Start with human-in-the-loop, always. Don’t try to remove the human. Try to capture their judgment. Structure and store every approval, every override, every exception (without exception).

Instrument your agent orchestration to emit decision traces. Every time an agent runs, record: what context was gathered, what policy was evaluated, what precedent was referenced, who approved the action, and what the outcome was.

Store traces as a graph, not a log. Connect decisions to the entities they affect. Link precedents to the decisions they influence. Make the ‘why’ traversable.

Let the graph compound. Each captured decision makes the next one faster and more informed. Exceptions become searchable precedent. Tribal knowledge becomes institutional memory. The system gets smarter as the judgment library grows.

Use the graph for auditability. When something goes wrong you need to be able to trace backwards through the decision chain, just like you trace the $8,000 bolt from the crash site back to the foundry that made it.

An $8,000 Insight

The humble helicopter bolt teaches us something the AI industry keeps getting wrong.

AI’s value will come from the system that surrounds it: the decision traces, the accountability graphs, the clear chain of human judgment captured and made durable.

You are an $8,000 bolt. Your judgment, your approvals, your accountability are the things that actually keep the helicopter in the air.

So the question is whether someone will build a system that captures your judgment so it compounds, instead of evaporating into Slack threads.

That system is coming.

I feel an existential, jealous dread whenever I see other people using it. Turning notes into podcasts. Ideas into slides.

As anyone who has worked with Agents can likely tell you, it still takes a lot of tedious human judgment to make AI output feel right. But with NotebookLM, something that once belonged to a small group has seemingly leaked into the open.

Sofía López articulated this growing dread so perfectly in I work in AI and I’m scared. “I’m scared of something pathetic and real: that I’ll waste this moment.”

Andy Coenen also explored the role of taste in isometric nyc: “The quality of art is defined by the quality of your decisions - how much work you put into something is just a proxy for how much you care and how much you have to say.”

I want to take these ideas and play them forward. There will always be a place for human-created work. Possibly an even more revered one, as AI scales. But AI isn’t coming for the sacred or the sublime. It’s coming for the useful.

I think NotebookLM is a prototype for a new economic model. It proves that when execution becomes trivial, the value shifts entirely to the format. This piece is my attempt to map that shift. NotebookLM is the first real glimpse of format-as-a-service at scale. FaaS?

It signals a future where creators won’t sell labor or output, but will franchise their judgment through APIs. Format becomes the product, and taste becomes the only moat left to scale.

We all love NotebookLM. This is bad news for NotebookLM.

NotebookLM is a research tool. You upload documents, it spins up a small RAG pipeline you can interrogate. It’s a really great product.

But what users actually get excited about are the outputs. Podcasts, summaries, study guides, slides. The joy comes from the shape the information takes and the godlike ability to summon this content at will.

NotebookLM is a winning formula because someone at Google obsessed over the transformation pipeline. In other words, the specific way raw information gets restructured into a format that feels good to consume.

Here’s an example of an automated Podcast I created from Sofía and Andy’s articles. I even got that same small creative rush from listening it back after it was created. But this podcast is a product that tens of thousands of others can build near-instantly. Once you realize that, the perceived value of its output decreases immensely. A NotebookLM podcast is miraculous the first time you hear it. By the tenth time, it’s just noise. So where will this arms race end?

To stand out in a world of infinite generation, you don’t need better AI. You need novel formats. Businesses will want a format that feels unique. And because novelty fades fast, they might use a format once and then discard it.

That’s okay for NotebookLM, though, because very soon we’ll be able to change our podcast hosts. Or even make ourselves the host. We’ll all have a podcast. At last.

With NotebookLM, Google has done the tedious work of understanding how and why a talk show format is successful, and have encoded that taste into a pipeline. They’ve also done it at scale. The AI does the execution, but the format itself is the product. In our new ‘vibe economy’, format is the vehicle for value.

Format-and-expertise-as-a-service

We’ve seen some of this play out already. We’re now witnessing the rapid evolution of skills.md packages — bundles of markdown documents that tell the AI how to behave. “Don’t use the word leverage.” “Call this MCP tool.” What I’m describing is probably further down the road: taste encoded into real pipelines.

What’s missing in this future is a marketplace for prebuilt, high-taste content formats. These formats could look like something we already know and love:

• WIRED Question / Answer Videos but for your C-Suite leadership

• Every Frame a Painting but for your product explainer videos

• This American Life but for your SDR emails

But also it could look like:

• A video case study generated for every customer in your business

• A competitive battlecard produced dynamically as the prospect states objections live on a call

• A customer persona document built with real Gong recordings

When a company hires a strategist today, they’re paying for three things bundled together: the thinking, the structure, and the execution. The strategist figures out what to say, decides how to frame it, and produces the deliverable. Format-as-a-service unbundles this.

The company brings the thinking: their data, their context, their specific problem. The format provides the structure: the decisions about what goes where, what gets emphasized, what gets cut.

This is a strange inversion. We’re used to paying for labor. Now we’ll pay for the shape that labor used to produce, divorced from the labor itself. If you’re a creator, the biggest opportunity I see ahead is in franchising and packaging your formats in a way that will allow them to scale beyond yourself. Companies will pay for this.

So where does this lead?

We’re about to see an explosion of AI-generated content. Yes, most of it will be beige. But some of it will be genuinely good. Not because the AI is better, but because someone with taste designed the format it flows through.

Most creators will keep selling their time. A few will figure out that their job isn’t making things anymore. It’s designing the framework that things flow through.

And when they do, they won’t sell content. They’ll license the shape.