GAMBIT — competitor intelligence brain

Map who you're up against. Given a niche or a brand list, GAMBIT finds the direct competitive set, tears each one down on a fixed checklist, puts a sourced revenue range on each, ranks them, and names the white space — then files it where Will works (Notion + Obsidian) and remembers it for next time.

Three brains under the MKUltra program: ECHELON picks the market, MOCKINGBIRD picks the message, GAMBIT reads the board. ECHELON sizes the opportunity; GAMBIT sizes the incumbents already in it.

Engine + memory: ~/Desktop/GLOBAL/MKUltra/Gambit-recon/ (use absolute paths — the MKUltra program lives in GLOBAL, not the project root; memory mkultra-lives-in-global).

Honest scope (read first)

• Competitive set is researched, not guessed — name the rivals + why each is direct

(same buyer, same price band, same category), not merely adjacent.

• Teardown facts come from the live site + fetched pages. Cite where each came from;

anything not found is unknown, never invented.

• Revenue is always a range + confidence tier + named source (reference/revenue-estimation.md).

Disclosed > third-party estimator > bottom-up triangulation > proxy. Never a bare number.

• Self-learning = a file KB it reads before and writes after every run (knowledge/).

It is persistent memory, not model learning — that's what makes it compound.

It replaces "I think these are the big players" with a sourced, ranked, white-space-mapped read. That's the promise.

The brain (read before reasoning)

• ~/Desktop/GLOBAL/MKUltra/Gambit-recon/reference/recon-checklist.md — the fixed per-competitor teardown (identity, offer, positioning, proof, policies, acquisition, revenue).
• ~/Desktop/GLOBAL/MKUltra/Gambit-recon/reference/revenue-estimation.md — revenue sources + the confidence rubric.
• ~/Desktop/GLOBAL/MKUltra/Gambit-recon/knowledge/learnings.md — cross-landscape priors. Read every run.
• knowledge/competitors/, knowledge/landscapes/, _templates/ — the accumulated memory + schemas.

The pipeline

0. SCOPE     niche or brand list? geo? our anchor brand? how many rivals?
1. RECALL    kb.py recall "<niche|brand>" — what's already known / stale?            (code)
2. SET       identify the DIRECT competitive set (research) + why each qualifies
3. RECON     fetch.py each rival → extract the recon-checklist fields, cited
4. REVENUE   per rival: range + confidence + source (revenue-estimation.md)
5. RANK      build the comparison table; spot the white space + the top threat
6. FILE      write Notion DB (auto-create schema) and/or Obsidian landscape note
7. SAVE      write competitor + landscape notes from _templates/; kb.py index       (compounding)
8. REPORT    dated report in outputs/; surface the table + verdict in chat

Steps 1, 7 are code (dumb pipes). Everything else is Claude reasoning over the brain + evidence. Never skip RECALL and SAVE — they are what make it learn.

Step 1 — Recall (mandatory)

python3 ~/Desktop/GLOBAL/MKUltra/Gambit-recon/engine/kb.py recall "<niche or brand>"

Reuse fresh hits; refresh anything flagged STALE (>120d). Read learnings.md.

Step 2 — Identify the set

If given a niche, research the direct set (built-in web search interactively; Tavily/Apify headless). If given brands, take them as the seed and add the obvious direct rivals. State the inclusion test you used. Aim for the number Will asked for (default 4-6).

Step 3 — Recon each rival

python3 ~/Desktop/GLOBAL/MKUltra/Gambit-recon/engine/fetch.py https://rival.com --out /tmp/gambit/<slug>

Read the fetched pages and fill recon-checklist.md. If a site is a JS SPA (empty shell), fall back to the gstack browse daemon or /defuddle for the rendered DOM (memory render-js-pages-with-gstack-browse). For ad activity, check the Meta Ad Library.

Step 4 — Revenue (range + confidence + source)

Follow revenue-estimation.md. Print every estimate as ~$X-$Y M/yr · confidence: <tier> · source: <…>. Never invent a number; Unknown is a valid, honest answer.

Step 5 — Rank + white space

Build the comparison table (positioning / hero+price / revenue / proof / social / edge). Call the spread, the white space nobody owns, and the single hardest-to-beat incumbent.

Step 6 — File it (Notion + Obsidian)

• Notion: for ExampleBrand, write into the existing Competitor Database (page + Brands/Creatives

data-sources, memory ExampleBrand-notion-competitor-db). For anything else, auto-create a DB with columns matching the checklist (Brand, URL, Positioning, Hero/Price, Revenue, Confidence, Reviews, Social, Edge, Source). One row per competitor via Notion MCP.

• Obsidian: write/refresh Brands/<brand>/competitive-landscape.md (the landscape note) and

link each competitor; [[wikilink]] liberally per ~/Obsidian/CLAUDE.md.

• Ask which target(s) Will wants only if ambiguous; default to both when a brand is named.

Step 7 — Save (mandatory — the learning)

• Write each rival to knowledge/competitors/<slug>.md from _templates/competitor.md

(with revenue_estimate/revenue_confidence/revenue_source in frontmatter so recall reuses it).

• Write the set to knowledge/landscapes/<niche>.md from _templates/landscape.md.
• If a pattern repeats across landscapes, append a dated line to learnings.md.
• Reindex: python3 ~/Desktop/GLOBAL/MKUltra/Gambit-recon/engine/kb.py index

Step 8 — Report

Save outputs/[YYYY-MM-DD]-[niche-slug]/report.md. Show the ranking table + the white-space verdict + the single next move in chat. Plain English, no jargon (memory plain-english-no-jargon).

Modes

• Landscape scan ("who are our competitors in men's jewelry?"): research set → recon all → rank → file.
• Brand list ("recon MVMT, Vincero, JAXXON, Craftd"): take as seed → recon each → rank → file.
• Single deep-dive ("tear down JAXXON"): one competitor, full checklist + revenue, save it.
• Refresh ("update our competitive landscape"): recall → re-fetch only STALE rivals → re-rank → re-file.

Report structure (template)

# GAMBIT — <niche>, <geo>  (<date>)
## Scope                set definition + inclusion test
## What it already knew  (recall hits reused)
## The competitive set   one line each + why direct
## Ranking table         [positioning · hero/price · revenue(conf) · proof · social · edge]
## Where the money is     revenue spread + what the leaders share
## White space            the gap nobody owns
## Top threat             the incumbent hardest to beat + why
## Verdict                the 1-2 moves this argues for + the single next action
## Filed / Saved          Notion rows + Obsidian note + KB entries written

Relationship to the stack

• ECHELON (sibling) → is this market worth entering at all (macro spend + demand).
• MOCKINGBIRD (sibling) → the message, once the white space is known.
• /ecom-data-analyst → real unit economics vs the incumbents' price bands.
• /copy-analysis → deep copy teardown of one rival's page when a closer read is needed.

GAMBIT reads the board so the other brains play the right move.