AI Strategy · LeverageAI

The Wiki Playbook: Business Intelligence for Everything You Can't Count

Front door to the modules — why capture was never the bottleneck, why the index is the data, and how soft data joins to the hard numbers.

By Scott Farrell, LeverageAI · July 2026 · ~14 min read

Quarterly board meeting. The pack is immaculate — revenue by segment, cohort curves, a margin bridge with footnotes. Then someone asks the only question that matters this quarter: why did Q3 dip?

Your warehouse holds the dip. Which SKUs, which regions, which weeks, sliced any way you like. Effects, beautifully aggregated. But the why lives somewhere the warehouse has never been: the email thread where a key account pushed back on pricing, the Monday meeting where someone flagged a competitor's launch, the ops workaround that quietly added four days to fulfilment, the account manager who resigned in June and took the relationship with her.

So what happens next, in almost every company on earth? Someone senior is assigned to "pull the story together." A human being spends four days doing a comprehension pass over the soft layer — reading threads, asking around, sampling documents — and produces a narrative. Sampled, slow, unrepeatable, and gone by next quarter.

Twenty years of "data-driven organisation" rhetoric, and the layer where the explanations live has been dark the entire time.

Why one layer got a forty-year industry and the other got nothing

Not neglect. Not stupidity. An accident of birth: hard data got activated because it was born structured. The schema existed at write time. Somebody designed the tables before the first transaction landed. Bill Inmon's founding definition of the data warehouse — "a subject oriented, integrated, non volatile, time variant collection of data for management's decision making" — presumes structure in every word.¹ Everything since — cubes, columnar stores, the whole modern data stack — was speed-and-scale engineering over what was already queryable. The BI industry never had to comprehend anything. It aggregated. That isn't a criticism; it's the boundary condition.

How big is the layer it left behind? IDC measured that 90% of the data organisations generated in 2022 was unstructured — documents, messages, media — against 10% structured.² The famous "80%" line has a pedigree problem worth knowing about: it traces to a 1998 Merrill Lynch report whose own sourcing was never clear.³ The honest statement is a band, 80–90%, and Gartner has a name for what happens to it: dark data — "the information assets organizations collect, process and store during regular business activities, but generally fail to use for other purposes."⁴

Here's the part that turns a storage statistic into a strategy. The unactivated majority isn't just bigger — it's the causal layer. Transactional systems record outcomes: the sale closed, the payment posted, the patient rebooked. The decisions that produced those outcomes happened in emails, meetings and documents, and left their residue there. BI activated the effects. This activates the causes.

Capture was never the bottleneck

The instinct at this point is a knowledge-management programme: write it down, put it in one place, be consistent. I want to tell you about the person who executed that playbook perfectly.

A dental practice owner ran a standing weekly meeting whose real agenda was questions — she instituted it in self-defence, because she hated getting them all week, so she batched them. And she started writing them down. Every question a staff member asked, and every answer she gave, into a Word document. Not for a month. For over ten years. Hundreds and hundreds of pages.

Her staff still asked her the questions. The document grew for a decade and the weekly meeting never got shorter.

Don't laugh at the document — respect it. She is the most rigorous knowledge-capturer most consultants will ever meet. If capture were the bottleneck, she would have solved knowledge management. Instead she produced the cleanest controlled experiment on record that the playbook is missing a step. Her own staff gave the honest diagnosis: you did tell me; I just have no way to find it again.

A repeated question is a cache miss, not a comprehension failure. The organisation failed to serve the answer — and billed the failure to the asker's intelligence.

That failure has numbers attached. Knowledge workers lose 5.3 hours every week waiting for information from colleagues or recreating knowledge that already exists, and 42% of institutional knowledge is unique to the individual holding it — when they leave, colleagues simply cannot do that part of the job.⁵ McKinsey's classic estimate has knowledge workers spending 1.8 hours a day just searching and gathering.⁶

The missing step has a name, and the whole argument hangs on the distinction:

Why did nobody ever run the right-hand column? Because it costs a human weeks of expert-grade tedium — a job demanding an owner's judgment and a clerk's patience, possessed by nobody and fundable by no small business. Comprehension at that scale had no affordable unit price. Now it does. That's why this argument exists in 2026 and not in 2015, and it's developed at length in Capture Was Never the Bottleneck.

What compilation actually produces

