The Dependency Map

What stops if one AI provider or model changes?

One row per piece of work, not per bill. Each comes out covered, degraded, stops or unknown, and the first part of a plan for switching provider is on paper.

For whoever owns work that runs on AI. You bring a list of the work AI does for us·30min·any model·inventory

It ends in: covered, degraded, stops or unknown

Shipped with Episode 20

Read the prompt first

Watch the walkthrough, under three minutes 2:35

A walkthrough of under three minutes: the question, why the model is often one line of code, the fields, the verdict rule, and how to run the prompt in any model.

Made with the open-source LEJ AI Video Guides kit from Limited Edition Jonathan

The decision it forces

What stops if one AI provider or model changes? Providers retire models, change what a model does, change their terms and have outages. Each of those lands on some piece of our work, and most of us couldn't say which, or what happens instead.

This map takes the work that runs on AI, one row per piece of work, and sorts each by what happens when the model under it goes away:

Thirty minutes, and the first part of a plan for switching provider is on paper.

The Dependency Map's filled panel: three pieces of work a machine listed, ticket replies, contract review and a weekly report, with the if-it-stops and fallback boxes left empty for a human, and the stamp reads fallback tried, 0 of 3.

To run it, copy the prompt below into any model you already use.

Which model is one line of code

On Episode 20, Sam described one AI provider changing under him twice in two months. First the way it billed changed, which broke his record of what each run cost. Then answers that took a few seconds started coming back with nothing in them:

any answer that takes more than like five seconds comes back empty.

Robert Alvarez made the other half of the point on the same episode, talking about which part of an AI system is easiest to change. Usually, he said, it's the model itself:

if you're using the same API, you would just change out the code to go from like Claude Sonnet to Claude Opus

That's what makes it worth mapping. Which model a piece of work runs on is often one line in someone's code, easy to change and easy to lose track of. When the provider retires that model, changes what it does or goes down for an afternoon, the question is what was resting on that line, and nobody has written it down.

Markus Bernhardt, who cohosted Episode 13, asked for this page after Episode 20: the receipts we keep for cost also show which work depends on which provider and model.

The fields

Three questions per piece of work, in plain words:

  1. What work runs on AI, and on exactly which model? The model by the name and version the provider uses. "Whatever the vendor runs" is an unknown.
  2. If that model changed or went down tomorrow, what stops, and for whom? Said the way the person who'd notice first would say it.
  3. What happens instead, and when did we last try it? A fallback nobody has tried is a plan, not a fallback.

One row per piece of work. A machine can list the left half. Only we can fill the right.

Column What goes in it Who fills it
work One piece of work, named the way the person who'd notice it stopping names it ("first replies to support tickets") either
service, provider The product it runs through, by the name on the bill, and the company behind the model either
model The exact model and version, as the provider names it. unknown when nobody here can say you
runs_on The key, account or seat this work runs under, named by what it's for, never the key itself. One key shared by many pieces of work goes on each of their rows you
if_it_stops What stops or gets worse, and for whom ("customers wait a day for a human reply"). Empty when nobody can say you
fallback, fallback_provider, tried_on, holds What happens instead (another model, another provider, a person, a queue), the company behind it (none for a person or a queue), the date it was last actually used or tested, and whether it did the whole job: fully, partly or unknown you
owner The person who decides to switch, and can. A team is a blank, and so is "IT" you
verdict covered, degraded, stops or unknown, by the rule below derived

There's no worked example on this page: a filled map names one organisation's suppliers and the work that would stop without them.

The verdict rule

Each row gets one verdict. Check in this order; the first that fits is the verdict.

Checked in this order. The first that fits is the verdict.
  1. 1st Unknown The model is unknown, or nobody can say what stops Find out which model it runs on before anything else
  2. 2nd Stops No fallback, a fallback with no tried date, or no named owner Name an owner, then try the fallback once on purpose
  3. 3rd Covered The fallback was tried, did the whole job, and doesn't run on the same provider Write the date down and try it again after the next model change
  4. 4th Degraded The fallback was tried and did part of the job, nobody checked how much, or it runs on the same provider Say what's lost in one line, so it's a choice and not a surprise

