All lessons › Function F — AI Governance for Agentic Systems › Building the Governance Platform — Regulatory and Compliance
F2.4

Sector overlays

F2
▶
Lightboard recording

Not recorded yet. The lesson below is complete and runnable today — the video is added later without touching this page.

Video placeholderpublishes automatically from recordings/F2.4.mp4
Risk

An agent is already a "model" under model-risk rules you already comply with.

Control

Find the regime you're already in before inventing a new one.

The lab

Map one agent to existing model-risk obligations.

◉Use case relevance

Sector overlays add requirements rather than replacing them. Reconciling them against the common spine is what stops a financial-services obligation and a healthcare obligation becoming two separate control estates.

At CyberTravels. The cheapest control in the programme is one you are already operating under another name. An agent that decides is a model under model-risk rules your organisation has followed for years, with inventory, validation and change requirements nobody thought to apply here.

◴What this lesson is — Day 0, Day 1, Day 2

Finding the sector rules you are already complying with under another name, which is usually the cheapest control in the programme — an agent that decides is a model, and model rules already have inventory, validation and change requirements.

Day 0 — why

The sector regime you are already in applies to agents without ever using the word AI.

Day 1 — how

Find the clauses that catch agents: third-party risk, exit strategy, scope containment, minimum necessary.

Day 2 — measure

Thresholds that move rather than indicators that are new — a much smaller job than inventing a measurement programme.

Measure this

what to measuredenominator or target
thresholds that move, against indicators that are newtwo counts; the first is a much smaller job

▦The framework, and how it works

   overlays ADD, they do not replace

   +---------------------------------------+
   |          the common spine             |
   +---------------------------------------+
      + finance: model risk, records
      + health: safety, clinical validation
      + critical infra: resilience, reporting

   reconcile at the spine, or you end up with three control estates

Sector overlays usually bite first, and the reason is structural: they already applied before anyone deployed an agent, they already have a supervisor who knows your organisation, and several of their clauses cover autonomous action without ever using the word AI.

Four clause types that catch agents without naming them:

  • ICT third-party risk (DORA) — your model provider is an ICT third party.
  • Exit strategy (DORA) — can you stop using this provider? Most AI contracts have no answer.
  • Scope containment (PCI DSS) — an agent with access to the cardholder data environment expands that environment.
  • Minimum necessary (HIPAA) — the agent's context window is a disclosure.

Citing an existing clause is also far more effective internally than proposing a new AI policy: it needs no new governance, and somebody already owns it.

Anchor → F1.1. A sector overlay mostly re-targets indicators you already compute — the same containment number against a stricter threshold. The exception is exit strategy, which no horizontal regime asks for and which almost nobody can currently measure at all.

2 · Demo — map agent facts onto pre-existing clauses

3 · Where it breaks — the exit-strategy clause

4 · The control — cite the existing clause, not a new policy

5 · The procedure, as a skill

Seven clauses already bind the claims-triage agent and none of them mentions AI. The skill searches on function rather than on technology, and assesses whether the hosted frontier API could be exited at all.

▶Real time execution as skill

The skill — skills/regulatory/sector-overlay-assessment/SKILL.md

name: sector-overlay-assessment
description: >-
  Find the pre-existing sector clauses that already apply to an AI system
  without mentioning AI, and assess provider exit against them. Use when a team
  believes no regulation applies yet because the AI rules are not in force.
allowed-tools: Read, Grep, Glob

The clauses that already apply and never say "AI"

Sector regulation was written before this and applies anyway. Outsourcing, material change, operational resilience, exit strategy, data handling — none of them mention AI, all of them bind an agent that processes claims or moves money. The finding is usually that a system nobody thought was regulated attracts seven clauses today.

When to use this

Any AI system in a regulated sector, especially one whose team believes the obligations arrive later.

Procedure

1 — Describe the system functionally. What it processes, what it decides, whose money or health or data it touches. Sector clauses trigger on function, not on technology.

2 — Search existing obligations for the functional triggers. Outsourcing and third-party dependency, material change notification, resilience and continuity, record keeping, exit. Do not search for "AI" — that is why nobody found them.

3 — Record each clause with what it requires, in operational terms. "Notify the regulator of material change to an outsourced arrangement" becomes a question about whether a hosted model version change is a material change.

4 — Assess provider exit specifically. Could you move off this provider, how long would it take, and is the alternative viable? A hosted frontier API with no equivalent substitute usually fails an exit test that a database would pass.

5 — Make the case for each clause explicitly. Clause, why it applies, what it requires here. That framing survives a challenge from a team that would rather it did not apply.