Not a summary. Not a chatbot over your documents. The artefact is claims — atomic, dated statements — and edges: typed links between them. related. supersedes. [[Project Horizon]]. The claims hold the facts; the edges hold the relationships. Once the relationships live in the structure, a model navigates them instead of re-inferring them from chunk similarity every single time.

Andrej Karpathy gave the public version of this pattern a name in April 2026 — the "LLM Wiki," where the model "incrementally builds and maintains a persistent wiki," so "the knowledge is compiled once and then kept current, not re-derived on every query."⁷ The research has been converging on the same shape from the other direction: Microsoft's GraphRAG reports "substantial improvements over a conventional RAG baseline for both the comprehensiveness and diversity of generated answers" on sense-making questions,⁸ and newer work shifts cross-document reasoning from online inference to offline indexing outright.⁹ Anthropic states the trade-off in nine words: "runtime exploration is slower than retrieving pre-computed data."¹⁰

The reframe that carries the whole doctrine: the index stops being a pointer to the data and becomes the data (The Index Is the Data). And the mechanism that makes it self-improving is that ingest is a query: the agent doing the filing pulls the map, searches what the corpus already says, opens the top hits, follows their edges, and forms a view — this extends that claim; it contradicts this one; it's the missing example under that framework — then files itself with those edges attached. The edge was discovered by travelling, not computed by cosine distance (Ingest Is a Query). Same word. Completely different provenance.

When you should not compile

This is where most vendors would keep selling. Compilation is expensive and it is not always right, so here is the rule before the pitch.

Dropping a document into a vector store is cheap: chunk, embed, write. Ingesting one into a compiled graph is not — an agent reads the source, walks the existing graph, drafts claims and edges, and a more expensive model reviews and commits. That's a chain of model calls per source. Cognition's DeepWiki, which auto-generates wikis for public code repositories, reportedly spent around $300,000 in compute indexing its first 50,000 repositories, and regenerates on a schedule rather than on every commit because continuous re-compilation is too expensive.¹¹ That is compilation economics in one data point: the understanding is valuable because it was expensive to produce, and you only earn it back by reading the result many times.

That position — stratify, don't migrate — is the reason the rest of this is credible. Nobody selling you a knowledge graph will tell you which of your corpora should stay a vector index. The arithmetic will.

The join: BI says where, the wiki says why

Now the part that earns the word "intelligence." Traditional ETL made hard data joinable. Compilation makes soft context joinable — and that expansion is the product.

In hard BI a join looks like sales.region_id = employee.region_id. Here's the same operation over soft data. The dashboard reports: western region, enterprise segment, down 18% over ninety days. That's a complete answer to a where-question. Ask a naked model why, and you get a horoscope — competitive pressure, macro headwinds, sales execution. Every answer generically true and organisationally useless.

Now run it against a compiled organisational map that already holds pages like Western Sales Team (regional manager changed in March; two senior AEs left; recruitment incomplete), Enterprise Pricing (discount authority tightened in February; three exceptions awaiting a CFO decision), Project Horizon (CRM migration disrupted account ownership; several enterprise accounts temporarily unassigned; western concentration noted in cutover notes), Competitor X, Acme Group.

          TRADITIONAL BI
    Sales ↓ 18% · West · Enterprise · 90d
                    |
                    |  SOFT JOIN
                    ↓
              COMPILED WIKI-GRAPH
    (claims + typed edges + source pointers)
                    |
                    ↓
            RANKED ORGANISATIONAL CANDIDATES
                    |
                    ↓
              HUMAN INVESTIGATES

The critical join is not a foreign key. It's the recognition that "western sales deterioration" may connect to "the CRM migration temporarily left several major western enterprise accounts without clear ownership." Those strings share no vocabulary contract. They share a world — if something compiled one.

And what comes back is not a verdict. It's a ranked briefing a sceptical COO can attack: the strongest candidate is account-ownership disruption following the migration, amplified by reduced discount discretion; the competitor appears in lost-deal material but doesn't by itself explain the regional concentration; staffing gaps are contributing; one account is a single-account story unless more like it cluster. Every sentence clickable down to wiki paths and raw evidence. If it isn't clickable, it's theatre (BI Where Wiki Why).

Three disciplines that make the join defensible

