Not subscribed? Sign up to get it in your inbox every week.

At 5:21pm on June 12, the most capable model on the market got switched off. It was three days old.

Anthropic shipped Fable 5 on June 9. On June 12 came an export-control directive from the US government, which believed someone had found a way to jailbreak the model; Anthropic disagreed with the call and complied anyway, suspending access to Fable 5 and Mythos 5 for everyone. Access came back on July 1. OpenAI offered no refuge that month either: GPT-5.6 launched into a preview limited to roughly twenty government-vetted organizations, at the White House's request, and opened to the rest of us only after a twelve-day gate.

Here is what happened during the nineteen days in between: almost nothing. Teams dropped back to Opus, the previous flagship, took the capability haircut, and kept working. When Fable came back on July 1, they switched again, and the whole episode registered as a shrug. But the shrug is the interesting part. An entire market lost its best model overnight and lost nothing else: the prompts still ran, the playbooks still applied, the automations still fired, just with a slightly dimmer engine behind them. The swap was painless because nothing anyone had built actually lived inside the model.

That split is what this post is about. The model is rented. Everything above it can be owned.

Intelligence stack is a grand phrase for a simple inventory. When AI does real work in your company, five layers are involved, and only one belongs to the vendor.

The model. Rented by the token, improving on someone else's schedule, and more interchangeable every quarter. Renting is still the right default, though this is the one layer whose rules started changing this week; hold that thought.

The context. What the system knows about your business: the warehouse, the docs, the tickets, the CRM, and the connections that put all of it in front of the model.

The skills. How your company does the thing. The steps, the exceptions, the tone, the thresholds, the judgment calls that live in your best operator's head until someone writes them down.

The evals. Your definition of good. The checks that tell you an output is right before it ships, and the test cases that tell you whether a new model handles your work before you commit to it.

The automations. Where the work actually runs: the scheduled jobs, the agents sitting in your channels, the triggers wired into your systems.

One layer is a commodity. The other four are your institutional knowledge wearing a new file format, and each of them can live in artifacts you control instead of inside somebody's product. That choice, more than which model you pick, is your actual AI strategy.

Run that inventory at most companies and the answer is uncomfortable. The prompts live in personal chat histories, the playbooks in the head of whoever built the workflow. Evals live nowhere, which is why every model upgrade feels like a leap of faith. None of it is owned, because none of it exists in a form that could leave the tool where it was born.

Ramp is the cleanest public example I've found. In April, Seb Goddijn published a post on Glass, the internal AI suite Ramp built for its employees, and it rewards a close read. Ramp had hit roughly 99% AI tool adoption, but most people were stuck at the same plateau. Eric Glyman, Ramp's CEO, described the blocker in public: the models were good enough, and the setup (terminal configs, MCP servers, everyone figuring it out alone) was what kept people from going further. Glass attacked the configuration problem first: install it, and it wires itself into your internal tools and data sources through your Okta login.

The layer worth stealing, though, is Dojo, Ramp's internal skill marketplace. A skill is a markdown file that teaches an agent a specific task. Ramp has more than 350 of them, shared across the company, git-backed, versioned, and reviewed like code. A CX engineer built a Zendesk skill that pulls ticket history, account health, and resolution paths, shipped it to Dojo, and the whole support team leveled up overnight. A finance lead scheduled a job that posts yesterday's spend anomalies to the team channel at 8am. A recommender called Sensei suggests skills based on your role, your tools, and your recent work, so one person's breakthrough becomes everyone's baseline.

Now read the substrate underneath all that: the skills are markdown, the version control is git, and the review process is the one Ramp already used for code. Knowledge in that shape survives a model swap, because plain instructions in plain files carry over to whatever engine reads them next. Ramp's edge is 350 text files under version control. Owning your intelligence stack looks exactly that boring.

June handed every operator a free diagnostic: could you change model vendors in a weekend?

Walk the layers honestly. Context: do your data connections run through standards you configured, or through one vendor's proprietary integrations? Skills: could you export your prompts and playbooks as files this afternoon, or do they live inside a product you log into? Evals: when a new model claims to be better, do you have a test set that proves it against your actual work by Friday? Automations: are they triggers you own pointed at a model API, or features inside someone else's platform?

June was the easy version of this test, and everyone passed without studying, because the fallback sat one rung down on the same platform and the vendor flipped the switch for the whole market at once. The versions worth preparing for are harder: a directive that takes out a vendor instead of a model, a product you depend on getting acquired or shut down, a price change that breaks your setup's economics. Access to frontier AI is now contingent on export directives, jailbreak findings, and voluntary frameworks negotiated far above your head. Nineteen days and one rung of capability was the gentle version. Nobody will consult you about the next one either.

Vendor products still belong in the stack; buying is fine, and mostly unavoidable. The test is what a product lets you take out. Ask every AI tool in your stack the exit-interview question: if we left in six months, what walks out with us? Files walk out. Configurations of somebody else's features stay behind.

Last week I wrote about forward deployed engineers and who owns the outcome when you buy AI. This is the follow-on question, with a sharper edge: when the vendor's engineer finishes embedding inside your company, where do the artifacts land? The skills, prompts, and eval sets that engagement produces are your operating knowledge. Write it into the statement of work that they land in your repo, in portable formats, because paying a vendor to move your own know-how into their building is the quiet failure mode of every AI services deal.

Everything so far treats the model as the one layer you rent by necessity. This week that assumption picked up an expiration date. Thinking Machines, Mira Murati's lab, released Inkling yesterday: an open-weights model, Apache-licensed, weights sitting on Hugging Face, and by the lab's own admission not the strongest model you can buy. That admission is the strategy. Inkling is built as a base for companies to tune on their own data for their own workloads, through Tinker, the fine-tuning platform the lab shipped first. The bet is that the durable advantage belongs to whoever closes the loop between proprietary data and a model continuously shaped by it, on weights they control.

Set aside whether Inkling itself wins. Look at what tuning a model to your company actually consumes. Training data that captures how your work gets done: that is your context and your skills. A way to prove the tuned model beats the rented one on your tasks: that is your eval set. Every input to owning a model is a layer from the list above, which means the companies positioned for the open-weights era are exactly the ones that own their stack already. The skill files you write this quarter are the tuning corpus you own a model with next year.

Owned weights also close the loop June opened. A model running on infrastructure you control has no remote kill switch.

The whole thing starts embarrassingly small.

Pick your ugliest recurring process, the one held together by tribal knowledge and Slack archaeology. Have the person who runs it best write it down as instructions an agent could follow: the steps, the exceptions, the thresholds, what good looks like. Save it as a markdown file. Put it in version control, even a bare repo named skills with one file in it. That file matters more than it looks, because it is the first piece of your company's operating knowledge that exists outside a person's head and outside a vendor's product at the same time.

The second file is even easier. Write down ten real examples of the task with what a good answer looks like for each. That plain list is an eval set, and it is the difference between switching models on evidence and switching on vibes.

Then run the census. List every prompt, playbook, and automation your team actually uses, and mark where each one lives. Count how many you could take with you tomorrow. That number is how much of your intelligence stack you own today, and every file you add moves it.

Ramp got to 350. You need one by Friday.

Till next time,
Chris