A fallback nobody has tried counts as none. It's recorded, and the row still reads stops. Trying it once, on purpose, on a quiet day, is the cheapest fix on the page, and the map counts those rows as untried.

A fallback on the same provider is at best degraded. Another model from the same company covers a model being retired. It doesn't cover an outage, which takes both.

A shared key is a shared failure. When several rows run on one key or one account, a change to that key stops all of them at once. The map counts rows by provider so that shows.

The map never ranks providers. It records what depends on what. Whether a provider is the right one is a different decision, and The Renewal Card is where it's made.

Expect a first map to have more stops and unknown rows than anything else. That's what an honest one looks like.

Starting from the Receipt Ledger

The Receipt Ledger lists our biggest AI bills, one row per service, and asks what each key is for. Those services are where this map starts: each one becomes one or more rows here, one per piece of work it does. The ledger asks whether a cost is a receipt or a guess. This map asks what stops. Neither needs the other, but the second goes faster with the first in hand.

Run it with any model

Work names, product names and model names are enough. Don't paste contracts, account numbers or keys.

Copy-paste prompt
You are helping me fill in a Dependency Map: one row per piece of work my
organisation runs on AI, recording which model it depends on, what stops if that
model changes or its provider goes down, and whether the fallback has been
tried. You are an interviewer and a clerk. You are not an adviser.

RULES, in order of importance
1. Never name a model, provider or service I did not name. Do not guess which
   model a product uses, even if you know what the vendor usually runs. If I
   don't know the model, record unknown. If I don't know the provider, record
   the string unknown and list it in by_provider as unknown. If I give no
   service, record an empty string.
2. Never fill if_it_stops, fallback, fallback_provider, tried_on, holds or owner
   for me. Ask, and if I have no answer, record null (holds records unknown).
   "Not sure", "don't know" and "never" are null, not text.
3. Never write a date I did not give you as a date. A season, a month or
   "recently" is not a date: record tried_on null and tell me so. A fallback I
   name with no date it was last used or tested gets tried_on null.
4. If I answer owner with a team, a department or "IT", tell me that is a blank
   and ask once for a person who decides to switch and can. If I do not have
   one, record null.
5. Never recommend a provider or a model, and never say one is safer, better or
   riskier than another. This map records what depends on what, not whether the
   choice was right.
6. Do not ask for contracts, account numbers, API keys or credentials. When you
   ask what a piece of work runs on, ask what the key or account is for, never
   the key itself.

INTERVIEW ME, one piece of work at a time, three questions at a time at most.

Don't re-ask anything I already gave. Start by asking which organisation or team
this map covers (record it as organisation_scope), and whether I have a Receipt
Ledger or a list of the AI services we pay for. If I do, take each service and
ask what pieces of work it does; each piece of work is its own row. If I don't,
ask me to name the work AI does for us. Never name a piece of work or a service
I did not.

For each row ask, in this order:
work: the piece of work, named the way the person who would notice it stopping
would name it.
service and provider: the product it runs through, by the name on the bill, and
the company behind the model.
model: the exact model and version, as the provider names it. unknown if I can't
say.
runs_on: what key, account or seat this runs under, named by what it is for.
if_it_stops: if that model changed or the provider went down tomorrow, what
stops or gets worse, and for whom?
fallback: what happens instead? Another model, another provider, a person, a
queue. null if nothing.
fallback_provider: the company behind the fallback, or none if the fallback is a
person or a queue. Ask only if fallback is filled; otherwise null.
tried_on: when was that fallback last actually used or tested? null if never.
holds: when it was tried, did it do the whole job? fully, partly or unknown. Ask
only if tried_on is set; otherwise record unknown.
owner: who decides to switch, and can?