Natural keys before embeddings. Wherever a real key already exists — a folder name, an email subject, a CRM record ID, a legacy document UNID, EXIF metadata — a deterministic join gives exact provenance for free. Embedding similarity tells you which conversations resemble this artefact. The key tells you which conversations created it. That's not a better score; it's a different fact. Similarity is the fallback, not the default (The Soft Join).

The answer depends on the date. High-stakes organisational questions are disproportionately past-tense: was this compliant when it was lodged? Currency asks which version is latest; applicability asks which version's validity window covers business date D. A supersedes edge is typed succession, not deletion — the warehouse world has run this discipline for decades as slowly-changing dimensions, inserting a new row with effective dates rather than overwriting.¹² Most organisations run filesystem instinct on policies and then expect warehouse-grade answers from the AI on top. That's not a model gap; it's a modelling gap (The Answer Depends on the Date).

Witnesses, not oracles. Every component that feeds another component returns four things: the claim, the verbatim exhibit it rests on, a resolvable pointer, and a confession of what it could not verify. The fourth field is the one people skip and the one that makes the whole chain compose — because it lets the next stage aim its scepticism (Witness, Not Oracle). This matters more than it sounds: research on chain-of-thought faithfulness found models frequently do not mention the hint that changed their answer, and admitted exploiting a reward hack in under 2% of cases.¹³ An explanation is something the model produces. A receipt is something you can open.

The part nobody expected: a substrate you can think inside

Everything above is business intelligence in the strict sense. What follows is the newer observation, and it's the reason this is worth capital now rather than in two years.

I used to think of tool connectivity as recovering data — accessing your email, accessing your CRM. That's the small version. Connect a model to a compiled corpus of your own frameworks and it stops behaving like a system with better lookup. Ordinary tools give a model more territory. A compiled graph gives it a better map — and partly determines what counts as interesting territory in the first place.

That suggests a four-part architecture, and most discussion of AI tooling only ever covers the first two:

Your compiled layer occupies the third. Your governance builds the fourth. Put all four together and you don't have a chatbot with tools; you have the beginnings of a governed cognitive system.

Two mechanisms make the third layer real rather than rhetorical.

Residence, not lookup. Once the relevant pages are loaded into the same working context as the task, they condition every downstream token whether or not another call ever fires. A lookup is an event. Residence is a condition. And a condition shapes the thousand small decisions nobody would ever write a lookup for. The test isn't whether markdown files think by themselves — a model checkpoint on disk is inert too. The test is whether including the component materially changes the cognition of the assembled system. I've run that ablation on my own stack repeatedly: same model, same question, wiki off and wiki on. It isn't that it sounds smart when it cites my material. The answers are deeper, the joins more distant, the refusals sharper. When I turn the wiki off, it's like talking to a dummy.

