All lessons › Function F — AI Governance for Agentic Systems › Running the Programme — the CISO Office
F3.4

Org design and ownership

F3
▶
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/F3.4.mp4
Risk

Harness engineering with no home; research as a hobby.

Control

Identity owns the control plane; BUs own grants; security owns stop authority.

The lab

Draw your org's ownership map against the topic matrix.

◉Use case relevance

Ask five people who owns agent identity and you will get five answers, all sincere. Org design is what converts that into one name per thing, which is the precondition for every control in Function F.

At CyberTravels. Two functions have no home on any org chart — harness engineering and red team / research — and neither fails loudly. They quietly do not happen, and the first evidence is an incident nobody had the tooling to investigate.

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

The two functions that fall between org charts — harness engineering and research — and the failure mode of both, which is not dramatic: they quietly do not happen.

Day 0 — why

Harness engineering with no home and research as a hobby means the seams have no names against them.

Day 1 — how

Name an owner for each seam before the incident rather than during it.

Day 2 — measure

Seams with a name against them. If nobody owns the measurement, the indicator exists on a slide and nowhere else.

Measure this

what to measuredenominator or target
seams with a name against themshare of seams; an unowned measurement exists on a slide and nowhere else

▦The framework, and how it works

   one name per thing, or the control has no owner

   agent identity        ->  ?
   evals                 ->  ?
   agent incidents       ->  ?
   model approval        ->  ?
   MCP server allowlist  ->  ?

   ask five people and get five sincere, different answers

The failures happen in the seams, so org design is the question of which seams you have chosen to have.

Every seam below is a real handover where an agentic incident stalls, and each one has a question that must have a name against it before the incident, not during:

SeamThe question
AppSec ↔ Platformwho owns the agent's sandbox?
Identity ↔ SecOpswho revokes a non-human identity at 03:00?
GRC ↔ Engineeringwho decides an autonomy rung — the tier or the roadmap?
SOC ↔ Datawho retains agent traces, and for how long?
CISO office ↔ Legalwho starts the regulatory clock?

An unanswered seam becomes an incident finding phrased as "unclear ownership", which is a decision nobody made rather than a surprise.

The second half of this lesson is the four roles this curriculum implies, and which one to hire first — which is not the one most teams hire first.

Anchor → F1.1. Org design decides who can actually compute each indicator. If identity owns the control plane and nobody owns the measurement of it, the indicator exists on a slide and nowhere else.

2 · Demo — the seams, and testing whether they are answered

3 · Where it breaks — an incident crossing an unanswered seam

4 · The control — four roles, and which to hire first

roletrackownsdelivershow many others it unblocks
identity engineerB2agent identity and delegationrevocation · attribution · act chains3
detection engineerE1agent telemetry and driftdrift alerts · agent detections2
GRC practitionerF1tiering, evidence, continuous verificationinventory · control coverage2
harness engineerC2the loop, the verifier, the evalevaluation · stop conditions1
The harness engineer is the one most teams hire first. The identity engineer is the one who unblocks the most others — revocation, attribution and act chains are prerequisites for evidence, evaluation and continuous verification alike, so hiring them second costs a quarter.

5 · The procedure, as a skill

Two of six decisions have no named owner, and in the simulated incident they account for 35 of 36.5 hours. The skill enumerates decisions rather than functions, and asks who may decide each one alone.

▶Real time execution as skill

The skill — skills/programme/ownership-seam-audit/SKILL.md

name: ownership-seam-audit
description: >-
  Find the decisions in an agentic programme that have no named owner and
  measure what they cost during a simulated incident. Use when org design is
  being discussed, or when an incident stalled waiting for a decision.
allowed-tools: Read, Grep, Glob

Thirty-five of thirty-six hours were two unowned decisions

Org design failures are invisible until an incident, when they appear as hours. The two decisions that typically have no owner — what autonomy rung an agent may run at, and how long traces are retained — are the ones that stall response, because nobody can make them and everybody can veto them.

When to use this

Designing ownership for an agentic programme, and after any incident whose timeline contains a wait.

Procedure

1 — Enumerate the decisions, not the functions. Autonomy rung, trace retention, stop authority, exemption approval, disclosure sign-off, vendor acceptance. Decisions have owners; functions have opinions.

2 — Ask who may decide each one alone. Not who is consulted — who may decide. Two or more names is the same as none, and it takes the same time to resolve.

3 — Simulate an incident that needs several of them. Assign realistic hours, with the unowned decisions taking as long as it takes to convene the people who could make them.

4 — Report the share of the incident that was decision latency. It is usually most of it, and the number is far more persuasive than the observation.

5 — Assign each unowned decision a single accountable name, with an escalation path. Then re-run the simulation to show the difference. That is the business case for the org change.

Example

Input — the fixture committed at the top of scripts/ownership_seam_audit.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:

seam                        owner                           lesson
------------------------------------------------------------------------------
AppSec ↔ Platform           platform-security               B3.1
Identity ↔ SecOps           on-call SRE, pre-authorised     B3.6
GRC ↔ Engineering           ⚠ NOBODY                        F3.2
SOC ↔ Data                  ⚠ NOBODY                        E1.3
CISO office ↔ Legal         legal, on IR notification       F2.6
AppSec ↔ SOC                detection engineering           E2.2

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

{
  "decisions": [{"name": "str", "owner": "str|null", "consulted": ["str"], "may_decide_alone": 0}],
  "unowned": ["str"],
  "incident": [{"step": "str", "hours": 0.0, "blocked_on": "str|null"}],
  "totals": {"hours": 0.0, "decision_latency_hours": 0.0, "share": 0.0},
  "after_assignment": {"hours": 0.0}
}

Failure modes

  • Mapping functions. They all report coverage.
  • Two owners. It resolves as slowly as none.
  • Reporting the seam without the hours. It reads as a governance preference.

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 F3.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 f3-4-org-design-and-ownership:

agentinstall just for this agentstart it
Claude Codepython3 scripts/install_skills.py --tool claude --lessons F3.4type /f3-4-org-design-and-ownership
GitHub Copilot (VS Code)python3 scripts/install_skills.py --tool copilot --lessons F3.4type /f3-4-org-design-and-ownership in Chat
Cursorpython3 scripts/install_skills.py --tool cursor --lessons F3.4type / in Agent chat and search for it
Codexpython3 scripts/install_skills.py --tool agents --lessons F3.4type $f3-4-org-design-and-ownership, 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 F3.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 F3.4 --out work/cybertravels
python3 scripts/checkpoint.py --at F3.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

Two of six seams have no named owner — autonomy rung decisions and trace retention. The simulated incident takes 36.5 hours, of which 35 are the two unowned decision steps, roughly 24× slower than if every seam were owned. The role analysis shows the identity engineer unblocks the most downstream capability while the harness engineer is hired first most often.

✎Your turn

Put a name against each of the six seams this week. Any seam where two people both say "them" is the one that will stall your next incident, and finding it now costs one meeting.

Skill source: skills/programme/ownership-seam-audit

← PreviousF3.3 · Sequencing the programme