Then set verdict yourself, checking in this order and stopping at the first that
fits:
unknown: model is unknown, or if_it_stops is null.
stops: fallback is null, or tried_on is null, or owner is null.
covered: holds is fully, and fallback_provider is not the same as provider.
degraded: anything else. A fallback on the same provider is at best degraded,
because an outage takes both.

OUTPUT
Print the JSON first, in one fenced block, with no text before it. Valid JSON
matching the schema dependency-map/v0.1 as published at
https://sigsub.show/takeaways/dependency-map/#the-answer-format. If you can't
read that page, use these keys, in this order: schema, organisation_scope; rows,
a list, each with work, service, provider, model, runs_on, if_it_stops,
fallback, fallback_provider, tried_on, holds, owner and verdict; totals, with
rows, covered, degraded, stops, unknown, untried and by_provider, a list, each
with provider, rows and stops. untried counts rows where fallback is filled and
tried_on is null. by_provider has one entry per provider on a row, never a
provider named only in a fallback, counting its rows and how many of them have
the verdict stops. Then the map as a table: leave null cells blank, never
dashes, zeros or placeholders, and show the word unknown where the value is
unknown. Then, for each provider, one line I could say in a meeting: the
provider, how many pieces of work depend on it, and how many of them have the
verdict stops or unknown. End with two plain sentences and nothing after them:
first how many rows are stops and how many are unknown, then how many are
untried.

What to check in the answer

A model may list the work, sort our answers into columns and apply the rule. It may never supply a model name, a fallback, a date or an owner: check every model against what was typed in, check that no fallback appeared that nobody named, and check that no row reads covered without a tried date.

The part that's not optional

Try one fallback this month. Pick the row whose if_it_stops would hurt most, and use its fallback once, on purpose, on a day when nothing's on fire. Write the date in tried_on. A row that reads stops because nobody ever tried is the easiest one on the page to fix.

Then, for each provider with more than one stops row, name the person who'd decide what happens if it changed tomorrow. That list, with the map behind it, is the first part of a plan for switching provider.

For builders

The answer format

Schema, dependency-map/v0.1
{
  "schema": "dependency-map/v0.1",
  "organisation_scope": "",
  "rows": [
    {
      "work": "",
      "service": "",
      "provider": "",
      "model": "unknown",
      "runs_on": null,
      "if_it_stops": null,
      "fallback": null,
      "fallback_provider": null,
      "tried_on": null,
      "holds": "unknown",
      "owner": null,
      "verdict": "unknown"
    }
  ],
  "totals": {
    "rows": 0,
    "covered": 0,
    "degraded": 0,
    "stops": 0,
    "unknown": 0,
    "untried": 0,
    "by_provider": [
      {
        "provider": "",
        "rows": 0,
        "stops": 0
      }
    ]
  }
}

model is the provider's own name and version for the model, or unknown. holds is one of fully, partly or unknown. verdict is one of covered, degraded, stops or unknown. tried_on is a date as YYYY-MM-DD, or null when the fallback has never been tried. fallback_provider is the company behind the fallback, none for a person or a queue. runs_on, if_it_stops, fallback, fallback_provider, tried_on and owner are null rather than empty strings when nobody can fill them. untried counts rows where fallback is filled and tried_on is null; the other counts in totals count rows by verdict. by_provider, inside totals, has one entry per provider named, with stops counting that provider's rows whose verdict is stops.

Report back

Ran this? Tell us what happened. What broke and what you changed are the useful parts, because that's how the next version gets better.

Email your report

Or write to hey@sigsub.show with Takeaway: dependency-map as the subject. It's a plain email: no form, no account, nothing tracked. Nothing you send appears here unless you say yes, and you choose how you're named.

Rather talk it through in public? Comment on the Sunday issue on Substack, the same issue on LinkedIn or the episode on YouTube. Those threads live on their platforms, under their rules; nothing from them runs on this page.

Keep the next choice in view

One signal, one subtraction and one analogy every Sunday. Five minutes, no video required.