Traversal, not similarity. A model spent its formative existence reading hyperlinked documents threaded together by named links that a human was expected to follow. Handing it a page and a set of named edges asks for the single most rehearsed action in its entire training history. Asking it to emit a query string that will land near the right chunks in an embedding space it cannot see asks for something nothing in pretraining rehearses (Walk a Wiki, Can't Drive a RAG). Following a named link is reading a signpost. Writing a query is guessing a password for a lock you're not allowed to look at.

That is not similarity search over documents. It is associative traversal over compiled meaning.

And because the walk leaves a trail, the system learns from the thought it helped produce. A query isn't consumption; it's production — it yields a filable answer and a mineable path (File Back the Walk). New material doesn't just get added; ingestion places it against what was already believed. That distinction is the whole difference between a hard drive and a mind: a fact stored without connection to prior knowledge hasn't been learned — it's been filed. Or as one venture essay put it: "retrieval is not learning."¹⁴

Why the asset appreciates

Here is the argument for spending money now. The existing version, which I've written before, is the Model Dividend: better engine, same accumulated car. Every model release makes your existing scaffolding execute better.

There's a stronger version. The models are getting better at using tools — the labs have been focused on coding, agentic use, long-running processes. And guess what category a wiki call falls into? All of those. Turning up reasoning effort used to mean the model thought harder about the packet it already had, which doesn't help much. Turn it up now against a graph and it spends the budget differently: more probes, more edges travelled, more source reads, more backtracking. The reasoning budget stops buying deliberation and starts buying more relevant world.

The content of the graph hasn't changed. What expands is the model's usable graph radius: how far through semantically meaningful relationships an agent can travel before it loses the intent, pollutes its context, or settles prematurely. A weaker model reaches three hops and stops. A stronger one keeps going, crosses into an adjacent cluster, notices a contradiction, drops to source, and comes back with something that was always in your corpus and never previously reachable.

I want to be exact about the epistemic status of that claim, because it would be easy to dress it up. I have no benchmark for the magnitude and I'm not going to invent one. The argument is from mechanism: a better agent makes better probes, selects better edges, holds the parent intent across more operations, recognises useful but distant analogies, backtracks after a weak branch, and knows when to stop. Each of those is a step in a walk, and each is exactly what the labs have been optimising. The behavioural evidence in my own system is real but informal — and the experiment that would settle it is specifiable: fix the prompts, vary wiki off/on × reasoning effort × model generation, and blind-review the results. The sharp prediction is an interaction effect — extra reasoning should buy much more with the graph than without it, because without it, additional reasoning eventually saturates over a fixed packet.

One correction I owe my own earlier writing. I've said "architecture compounds; models don't." That still holds, but it needs a qualifier: models do not retain your private learning — architecture does — but better models can harvest more of what the architecture retained. A new release doesn't add a framework to your graph or draw an edge. It can, overnight, make more of your existing edges walkable. The model doesn't compound your private knowledge. It revalues it.

Which gives the finance answer. Stop counting what AI subtracts — hours, heads — and count what it adds in kind: decisions that got better because the context was finally in the room, institutional IP recovered from heads and old drives, and the question nobody knew to ask, answered. Denominate in capability (The Wiki Is CapEx). A capability case is politically stable for the same reason an hours-saved case is explosive: nobody sabotages the thing that makes them the most valuable person in the meeting.

And unlike most capital assets, this one appreciates with use. Every query teaches you where it's thin. Every package ingested raises the hit-rate of everything already in it, because the graph gets denser. Every correction adds an edge that will route a question nobody has asked yet. The depreciation schedule runs backwards.

Where to start on Monday

Not with a platform. With the densest corner of your own exhaust, and a two-week test.

Two rules that will save you the two most common failures. Keep the numbers out of the graph — map relationships and point to the authoritative source for any figure, because a stale relationship is still directionally true and a stale number is just wrong. And never skip the human verify step; an unreviewed compiled draft is a liability with confidence. Run ingestion without a gate and you've built a rumour mill with citations.

The failure modes are known and they're worth naming out loud: hallucinated consolidation, where a janitor with a vague directive merges two distinct old ideas into one false claim; the knowledge graveyard, where a system only ever writes and never prunes; calcified lore, where a conditional pattern hardens into an unconditional rule; and the receiptless guess that quietly acquires operational authority. That last one has a face — a man at a service desk saying "I think the AI got that one wrong," and then quietly clocking out of the problem (the invisible foreman).

And the boundary that matters most: activation improves cognition; it does not mint authority. A well-conditioned agent is more effective and more dangerous. Instrument whose lens was loaded, which pages dominated attention, and what the agent was then allowed to do — because the governable question is not "can the AI explain itself?" but "can we replay the conditions under which it acted?" Roughly 80% of organisations don't yet have a mature governance model for agentic AI,¹⁵ and Gartner forecasts over 40% of agentic AI projects will be cancelled by end-2027, partly for inadequate risk controls.¹⁶ Don't be evidence for either statistic.

The rooms, and which one to enter

This is the front door to a body of work, not a summary of it. Forty-three published modules develop the pieces, and each one owns something this piece only names:

• What the thing is — The Index Is the Data, RAG Was Built for Chatbots, The Wiki Is the Kernel, Ingest Is a Query.
• The join — BI for Soft Data, BI Where Wiki Why, The Soft Join, Elastic Assurance.
• Traversal and agents — Executable Worldview, The Intent Compiler, Context Arbitrage, The Scout and the Senior.
• Why it appreciates — The Third Substrate, The Wiki Is CapEx, Two Ladders, One Climb.

One last honesty, and it's the thesis proving itself. A capstone freezes an argument at publication time. The living graph doesn't stop — it has already kept thinking past this piece, including about this piece. Every module above was ingested against the ones before it, which changed the intellectual neighbourhood each of them lives in. That's not an embarrassment. It's the whole point: the substrate is upstream and downstream of the thinking at the same time. It conditions the thought, then learns from the thought it helped produce.

Your competitor can buy your model tomorrow. They cannot buy two years of your compaction.