@@ -187,8 +187,17 @@ function buildUserPrompt(input: {
   linkSlots: number;
   exchangeCandidates: ExchangeCandidate[];
   exchangeSlots: number;
+  exchangeRelaxed?: boolean;
 }): string {
-  const { site, keyword, candidates, linkSlots, exchangeCandidates, exchangeSlots } = input;
+  const {
+    site,
+    keyword,
+    candidates,
+    linkSlots,
+    exchangeCandidates,
+    exchangeSlots,
+    exchangeRelaxed,
+  } = input;
   const brand = site.domain;
   const niche = site.niche?.trim() || "B2B / technical SaaS";
   const audiences = site.target_audiences.length
@@ -218,8 +227,11 @@ function buildUserPrompt(input: {
         `${i + 1}. [PARTNER BLOG: ${c.domain}] ${c.url}\n   Title: ${c.title}\n   About: ${c.meta_description ?? "(no description)"}`,
     )
     .join("\n");
+  const exchangeMax = Math.min(exchangeSlots, exchangeCandidates.length);
   const exchangeSlotLine = exchangeSlots > 0 && exchangeCandidates.length > 0
-    ? `Insert UP TO ${Math.min(exchangeSlots, exchangeCandidates.length)} of the following external partner-blog links inline as standard markdown links, where each fits naturally in a sentence whose topic genuinely overlaps. Pick the most relevant — skip any that don't fit; do not force a link. Do not invent URLs. Return the URLs you used in used_exchange_link_urls.`
+    ? exchangeRelaxed
+      ? `Insert UP TO ${exchangeMax} of the following external partner-blog links. These are pre-vetted blogs in our shared content network — the network is still small, so topical overlap may be loose. Place each as a natural "Related reading from our network: [anchor](url)"-style inline reference where the surrounding paragraph allows even a tangential connection (e.g., a "for adjacent reading" aside, a comparison, or a "teams in {their niche} face similar tradeoffs" sentence). Prefer using all ${exchangeMax}; only skip a candidate if including it would make a paragraph read as obviously incoherent. Do not invent URLs. Return the URLs you used in used_exchange_link_urls.`
+      : `Insert UP TO ${exchangeMax} of the following external partner-blog links inline as standard markdown links, where each fits naturally in a sentence whose topic genuinely overlaps. Pick the most relevant — skip any that don't fit; do not force a link. Do not invent URLs. Return the URLs you used in used_exchange_link_urls.`
     : "External-link slots: 0. Return used_exchange_link_urls: [] and do not link out.";
 
   return [
@@ -626,15 +638,17 @@ export async function generateArticle(
   const exchangeSlots = typedSite.backlinks_enabled
     ? Math.max(0, typedSite.external_links_per_article)
     : 0;
-  const exchangeCandidates = await findExchangeCandidates(supabase, {
+  const exchangeMatch = await findExchangeCandidates(supabase, {
     selfSiteId: typedSite.id,
     selfNiche: typedSite.niche,
     keyword: keyword.keyword,
     slots: exchangeSlots,
   });
+  const exchangeCandidates = exchangeMatch.candidates;
+  const exchangeRelaxed = exchangeMatch.relaxed;
   if (exchangeSlots > 0) {
     console.log(
-      `[lx] exchange candidates for ${typedSite.id} keyword="${keyword.keyword}": ${exchangeCandidates.length}/${exchangeSlots} slots`,
+      `[lx] exchange candidates for ${typedSite.id} keyword="${keyword.keyword}": ${exchangeCandidates.length}/${exchangeSlots} slots (mode=${exchangeRelaxed ? "relaxed" : "strict"}, network=${exchangeMatch.networkSize})`,
     );
   }
 
@@ -672,6 +686,7 @@ export async function generateArticle(
             linkSlots,
             exchangeCandidates,
             exchangeSlots,
+            exchangeRelaxed,
           }),
         },
       ],
 
@@ -39,6 +39,13 @@ export type ExchangeCandidate = {
   meta_description: string | null;
 };
 
+// Below this many eligible articles in the network, the matcher relaxes
+// its "score > 0" requirement and will surface the freshest candidates
+// even with zero topic overlap. Once the corpus is large enough, niche
+// overlap reliably finds something for any given keyword and strict
+// mode kicks back in. Tuned to ~250 sites × ~10 articles each.
+export const RELAXED_NICHE_THRESHOLD = 2500;
+
 type RankableRow = {
   id: string;
   title: string;
@@ -92,13 +99,27 @@ export function buildArticleUrl(blogRootUrl: string, slug: string): string {
 
 export function rankExchangeCandidates(
   rows: RankableRow[],
-  input: { selfSiteId: string; selfNiche: string | null; keyword: string; slots: number },
+  input: {
+    selfSiteId: string;
+    selfNiche: string | null;
+    keyword: string;
+    slots: number;
+    // Minimum overlap score to accept. Defaults to 1 (strict — require
+    // some topical overlap). Caller passes 0 in early-network "relaxed"
+    // mode so the matcher can still find SOMETHING when the corpus is
+    // too thin for niche overlap to fire reliably.
+    minScore?: number;
+  },
 ): ExchangeCandidate[] {
   const { selfSiteId, selfNiche, keyword, slots } = input;
+  const minScore = input.minScore ?? 1;
   if (slots <= 0) return [];
 
   const selfTokens = topicTokens(keyword, selfNiche);
-  if (selfTokens.size === 0) return [];
+  // In relaxed mode (minScore = 0) we still surface candidates even if
+  // the self-token set is empty — the network's just too small to be
+  // picky. In strict mode, no self-tokens means nothing to match against.
+  if (selfTokens.size === 0 && minScore > 0) return [];
 
   const scored = rows
     .filter((r) => r.site.id !== selfSiteId)
@@ -109,7 +130,7 @@ export function rankExchangeCandidates(
         topicTokens(r.title, r.meta_description, r.site.niche),
       ),
     }))
-    .filter((s) => s.score > 0)
+    .filter((s) => s.score >= minScore)
     .sort((a, b) => b.score - a.score);
 
   const out: ExchangeCandidate[] = [];
@@ -131,18 +152,32 @@ export function rankExchangeCandidates(
   return out;
 }
 
+export type ExchangeMatchResult = {
+  candidates: ExchangeCandidate[];
+  // True when the network is below RELAXED_NICHE_THRESHOLD — we surfaced
+  // candidates without requiring topical overlap. Callers can use this
+  // to soften prompt language so the model actually uses what we found.
+  relaxed: boolean;
+  networkSize: number;
+};
+
 // Fetch + rank in one call. The PostgREST embed pulls the site columns
 // we need for filtering and URL construction in a single round-trip.
 export async function findExchangeCandidates(
   supabase: SupabaseClient<any>,
   input: { selfSiteId: string; selfNiche: string | null; keyword: string; slots: number },
-): Promise<ExchangeCandidate[]> {
-  if (input.slots <= 0) return [];
+): Promise<ExchangeMatchResult> {
+  if (input.slots <= 0) {
+    return { candidates: [], relaxed: false, networkSize: 0 };
+  }
 
   // Cap the candidate pool so a large network can't blow up the prompt
-  // or the ranking loop. slots*8 gives the ranker enough headroom to
-  // filter on niche overlap and still meet the slot count.
-  const limit = Math.max(20, input.slots * 8);
+  // or the ranking loop. In relaxed mode we widen the pull window so
+  // recency-ordering has enough variety to choose from.
+  const networkSize = await countEligibleNetworkArticles(supabase);
+  const relaxed = networkSize < RELAXED_NICHE_THRESHOLD;
+  const minScore = relaxed ? 0 : 1;
+  const limit = Math.max(20, input.slots * (relaxed ? 12 : 8));
 
   const { data, error } = await supabase
     .from("lx_article")
@@ -160,7 +195,13 @@ export async function findExchangeCandidates(
 
   if (error) {
     console.warn("[lx] exchange matcher query failed:", error.message);
-    return [];
+    return { candidates: [], relaxed, networkSize };
+  }
+
+  if (relaxed) {
+    console.log(
+      `[lx] exchange matcher running in RELAXED mode (network=${networkSize} < ${RELAXED_NICHE_THRESHOLD} eligible articles)`,
+    );
   }
   // PostgREST's `!inner` embed types come back as `site: T[]` even though
   // the runtime shape is a single object once the inner join is applied.
@@ -173,5 +214,35 @@ export async function findExchangeCandidates(
     meta_description: r.meta_description,
     site: Array.isArray(r.site) ? r.site[0] : r.site,
   })).filter((r) => r.site);
-  return rankExchangeCandidates(rows, input);
+  return {
+    candidates: rankExchangeCandidates(rows, { ...input, minScore }),
+    relaxed,
+    networkSize,
+  };
+}
+
+// Count of articles eligible to be exchanged across the whole network —
+// the denominator that decides whether the matcher is in strict or
+// relaxed mode. Counts opted-in, non-flagged, active-site rows only;
+// a backlogged or paused site shouldn't push us into strict mode just
+// by existing.
+async function countEligibleNetworkArticles(
+  supabase: SupabaseClient<any>,
+): Promise<number> {
+  const { count, error } = await supabase
+    .from("lx_article")
+    .select("id, site:lx_site!inner(backlinks_enabled, status, inappropriate_content)", {
+      count: "exact",
+      head: true,
+    })
+    .in("status", ["ready", "published"])
+    .eq("site.backlinks_enabled", true)
+    .eq("site.status", "active")
+    .eq("site.inappropriate_content", false);
+  if (error) {
+    console.warn("[lx] exchange network-size query failed:", error.message);
+    // Fail safe: treat as small network, relax matching.
+    return 0;
+  }
+  return count ?? 0;
 }
@@ -219,4 +219,66 @@ describe("rankExchangeCandidates", () => {
     });
     expect(out[0].url).toMatch(/^https:\/\/threatcrush\.com\/blog\/[a-z-]+$/);
   });
