01 - The Model & Theory

Two substrates and one multiplier

The core idea is not three equal pipelines. It is two things you build up (substrates) and one thing that multiplies them (Applied AI).

flowchart LR
    DATA["DATA MATURITY<br/>what the org can know, how fast"]
    ORG["ORGANIZATION MATURITY<br/>how the org operates, what AI can plug into"]
    AIx{{"APPLIED AI<br/>the multiplier"}}
    OUT["OUTPUT<br/>reporting, creative, social, CS"]
    DATA --> AIx
    ORG --> AIx
    AIx --> OUT
    classDef m fill:#1F4E78,stroke:#0B2545,color:#fff;
    class AIx m;
  • Data maturity governs what the org can know and how fast.
  • Organization maturity governs how the org operates and what AI can act through.
  • Applied AI is the multiplier. It converts both substrates into output, and it is bottlenecked by whichever substrate is weaker.

The gating law

Realized value  =  Applied AI  x  min(Data maturity, Organization maturity)

You cannot out-AI a maturity gap. Pour sophisticated agents onto a weak substrate and you get very little - the connectors have nothing to read, the agents have no captured process to run, the people cannot prompt. Every tooling and sequencing decision serves this law.

flowchart TB
    A["Lots of AI effort"] --> C{"min(data, org)"}
    B["Weak substrate"] --> C
    C -->|"weak link caps it"| D["Small realized value"]
    C2{"min(data, org)"}
    A2["Lots of AI effort"] --> C2
    B2["Strong substrate"] --> C2
    C2 -->|"nothing holding it back"| D2["Full realized value"]
    classDef bad fill:#F8CBAD,stroke:#C0504D,color:#111;
    classDef good fill:#C6EFCE,stroke:#2E7D32,color:#111;
    class D bad;
    class D2 good;

The topology - the substrates do not feed AI directly

They first converge into a shared context and knowledge layer (Git + the OpenKnowledge vault). Both AI surfaces draw from that same layer.

flowchart TB
    subgraph L4[" "]
      GOAL["LEAN SCALING"]
    end
    subgraph L3[" "]
      INT["Internal leverage"]
      PROD["AI as product"]
    end
    K["CONTEXT & KNOWLEDGE<br/>warehouse tables + Git/OpenKnowledge vault"]
    subgraph L1[" "]
      DATA["DATA MATURITY<br/>Starter -> Growth -> ML -> Real-time"]
      ORG["ORG MATURITY<br/>Tooling -> Process -> Literacy -> AI-native"]
    end
    DATA --> K
    ORG --> K
    K --> INT
    K --> PROD
    INT --> GOAL
    PROD --> GOAL
    classDef g fill:#C6EFCE,stroke:#2E7D32,color:#111;
    classDef k fill:#FFF2CC,stroke:#B7950B,color:#111;
    class GOAL g;
    class K k;

The two maturity ladders

flowchart LR
    subgraph D["Data maturity (Track B)"]
      d1["Starter<br/>basic tracking"] --> d2["Growth<br/>warehouse + dbt + BI - TARGET"] --> d3["Machine learning<br/>forecasting, predictive"] --> d4["Real-time<br/>data flows back to tools"]
    end
    subgraph O["Organization maturity (Track A)"]
      o1["Tooling adoption<br/>work lives in software"] --> o2["Process capture<br/>documented, repeatable"] --> o3["AI literacy<br/>people can drive it"] --> o4["AI-native ops<br/>designed around agents"]
    end
    classDef t fill:#DDEBF7,stroke:#2E75B6,color:#111;
    class d2 t;
    class o2 t;

Two things to notice:

  • On the data side, the ML outcomes (forecasting, auto-insight) are now reachable via the AI multiplier sitting on a solid Growth stack - we do not need a heavy ML org. Sequence Real-time last; it is the hardest and most expensive rung.
  • On the org side, process capture does the quiet heavy lifting: an agent can only take over a process that has been made explicit. Much of the “teach the team” work is really process-capture work.

The lean-scaling math (why this makes money)

Net profit impact  =  (labor displaced + revenue lift)  -  (Track A + B + C spend)

The structural claim: as output grows, A + B + C spend grows sub-linearly (per-seat SaaS, shared infra, usage far below human cost), while the labor you would otherwise hire grows linearly with output. The gap between those two lines widens as you scale. That widening gap is the entire business case, and the cost model (03) is its proof.

Two surfaces of the multiplier

flowchart LR
    K["Shared knowledge layer"]
    K --> INT["INTERNAL LEVERAGE<br/>ops-facing agents:<br/>reporting, ideation, creative, social"]
    K --> PROD["AI AS PRODUCT<br/>customer-facing agents:<br/>DM / CS bot on our knowledge base"]
    INT -.->|"~all near-term weight"| N1[" "]
    PROD -.->|"thin for now: CS/CRM only"| N2[" "]
    style N1 fill:#fff,stroke:#fff
    style N2 fill:#fff,stroke:#fff

Both are the same multiplier pointed in different directions, fed by the same fuel. Near-term, almost all the weight is on internal leverage. The only genuinely customer-facing surface today is the DM / CS bot - covered concretely in the Product Build Playbook.