Example

Input — the fixture committed at the top of scripts/sector_overlay_assessment.py. Edit it and re-run: the buckets, counts and verdicts below are derived from it, not hard-coded.

Output — the opening lines of a real run:

claims-triage-agent: autonomy L2.5, data ['customer', 'health'], external model True

DORA (financial)
   ICT third-party risk    your model provider is an ICT third party
   exit strategy           can you stop using this provider and keep operating?
   resilience testing      your stop mechanism is in scope for testing
   incident reporting      clocks measured in hours

The run continues past this. test_skills.py executes the script on every build, with no model configured — so what CI proves is that it runs and refuses legibly, not that it prints these lines. The output above is a recorded run against a real model, and nothing re-diffs it: a model's answer is not reproducible, and this repository does not claim otherwise anywhere it can be checked.

Output contract

{
  "system": {"function": "str", "decides": "str", "data": ["str"]},
  "clauses": [{"framework": "str", "clause": "str", "mentions_ai": false,
               "applies_because": "str", "requires": "str"}],
  "exit": [{"provider": "str", "substitutable": false, "days_to_exit": 0, "verdict": "str"}],
  "cases": [{"clause": "str", "argument": "str"}]
}

Failure modes

  • Searching for AI. The binding clauses do not use the word.
  • Waiting for the horizontal regime. These apply now.
  • An exit assessment that assumes substitutability. Test it.

Three ways to do this lesson. Pick one. They run the same procedure against the same code — what changes is who drives it, and how much you see.

1In your AI agent — you are taught

The agent reads the lesson, explains the idea, fetches the code, runs the check and answers your questions as you go. This is the one to take if you are here to learn.

Install it, once. From the folder you cloned. --all does every agent it finds on your machine:

python3 scripts/install_skills.py --all --lessons F2.4

Then restart your agent and open it in that folder. On Windows, if python3 says Python was not found, use python instead.

Then pick f2-4-sector-overlays:

agentinstall just for this agentstart it
Claude Codepython3 scripts/install_skills.py --tool claude --lessons F2.4type /f2-4-sector-overlays
GitHub Copilot (VS Code)python3 scripts/install_skills.py --tool copilot --lessons F2.4type /f2-4-sector-overlays in Chat
Cursorpython3 scripts/install_skills.py --tool cursor --lessons F2.4type / in Agent chat and search for it
Codexpython3 scripts/install_skills.py --tool agents --lessons F2.4type $f2-4-sector-overlays, or run /skills

2As one Python command — you just run it

No agent, no conversation. The same lesson executes and prints the same readback. Take this one if you have no assistant, if you are reviewing rather than learning, or if you want the result without the teaching around it.

python3 scripts/lesson.py F2.4

3Read the code, and the difference — nothing runs

Neither of the above, and no model needed. The first command writes CyberTravels exactly as it stood at the end of this lesson; the second prints the diff — the lines this lesson added or changed, and nothing from any later one.

python3 scripts/checkpoint.py --at F2.4 --out work/cybertravels
python3 scripts/checkpoint.py --at F2.4 --diff

On Windows, type python wherever these say python3 — and use \ instead of / in the paths. Everything else is identical. A0.0 step 2 explains why.

Ways 1 and 2 need a model; way 3 does not. A signed-in Claude Code CLI needs no API key, and any OpenAI-compatible endpoint works too. With neither, the audit exits 2 and says so rather than inventing an answer. A0.0 sets this up.

Ways 1 and 2 both end with the same readback: What I did, What changed, The number and Read this next. A step that was skipped or refused is reported as exactly that, never as a pass.

If you did the last lesson’s challenge, expect this to stop. Most challenges ask you to edit the code, and ways 1 and 2 will not overwrite your edits: you get stopped, not a failure, with two options — --out for a fresh folder that keeps your work, or --force to discard it and start this lesson clean.

✓What you just proved

Seven pre-existing clauses apply to the claims-triage agent across DORA, HIPAA and PCI DSS, none of which mentions AI. The exit-strategy assessment marks the hosted frontier API as not defensible on all three counts, the hosted open-weight API on one, and self-hosted weights as defensible. Three cases show how to route the requirement to an existing owner rather than a new policy.

✎Your turn

Find the clause in your own sector overlay that already covers autonomous action without naming AI. Citing it is faster, cheaper and more persuasive than any new AI policy you could write.

Skill source: skills/regulatory/sector-overlay-assessment

← PreviousF2.3 · Voluntary frameworks as your spine