+
+  it("relaxed mode (minScore=0) surfaces candidates with zero topic overlap", () => {
+    // freelancing niche has no token overlap with any fixture row.
+    // Strict mode returns [] (asserted above); relaxed should return
+    // something so the early-network case isn't permanently dead.
+    const strict = rankExchangeCandidates(FIX.rows, {
+      selfSiteId: FIX.selfId,
+      selfNiche: "AI-assisted freelancing and gig work",
+      keyword: "freelancer rate cards",
+      slots: 3,
+    });
+    expect(strict).toEqual([]);
+
+    const relaxed = rankExchangeCandidates(FIX.rows, {
+      selfSiteId: FIX.selfId,
+      selfNiche: "AI-assisted freelancing and gig work",
+      keyword: "freelancer rate cards",
+      slots: 3,
+      minScore: 0,
+    });
+    expect(relaxed.length).toBeGreaterThan(0);
+    expect(relaxed.length).toBeLessThanOrEqual(3);
+  });
+
+  it("relaxed mode still dedups by giver site and respects slot cap", () => {
+    const out = rankExchangeCandidates(FIX.rows, {
+      selfSiteId: FIX.selfId,
+      selfNiche: "completely unrelated topic",
+      keyword: "nothing in common",
+      slots: 2,
+      minScore: 0,
+    });
+    expect(out.length).toBeLessThanOrEqual(2);
+    const sites = new Set(out.map((c) => c.site_id));
+    expect(sites.size).toBe(out.length); // every result a distinct giver
+  });
+
+  it("relaxed mode prefers higher-scoring candidates when both have overlap and zero-overlap exist", () => {
+    // payments keyword should still surface the crypto-payments article
+    // first even in relaxed mode, before any zero-overlap stragglers.
+    const out = rankExchangeCandidates(FIX.rows, {
+      selfSiteId: FIX.selfId,
+      selfNiche: "payments and merchant tooling",
+      keyword: "crypto checkout flows",
+      slots: 3,
+      minScore: 0,
+    });
+    expect(out[0].site_id).toBe("site-coinpay");
+  });
+
+  it("relaxed mode tolerates an empty self-token set", () => {
+    // selfNiche null + keyword that tokenizes to nothing → strict returns
+    // []; relaxed should still fall back to recency-ordered candidates.
+    const out = rankExchangeCandidates(FIX.rows, {
+      selfSiteId: FIX.selfId,
+      selfNiche: null,
+      keyword: "",
+      slots: 2,
+      minScore: 0,
+    });
+    expect(out.length).toBeGreaterThan(0);
+  });
 });