- Cyber risk changes at two speeds. The ten causes stay stable; techniques, tools and CVEs change constantly. So it takes two layers, joined by one vocabulary.
- Strategy decides in clusters: risk appetite and KRIs per cluster, reviewed quarterly to annually.
- Operations works in the same clusters, at finer grain: security operations and secure development, two audiences on one layer.
- The bridge can be tested: ten clusters × six CSF functions gives 60 named control objectives, measured with KRI, KCI and DCS.
Why Two Layers? Because Reality Has Two Layers
Most cybersecurity frameworks treat their structure as an organizational convenience — a way to sort threats into tidy categories for reporting purposes. TLCTC takes a different approach: its two-layer architecture is a normative property of the framework, written into Axiom VIII, because it reflects a split that already exists in how cyber risk works.
This distinction matters more than it first appears. What's natural — grounded in the actual structure of the problem — differs fundamentally from what's typical in most cyber standards today. And building a security program on an unnatural foundation creates problems that no amount of tooling or process can fix.
"The best frameworks don't just organize information — they reveal the structure that was always there."
The Natural Structure of Cyber Risk
Every cyber attack follows the same fundamental pattern: an attacker exploits a generic vulnerability to reach an event, which leads to consequences. That is the bow-tie, and it isn't a framework anyone invented — it's a description of how causality works in risk scenarios. Within it, two distinct layers emerge:
Layer 1: Stable Patterns
Some aspects of cyber risk don't change regardless of which system you protect, which tools you run, or which year it is:
- Software can have implementation flaws
- Identities can be impersonated
- Communication paths can be intercepted
- Capacity can be exhausted
- Humans can be manipulated
- Third parties can be compromised
These are the 10 generic vulnerabilities — universal, and by rule immutable: cluster definitions must not change without axiom-level justification.
Layer 2: Volatile Specifics
Other aspects change constantly — sometimes daily or hourly:
- Which CVEs affect your systems
- Which TTPs attackers are using this week
- Which detection rules need updating
- Which patches are pending
- Which dependencies just shipped an update
- Which tools are deployed where
These are the operational sub-threats — specific, and deliberately left extensible.
The 10 generic vulnerabilities haven't changed since the first networked computer; the specific CVEs exploiting them change weekly. A framework that collapses these layers together is fighting that asymmetry, and pays for it every time the taxonomy has to be re-cut because the technology moved.
"Top-level clusters have sub-threats (strategic vs operational layering). This separates a stable Strategic Management Layer (clusters / generic vulnerabilities) from an Operational Security Layer (specific vulnerabilities, techniques, and procedures)."
The two layers are joined by strict semantic equivalence: #X and TLCTC-0X.00 refer to the same cluster and must be treated as identical in meaning. That equivalence is what lets one classification travel intact from the boardroom to the SOC to a developer's backlog.
The Spine: Cause → Event → Consequence
Both layers sit on the same horizontal axis: the Cyber Bow-Tie. The ten clusters are on the cause side; the pivot is the System Risk Event (SRE) — System Compromise, Loss of Control; the consequence chain SRE → DRE → BRE* runs on the right, and Business Impact is the role the terminal BRE holds under the organization's risk appetite. Since v2.6 every cluster step records its own SRE, so an attack path is a chain of pivots.
The full treatment — control placement, the consequence chain, attack paths as chains of bow-ties, the dual-layer reading this post builds on, stacked bow-ties and typed edges — is in The Cyber Bow-Tie: From One Pivot to Layered Bow-Ties.
A data risk event such as "data breach" or "ransomware impact" records what happened. It never changes the cluster classification of the step that caused it. This is the operational form of Axiom III, and it is exactly what allows the same outcome to be traced back to different cause-side clusters.
What's Typical vs. What's Natural
Most cybersecurity standards make a fundamental error: they organize threats by outcome rather than by cause. This feels intuitive — "ransomware" and "data breach" are what people worry about — but it destroys the analytical foundation needed for consistent security.
What's Typical (but wrong)
- Outcome-based categories: "Ransomware," "Data Breach," "DDoS" used as threat types
- Cause–consequence conflation: mixing what attackers do with what results
- Flat taxonomies: no distinction between stable patterns and specific instances
- Actor-centric thinking: organizing by "who" instead of "how"
- Control-failure-as-threat: treating missing controls as threat categories
Results in: incomparable incident data, broken control mapping, and the same "breach" classified differently every time.
What's Natural (how it works)
- Cause-side classification: threats defined by the generic vulnerability exploited
- Layered abstraction: CVE → generic vulnerability → cluster
- Stable + volatile separation: patterns that don't change vs. details that do
- Action-centric structure: what attackers do, not who they are
- Clean bow-tie positioning: causes left of the SRE, outcomes right of it, never mixed
Results in: comparable analysis, clear control mapping, and consistent classification across teams and time.
"Threats are on the cause side; outcomes and events are not threats. Threat clusters must not be conflated with data risk events such as Loss of Confidentiality, Integrity, or Availability/Accessibility."
This isn't a preference — it's a logical constraint. If you classify by outcome, you can't compare incidents, can't map controls consistently, and can't learn systematically. The same outcome ([DRE: C], exposed data) can follow from #2 (SQL injection), #4 (credential use), #5 (interception), or #9 → #4 (phishing then credential use). Those require different controls — and outcome-based thinking hides exactly that.
The Ransomware Test
Consider a simple question: "What is a ransomware attack?"
Under outcome-based thinking, ransomware is a category unto itself. You track "ransomware incidents," build "anti-ransomware controls," and report "ransomware risk" to the board.
Under TLCTC, "ransomware" is a label for an outcome — the encryption and extortion that follow a successful attack. The threat is a sequence of causes, and in v2.5 notation that sequence carries its own timing, its trust-boundary crossings, and its outcome tag:
#9 ||[email][@Attacker⇒@M365→@Org]|| →[Δt=2h] #3 |[sandbox][@renderer→@os]| →[Δt=0s] #7 →[Δt=6h] #4 →[Δt=10m] #1 + [DRE: Ac]
| Step | What happens | Why this cluster |
|---|---|---|
| #9 Social Engineering | Phishing mail persuades a user to open an attachment | The exploited generic vulnerability is human psychology; the ||…|| operator records the crossing from the attacker's sphere into the org's |
| #3 Exploiting Client | Malicious document triggers a client-side parser flaw | Client-side code flaw, not server-side — the |…| operator records the sandbox escape inside the system |
| #7 Malware | Dropper executes and establishes persistence | Code execution capability is its own generic vulnerability; exploit and execution are always two steps |
| #4 Identity Theft | Harvested credentials are presented to authenticate for lateral movement | Per Axiom X, #4 exists at the moment a credential is used, not when it is collected |
| #1 Abuse of Functions | Backup deletion and mass encryption via designed admin APIs | The functionality works exactly as designed — its scope is the vulnerability |
| + [DRE: Ac] | Files encrypted — loss of accessibility | Not a threat step. It is the outcome tag on the consequence side of the SRE |
Note what changed from earlier versions of this analysis: the encryption is no longer written as a trailing #7. Encryption is a Data Risk Event, and v2.5 records it as [DRE: Ac] on the consequence side. Writing it as a cluster step would have been precisely the cause/outcome conflation Axiom III forbids.
The Δt annotations are not decoration either. This path spends two hours getting from the lure to the client exploit, then completes the final #4 → #1 transition in ten minutes. As we'll see in the indicator section, that ten-minute edge is what decides whether your detection capability is adequate — not the average across the whole intrusion.
This isn't pedantry. Two organizations hit by "ransomware" might have completely different attack paths requiring completely different controls. Outcome labels hide that; cause-side analysis with an explicit chain reveals it.
The Communication Gap
The two-layer structure isn't only analytically correct — it solves a practical problem that plagues every security organization: the disconnect between strategy and operations.
Ask a CISO what keeps them up at night and you'll hear about board presentations, risk appetite, and resource allocation. Ask a SOC analyst the same question and you'll hear about detection rules, false positives, and attack techniques. They're talking about the same threats in completely different languages.
Board meeting: "We need to address our supply chain risk exposure."
SOC meeting: "We detected suspicious npm package behaviour and need to update our detection rules."
Same threat (#10 Supply Chain Attack / TLCTC-10.20), different universes.
Three groups sit around that gap, on two layers: strategy on one, and security operations and secure development as two audiences on the other. Each has its own focus, its own clock and its own tools. What they lack is a shared word for the same risk.
| Strategy | Security operations | Secure development | |
|---|---|---|---|
| Who | C-level, risk management, board | SOC analysts, incident responders, threat hunters | Developers, security architects, DevSecOps |
| Focus | Risk appetite, resource allocation, compliance | Detection, response, threat intelligence | Threat modeling, secure coding, architecture |
| Clock | Quarters to years | Real time to weeks | Sprints to releases |
| Tools today | ISO 27005, NIST CSF, enterprise risk frameworks | MITRE ATT&CK, STIX/TAXII, SIEM rules | STRIDE, OWASP, security testing |
| With one vocabulary | “Our #10 exposure is above appetite, so vendor assurance gets the budget.” | “We're seeing #9 → #4 → #1: phished credentials, their use, then function abuse. Let's detect at the #4 step.” | “This export endpoint works as designed, and that is the exposure: #1. Let's narrow what the function allows.” |
This disconnect creates four compounding problems:
- Strategic decisions lack operational grounding — risk appetites are set without understanding which controls actually exist.
- Operational activity lacks strategic context — SOC teams detect threats without knowing which ones leadership cares most about.
- Communication breaks down — technical teams can't explain risk in business terms; leadership can't translate priorities into technical requirements.
- Resources are misallocated — investment decisions don't align with the actual threat landscape or with control effectiveness.
The Strategic Layer: Where Decisions Are Made
The Strategic (Management) Layer uses the human-readable form #X and works exclusively with concepts that don't change with each new CVE or TTP. It is the layer of governance: executive communication, risk registers, board reporting, and the attack-path notation, which expresses whole intrusions in cluster terms without operational detail. It answers which generic vulnerabilities matter, and how they chain.
Purpose and Scope
- The 10 threat clusters and their generic vulnerabilities
- Risk appetite and tolerance statements per cluster
- Control objectives — what controls should achieve, not how
- Key Risk Indicators aggregated upward from operational metrics
- Attack-path hypotheses and their Δt velocity profile
- Deliberately excludes TTPs, CVEs, and tool configuration
KRIs Must Count Near-Misses
One strategic-layer detail deserves emphasis, because it is the most common reporting error. A Key Risk Indicator measures exposure to threat pressure per cluster — and it must count near-misses, not just incidents. A near-miss is a case where the threat event materialized (the attacker acted) but a control held.
Take a phishing lure where a user discloses credentials and reports it before the attacker ever presents them. That is a realized #9 + [DRE: C] with no #4 step at all — because #4 exists only at the moment a credential is used to authenticate. The harvested-but-unused credential is an averted → #4, and that averted step is exactly the near-miss the KRI must capture. It is a data point, not a non-event.
Strategic Artifacts
| Artifact | Purpose | Update Frequency |
|---|---|---|
| Risk Register (TLCTC-based) | Track threats by cluster, using stable categories | Quarterly |
| Risk Appetite Statement | Define acceptable exposure per cluster; derive KRI/KCI/DCS targets | Annually |
| Control Objectives Matrix | Ten clusters × six CSF functions = 60 named objectives | Annually |
| KRI Dashboard | Incidents and near-misses at cluster level | Monthly |
The Operational Layer: Two Audiences, One Vocabulary
This is where v2.5 sharpens the model most. The Operational (Security) Layer uses the machine-readable form TLCTC-XX.YY, and beneath it sit the specific vulnerabilities, techniques, and controls. Crucially, this single layer serves two operational audiences, not one:
Security Operations
- SOC detection and response
- SIEM rules, tooling, automation
- Threat-intelligence exchange
- Incident-response playbooks — one per cause, not per outcome
Answers: through which concrete vector is this cluster being realized right now?
Secure Development
- The per-cluster Developer's View
- Secure development lifecycle (SSDLC)
- SAST / DAST / SCA findings, CWE → cluster
- Cluster-tagged threat models and commits
Answers: with which control is this cluster prevented from being built in?
Governance lives at the strategic layer; development and operations share the operational layer. If your reading of "two layers" was "board versus SOC," this is the correction: the developer's backlog is on the same layer as the SOC's detection rules, speaking the same cluster vocabulary.
Programmer vs. Coder
The Developer's View splits secure development into two roles with distinct cluster responsibilities. The Programmer works on the cause side — architecture and strategy — and owns #1, #4, #5, and #10 at an architectural level: what functionality exists and how it could be misused, which authentication and communication architectures are chosen, which third-party trust is accepted. The Coder works at the centre — implementation and craftsmanship — and owns #2 and #3, plus the implementation details of #4, #5, and #7.
The division is deliberately not a clean partition: #4 and #5 are co-owned, architected by the programmer and implemented by the coder. In one line: the programmer prevents the generic vulnerability from being architected into the system; the coder prevents the specific vulnerability from being written into the code.
The Sub-Cluster Hierarchy
The two-digit suffix YY is hierarchical, and this is what gives the operational layer room to grow without ever destabilizing the strategic one:
- TLCTC-XX.00 — reserved for the top-level cluster itself; sub-cluster 00 must never carry any other meaning
- TLCTC-XX.Y0 — a sub-cluster: a vector class within the cluster
- TLCTC-XX.YZ — a refinement within that sub-cluster
That yields up to 81 operational positions per cluster, with the strategic shorthand #X.Y (so #8.1 = TLCTC-08.10). Every sub-cluster must answer one question: through which vector does the attacker reach the same generic vulnerability? If the honest answer requires a different generic vulnerability, it belongs in a different cluster — the hierarchy can never smuggle a new cause in through the back door.
Four clusters ship reference decompositions; the remaining six are deliberately left open for community refinement:
| Cluster | Sub-cluster vectors |
|---|---|
| #2 Exploiting Server | #2.1 protocol · #2.2 core function · #2.3 external handler |
| #3 Exploiting Client | #3.1 protocol · #3.2 core function · #3.3 external handler |
| #8 Physical Attack | #8.1 mechanical (contact) · #8.2 signal (no contact) |
| #10 Supply Chain Attack | #10.1 update · #10.2 development · #10.3 hardware |
The #2/#3 symmetry is worth pausing on: it yields a complete 2×3 matrix (server/client × protocol/core/handler), so any code exploit on a networked component maps to exactly one cell.
The Bridge: The TLCTC × CSF Control Matrix
The two layers have to communicate, and TLCTC uses the NIST CSF 2.0 functions — GOVERN, IDENTIFY, PROTECT, DETECT, RESPOND, RECOVER — as that bridge. But calling CSF a "universal grammar" undersells what actually happens when you connect the two, so it's worth being precise about the mechanism.
CSF names what an organization does about cyber risk. What it does not supply is an answer to what a cyber threat is. NIST SP 800-30 defines a threat broadly enough to span all of operational risk, and its threat-source taxonomy — adversarial, accidental, structural, environmental — doesn't delineate cyber causes at all. So CSF asks organizations to "identify threats" and then "apply controls" without saying what constitutes a threat or which controls counter which. Every organization fills that gap with its own vocabulary, and the resulting control mappings are neither comparable across organizations nor falsifiable within one.
TLCTC supplies exactly the missing half. Clusters are nouns (causes); CSF functions are verbs (responses). They answer different questions and never compete to classify the same thing.
Sixty Named Control Objectives
The integration rule is simple: for each cluster #X, define control objectives under each CSF function. Ten cause rows crossed with six function columns yield 60 named control objectives — and at that point control coverage becomes falsifiable. A gap is no longer an abstract worry; it is a named, empty cell that someone has to explain.
The bow-tie fixes each function's position on the chain: IDENTIFY and PROTECT shape the cause side, DETECT and RESPOND straddle the SRE, RESPOND and RECOVER act on the consequence side, and GOVERN spans the whole thing. Each cell is then realized at two scopes — a local control and an umbrella control.
| CSF Function | Control Objective for #2 | Local Controls | Umbrella Controls |
|---|---|---|---|
| GOVERN | Govern strategy and ownership for server-exploitation risk | AppSec accountability, secure-SDLC policy, patch-SLA standard | Risk-register entry for #2 with appetite and tolerance; vulnerability-management programme |
| IDENTIFY | Identify failures in the code of the server software | Fuzz testing, network vulnerability scanning | Threat intelligence, CVE subscriptions |
| PROTECT | Protect the server from being exploited | Patch management, secure coding | Web application firewall (WAF) |
| DETECT | Detect an exploited server | Local event logging | SIEM |
| RESPOND | Respond to an exploited server | Emergency patching, CSIRT engagement | Exploited-server response plan, enterprise WAF-rule rollout |
| RECOVER | Recover from a server-exploit event | Maintained repositories, restore procedures | IT service continuity management |
The same exercise runs for each of the ten clusters, with objectives chosen for the characteristics of that particular cause.
GOVERN Is the Odd One Out
Filling the matrix per cluster makes GOVERN's distinct nature obvious. The other five functions are tactical-operational: they act on the threat itself. GOVERN is strategic-integrative: it is the hook that connects each cluster into the organization's broader management system — an ISMS (ISO/IEC 27001, clauses 4–10) or the NIST RMF, carrying policy statements, ownership, risk acceptance, and management-review inputs.
That is why only the GOV-umbrella band is highlighted in Figure 4. It is the matrix's one genuinely cross-cutting row of cells — its integration layer to enterprise risk management. GOV-local (cluster owner, cluster policy, exceptions) and every other cell stays cluster-specific.
Umbrella Controls Are Always Scope-Limited
Here is the governance-critical property, and it is the reason "we have an EDR fleet" is not an answer to "are we covered for #7." Umbrella controls frequently cannot reach an exposed patient-zero system — or they become a target themselves. An internet-facing service under #2 may sit outside the protective scope of an internal WAF; a phishing target under #9 may be reached on a personal device the enterprise umbrella never covered.
For initial-access clusters especially, an organization has to verify whether the exposed surface lies inside or outside the umbrella's scope before claiming coverage. This is precisely why the domain-boundary operator (||…||) and responsibility spheres (@X) carry governance weight: an umbrella control may simply not apply across a boundary that the attack path crosses.
The canonical case: #9 can circumvent your #4 controls. Phishing-resistant MFA raises the cost of credential misuse, but a social-engineering step that induces a help-desk reset or an MFA-fatigue approval reaches loss of control without ever defeating the #4 control on its own terms — the path moved through #9 first. An organization with excellent #4 coverage but weak #9 controls has a gap that a single-cluster control review structurally cannot see. Controls must be assessed per cluster and per path.
Measuring the Bridge: KRI, KCI, and DCS
A matrix you can't measure is a poster. v2.5 makes the matrix measurable through a small, deliberately strict indicator hierarchy — and the strictness matters, because loose KRI/KCI/KPI usage is where most two-layer implementations quietly fall apart.
| Indicator | Sits at | Measures | Examples |
|---|---|---|---|
| KRI Key Risk Indicator |
Risk-event layer | Exposure to threat pressure per cluster — incidents and near-misses | Exploitation attempts against internet-facing services (#2); credential-stuffing volume (#4); malware execution attempts (#7) |
| Technical KCI state & coverage |
Control-objectives layer | "What is the posture?" against a threshold target | % of privileged accounts with hardware MFA (#4); % of endpoints with allowlisting (#7) |
| Procedural KCI also read as KPI |
Control-objectives layer | "How fast do we execute?" against an SLA/SLO target | Mean time to patch critical CVEs (#2); mean time to revoke compromised tokens (#4) |
Note what is not in that table: a fourth, free-standing KPI. In v2.5, KPI is the performance facet of a procedural KCI, not a separate indicator type. The distinction that matters strategically is the three-way one — risk exposure, control state, control performance — all reporting upward against targets derived from risk appetite.
Why the Same MTTD Can Be Excellent or Useless
A performance indicator measured in isolation is uninterpretable, because control performance is only sufficient or insufficient relative to attacker speed. Consider an identical four-hour mean time to detect against two attacks:
- APT campaign, #4 →[Δt=14 days] #1 — detection runs roughly 84× faster than the attacker completes the transition. Ample buffer; the control is highly effective.
- Automated ransomware, #4 →[Δt=10 min] #1 — detection runs ~24× slower than the transition. The attacker wins the edge long before the alert fires.
The MTTD did not change. The verdict did. The missing variable is the attack velocity Δt of the transition being defended — which is exactly the annotation the attack-path notation was already carrying.
The Detection Coverage Score
v2.5 turns that comparison into a single ratio and promotes it to a Key Control Indicator:
DCS = MTTD / Δt
- DCS < 1.0 — detection completes before the attacker completes the transition. The defender is ahead.
- DCS = 1.0 — detection matches attack speed. Marginal, no buffer.
- DCS > 1.0 — the transition completes before detection fires. The attacker wins that edge.
The two scenarios above are DCS ≈ 0.012 and DCS ≈ 24 for the identical MTTD. Because DCS is appetite-bounded, an organization sets a target per velocity class, and the target then derives the MTTD the procedural KCI has to meet:
| Velocity class | Typical Δt | DCS target | Required MTTD | Investment focus |
|---|---|---|---|---|
| VC-1 Strategic | 7 days | ≤ 0.5 | < 3.5 days | Threat-hunting cycles |
| VC-2 Tactical | 4 hours | ≤ 0.8 | < 3.2 hours | SOC SLA, alert tuning |
| VC-3 Operational | 10 min | ≤ 0.8 | < 8 min | Automation, playbooks |
| VC-4 Real-Time | 30 sec | N/A | N/A | Prevention only |
The real-time row carries the most important governance message in the whole indicator system: below roughly a minute of Δt, detect-and-respond is structurally too slow no matter how much you spend on MTTD. The rational target there is not a faster DCS but architectural prevention — rate limits, automatic isolation, design that denies the step outright. That is a board-level investment conclusion derived entirely from a cause-side taxonomy and a stopwatch.
Control failure is never a threat (Axiom V). An indicator must read "lack of MFA reduces control effectiveness against #4," not "lack of MFA is a risk." And "high DCS means controls are ineffective for fast-velocity attacks," not "slow detection is a vulnerability."
Indicators never re-classify a cluster. KRIs count realized events per cluster, but a cluster's identity is fixed by the generic vulnerability exploited — never by its control state. This is what lets the indicator system measure the matrix without disturbing the taxonomy it measures against.
One Path, Many Regulators
If the two-layer model plus the consequence chain earns its keep anywhere, it is here.
A regulation does not, in practice, ask "what was the root cause?" in the taxonomic sense. It fixes a trigger point somewhere on the chain and attaches an obligation to it. Because one classified attack path carries the cluster causes, the SRE pivot, the DRE tags, and the BRE chain all at once, the same path can satisfy several regimes without being re-described once per regulator.
| Regime | Trigger point on the chain | What TLCTC supplies |
|---|---|---|
| GDPR (Art. 33/34) | Personal-data DRE (C/I/A of PII) | Cause cluster + DRE tag naming the breached property |
| NIS2 | "Significant incident" ≈ the SRE (loss of control) | The cluster path that establishes the incident and its cause |
| DORA | ICT operational impact ≈ BRE + velocity | The BRE chain plus Δt for the resilience view |
| CRA | Product weakness, pre-event | CWE → cluster exposure on the cause side |
| IEC 62443 | OT threat-identification gap in the risk method | Clusters + velocity classes as the threat layer for the TARA |
Worked Example: One Path, Two Regulators
#9 ||[human][@Attacker⇒@SMSProvider→@Org]|| → #4 → #1 + [DRE: C]
NIS2 triggers at the SRE — the moment the attacker reaches loss of control after #4 — and is satisfied by reporting the cluster path. GDPR triggers later, at the [DRE: C] node, when personal data is exposed, and is satisfied by reporting the same path's DRE tag and breached property.
Neither obligation requires a second incident narrative. They read different nodes of one classified path — and that is only possible because the framework kept causes, the central event, and consequences as distinct, separately addressable things.
TLCTC supplies the threat and trigger vocabulary — not legal thresholds, notification timelines, or materiality cuts. Those remain regime-specific and are set by counsel, not by a taxonomy.
Conclusion: Align with Reality
The cybersecurity industry has struggled for a long time with the disconnect between strategic intent and operational reality. Boards make decisions without understanding implementation; SOC teams detect threats without knowing strategic priorities; developers ship code against a threat model nobody upstream can read.
TLCTC's two-layer framework doesn't impose an artificial structure on cyber risk — it names a structure that is already there, and then holds itself to it. Stable patterns belong to the Strategic Layer, addressed as #X. Volatile specifics belong to the Operational Layer, addressed as TLCTC-XX.YY, shared by security operations and secure development. The CSF functions bridge them as sixty named, falsifiable control objectives. And the SRE → DRE → BRE* chain gives every one of those objectives a position, a detection window, and a measurable target.
When the framework aligns with reality, everything downstream gets easier: communication, control mapping, incident learning, resource allocation, and — increasingly — answering several regulators from a single classified path.
"The best defense isn't just strong controls or good threat intelligence — it's an organization where the board, the SOC, and the development team speak the same language and work toward the same goal. The two-layer framework gives you that common language. The rest is up to you."
References
- Kreinz, B. A Cause-Oriented Cyber Threat Taxonomy: The Top Level Cyber Threat Clusters Framework (TLCTC v2.5 Core), 2026. §3.4 the cause–event–consequence model; §4 the two-layer model; §5 the ten axioms; §7 attack-path notation.
- Kreinz, B. Applying the Top Level Cyber Threat Clusters: Classification, Governance, and Cross-Domain Application (TLCTC v2.5 Application), 2026. §7–§11 governance, controls and indicators; §13 regulatory reporting; §15 secure development.
- NIST Cybersecurity Framework 2.0, National Institute of Standards and Technology, 2024.
- NIST SP 800-30 Rev. 1, Guide for Conducting Risk Assessments, National Institute of Standards and Technology, 2012.
- TLCTC framework releases and citable versions: doi.org/10.5281/zenodo.20633176 (concept DOI — always resolves to the latest version).