> ## Documentation Index
> Fetch the complete documentation index at: https://docs.introw.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Campaigns & Announcements

> AI partner marketing automation generates segmented campaigns from LinkedIn posts, blogs, and Loom recordings, scaling partner-facing output without hiring.

export const UseCaseFlow = ({layout = "circuit", tagline, reads, from, agent, to, human, second, gate, builtFor = []}) => {
  const LOGOS = {
    salesforce: "Salesforce",
    hubspot: "HubSpot",
    introw: "Introw",
    notion: "Notion",
    slack: "Slack",
    "microsoft-teams": "Teams",
    gmail: "Email",
    claude: "Claude",
    chatgpt: "ChatGPT",
    crossbeam: "Crossbeam",
    mcp: "MCP"
  };
  const MONO = {
    crm: ["CRM", "Your CRM"],
    erp: ["ERP", "Your ERP"],
    finance: ["FIN", "Your finance system"],
    confluence: ["CF", "Confluence"],
    "google-drive": ["GD", "Google Drive"],
    box: ["BX", "Box"],
    zoom: ["ZM", "Zoom"],
    gong: ["GG", "Gong"],
    otter: ["OT", "Otter"],
    fathom: ["FA", "Fathom"],
    chorus: ["CH", "Chorus"],
    clay: ["CL", "Clay"],
    zoominfo: ["ZI", "ZoomInfo"],
    apollo: ["AP", "Apollo"],
    loom: ["LM", "Loom"],
    linkedin: ["LI", "LinkedIn"],
    mailchimp: ["MC", "Mailchimp"],
    portal: ["PT", "The portal"]
  };
  const parse = raw => {
    const at = String(raw).indexOf(":");
    const id = at === -1 ? String(raw) : String(raw).slice(0, at);
    const custom = at === -1 ? null : String(raw).slice(at + 1).trim();
    if (LOGOS[id]) return {
      id,
      label: custom || LOGOS[id],
      kind: "logo"
    };
    if (MONO[id]) return {
      id,
      label: custom || MONO[id][1],
      mono: MONO[id][0],
      kind: "mono"
    };
    return {
      id: null,
      label: custom ? `${id}:${custom}` : String(raw),
      kind: "data"
    };
  };
  const mark = (p, small) => {
    if (p.kind === "logo") {
      return <span className={small ? "ucf-lg ucf-lg-sm" : "ucf-lg"} style={{
        backgroundImage: `url(/images/integrations/${p.id}.png)`
      }} role="img" aria-label={LOGOS[p.id]} title={LOGOS[p.id]} />;
    }
    if (p.kind === "mono") {
      return <span className={small ? "ucf-mono ucf-mono-sm" : "ucf-mono"} title={MONO[p.id][1]}>
          {p.mono}
        </span>;
    }
    return null;
  };
  const chip = raw => {
    const p = parse(raw);
    return <span key={String(raw)} className={p.kind === "data" ? "ucf-chip ucf-chip-data" : "ucf-chip"}>
        {mark(p, true)}
        {p.label}
      </span>;
  };
  const node = raw => {
    const p = parse(raw);
    return <span key={String(raw)} className={p.kind === "data" ? "ucf-node ucf-node-soft" : "ucf-node"}>
        {mark(p, true)}
        <span className="ucf-node-txt">{p.label}</span>
      </span>;
  };
  const stack = side => side ? <div>
        {side.label ? <p className="ucf-cap ucf-cap-stack">{side.label}</p> : null}
        <div className="ucf-stack">{(side.nodes || []).map(n => node(n))}</div>
      </div> : <div />;
  const core = a => a ? <div className="ucf-core">
        <span className="ucf-wire ucf-wire-l" aria-hidden="true" />
        <span className="ucf-wire ucf-wire-r" aria-hidden="true" />
        <span className="ucf-core-name">
          {(a.logos || []).map((id, i) => <span key={id} className="ucf-core-logo">
              {i > 0 ? <span className="ucf-plus">+</span> : null}
              {mark(parse(id), (a.logos || []).length > 1)}
            </span>)}
          {a.name}
        </span>
        {a.sub ? <span className="ucf-core-sub">{a.sub}</span> : null}
        {(a.does || []).length > 0 ? <span className="ucf-rules">
            {(a.does || []).map(d => <span key={d}>{d}</span>)}
          </span> : null}
      </div> : <div />;
  const band = r => r && (r.of || []).length > 0 ? <div className="ucf-band-wrap">
        {r.label ? <p className="ucf-cap ucf-cap-band">{r.label}</p> : null}
        <div className="ucf-band">{(r.of || []).map(c => chip(c))}</div>
      </div> : null;
  const link = () => <div className="ucf-vlink" aria-hidden="true" />;
  const gateRow = g => g ? <div className="ucf-gate">
        <span className="ucf-gate-g">{typeof g === "string" ? g : g.text}</span>
      </div> : null;
  const humanRow = h => h ? <div className="ucf-human">
        <span className="ucf-human-who">{h.who}</span>
        {h.text ? <span className="ucf-human-what">{h.text}</span> : null}
        {(h.chips || []).map(c => chip(c))}
      </div> : null;
  const arrow = () => <div className="ucf-arrow" aria-hidden="true">
      <svg viewBox="0 0 40 20" preserveAspectRatio="none" focusable="false">
        <path d="M2 10 H30" strokeWidth="1.25" fill="none" />
        <path d="M28 6 L34 10 L28 14" strokeWidth="1.25" fill="none" strokeLinecap="round" strokeLinejoin="round" />
      </svg>
    </div>;
  const rolesCol = (side, kind, n) => side ? <div className={kind === "mid" ? "ucf-col ucf-col-mid" : "ucf-col ucf-col-side"}>
        <div className="ucf-col-hd">
          <span className="ucf-num">{n}</span>
          <span className="ucf-cap">{side.label}</span>
        </div>
        {kind === "mid" ? <>
            <span className="ucf-core-name">
              {(side.logos || []).map(id => <span key={id} className="ucf-core-logo">
                  {mark(parse(id), false)}
                </span>)}
              {side.name}
            </span>
            {side.sub ? <span className="ucf-core-sub">{side.sub}</span> : null}
            <span className="ucf-rules">
              {(side.does || []).map(d => <span key={d}>{d}</span>)}
            </span>
          </> : (side.nodes || []).map(raw => {
    const p = parse(raw);
    return <div key={String(raw)} className="ucf-item">
                {mark(p, true)}
                {p.label}
              </div>;
  })}
        {side.foot ? <p className="ucf-foot">{side.foot}</p> : null}
      </div> : <div />;
  return <div className="ucf not-prose">
      <style>{`
.ucf {
  --ucf-surface: #ffffff;
  --ucf-soft: #fafafa;
  --ucf-line: #e4e4e7;
  --ucf-line-soft: #f1f1f4;
  --ucf-dash: #d9d9de;
  --ucf-txt: #3f3f46;
  --ucf-strong: #18181b;
  --ucf-muted: #a1a1aa;
  --ucf-dim: #71717a;
  --ucf-arrow: #b8b8c0;
  --ucf-mono-bg: #f1f0ee;
  --ucf-mono-fg: #78716c;
  --ucf-accent-bg: linear-gradient(180deg, rgba(253,144,255,.10), rgba(253,144,255,.02));
  --ucf-accent-line: rgba(253,144,255,.35);
  --ucf-pill-bg: rgba(253,144,255,.10);
  --ucf-pill-fg: #a3389f;
  --ucf-pill-sub: #8c4c8f;
  container-type: inline-size;
  margin: 1.5rem 0;
  overflow: hidden;
  border: 1px solid var(--ucf-line);
  border-radius: 1rem;
  background: var(--ucf-surface);
  box-shadow: 0 1px 2px rgba(16,24,40,.03);
  font-size: 15px;
  line-height: 1.6;
  color: var(--ucf-txt);
}
.dark .ucf {
  --ucf-surface: rgba(255,255,255,.02);
  --ucf-soft: rgba(255,255,255,.025);
  --ucf-line: rgba(255,255,255,.10);
  --ucf-line-soft: rgba(255,255,255,.06);
  --ucf-dash: rgba(255,255,255,.16);
  --ucf-txt: #d4d4d8;
  --ucf-strong: #fafafa;
  --ucf-muted: #71717a;
  --ucf-dim: #a1a1aa;
  --ucf-arrow: #52525b;
  --ucf-mono-bg: rgba(255,255,255,.06);
  --ucf-mono-fg: #a1a1aa;
  --ucf-accent-bg: linear-gradient(180deg, rgba(253,144,255,.09), rgba(253,144,255,.02));
  --ucf-accent-line: rgba(253,144,255,.24);
  --ucf-pill-bg: rgba(253,144,255,.10);
  --ucf-pill-fg: #FD90FF;
  --ucf-pill-sub: #e6a9e8;
  box-shadow: none;
}
.ucf * { box-sizing: border-box; }
.ucf-tagline {
  margin: 0;
  padding: 11px 20px;
  border-bottom: 1px solid var(--ucf-line);
  background: linear-gradient(90deg, rgba(253,144,255,.08), rgba(253,144,255,.03), transparent);
  font-size: 13.5px;
  color: var(--ucf-dim);
}
.ucf-body {
  padding: 20px; display: grid; grid-template-columns: minmax(0, 1fr); gap: 0;
  --ucf-gap: clamp(14px, 4cqw, 32px);
}
.ucf-cap {
  margin: 0;
  font-size: 9.5px;
  font-weight: 700;
  letter-spacing: .1em;
  text-transform: uppercase;
  color: var(--ucf-muted);
}
.ucf-cap-band { text-align: center; margin-bottom: 7px; }
.ucf-cap-stack { margin-bottom: 7px; }

.ucf-lg {
  display: inline-block; flex: none; width: 20px; height: 20px;
  background-size: contain; background-repeat: no-repeat; background-position: center;
}
.ucf-lg-sm { width: 16px; height: 16px; }
.ucf-mono {
  display: inline-grid; place-items: center; flex: none; width: 20px; height: 20px;
  border-radius: 5px; background: var(--ucf-mono-bg); color: var(--ucf-mono-fg);
  font-size: 9px; font-weight: 700; letter-spacing: -.02em; line-height: 1;
}
.ucf-mono-sm { width: 16px; height: 16px; border-radius: 4px; font-size: 7.5px; }

.ucf-band { display: flex; justify-content: center; gap: 6px; flex-wrap: wrap; }
.ucf-chip {
  display: inline-flex; align-items: center; gap: 5px;
  border: 1px solid var(--ucf-line); background: var(--ucf-surface); border-radius: 7px;
  padding: 3px 7px 3px 5px; font-size: 12px; font-weight: 500; color: var(--ucf-txt);
  white-space: nowrap;
}
.ucf-chip-data { padding-left: 7px; border-style: dashed; color: var(--ucf-dim); font-weight: 400; }

.ucf-vlink { height: 20px; display: flex; justify-content: center; }
.ucf-vlink::before { content: ""; width: 0; border-left: 1px dashed var(--ucf-dash); }

.ucf-grid {
  position: relative; display: grid;
  grid-template-columns: minmax(0, 152px) minmax(120px, 1fr) minmax(0, 152px);
  gap: var(--ucf-gap); align-items: center;
}
.ucf-stack { display: grid; gap: 6px; }
.ucf-node {
  background: var(--ucf-surface); border: 1px solid var(--ucf-line); border-radius: 9px;
  padding: 7px 9px; display: flex; align-items: center; gap: 7px;
  font-size: 12.5px; color: var(--ucf-txt); font-weight: 500;
}
.ucf-node-soft { border-style: dashed; color: var(--ucf-dim); font-weight: 400; }
.ucf-node-txt { min-width: 0; }

.ucf-core {
  position: relative; background: var(--ucf-accent-bg); border: 1px solid var(--ucf-accent-line);
  border-radius: 12px; padding: 13px; text-align: center;
  display: grid; gap: 7px; justify-items: center;
}
.ucf-core-name {
  font-size: 14px; font-weight: 600; color: var(--ucf-strong);
  display: flex; align-items: center; gap: 7px; justify-content: center; flex-wrap: wrap;
}
.ucf-core-logo { display: inline-flex; align-items: center; gap: 7px; }
.ucf-plus { color: var(--ucf-muted); font-weight: 400; }
.ucf-core-sub { font-size: 12px; color: var(--ucf-pill-sub); line-height: 1.45; }
.ucf-rules { display: flex; flex-wrap: wrap; gap: 4px; justify-content: center; }
.ucf-rules span {
  font-size: 11px; color: var(--ucf-pill-fg); background: var(--ucf-pill-bg);
  border-radius: 5px; padding: 2px 7px;
}
.ucf-wire { position: absolute; top: 50%; height: 1px; background: var(--ucf-line); }
.ucf-wire-l { left: calc(-1 * var(--ucf-gap)); right: 100%; }
.ucf-wire-r { left: 100%; right: calc(-1 * var(--ucf-gap)); }
.ucf-wire::after {
  content: ""; position: absolute; right: -1px; top: -3px;
  border-left: 5px solid var(--ucf-arrow);
  border-top: 3.5px solid transparent; border-bottom: 3.5px solid transparent;
}

.ucf-gate { display: flex; justify-content: center; }
.ucf-gate-g {
  font-size: 11.5px; color: var(--ucf-dim); background: var(--ucf-surface);
  border: 1px dashed var(--ucf-line); border-radius: 100rem; padding: 4px 12px; text-align: center;
}
.ucf-human {
  display: flex; align-items: center; justify-content: center; gap: 9px; flex-wrap: wrap;
  border-radius: 10px; padding: 9px 12px; background: var(--ucf-soft);
  border: 1px dashed var(--ucf-line);
}
.ucf-human-who { font-size: 12.5px; font-weight: 600; color: var(--ucf-txt); }
.ucf-human-what { font-size: 12.5px; color: var(--ucf-dim); }

.ucf-roles { display: grid; gap: 8px; }
.ucf-strip {
  display: flex; align-items: center; gap: 10px; flex-wrap: wrap; border-radius: 10px;
  padding: 9px 12px; background: var(--ucf-soft); border: 1px solid var(--ucf-line-soft);
}
.ucf-strip-dashed { background: var(--ucf-surface); border-style: dashed; border-color: var(--ucf-line); }
.ucf-strip-txt { font-size: 12.5px; color: var(--ucf-txt); }
.ucf-strip-spacer { flex: 1; }
.ucf-chiprow { display: flex; flex-wrap: wrap; gap: 5px; }
.ucf-num {
  font-size: 10px; font-weight: 700; color: var(--ucf-surface); background: var(--ucf-strong);
  width: 15px; height: 15px; border-radius: 50%; display: grid; place-items: center;
  flex: none; line-height: 1;
}
.dark .ucf-num { color: #18181b; background: #d4d4d8; }
.ucf-mid3 {
  display: grid;
  grid-template-columns: minmax(0, 1fr) clamp(20px, 5cqw, 42px) minmax(0, 1fr) clamp(20px, 5cqw, 42px) minmax(0, 1fr);
  align-items: stretch;
}
.ucf-col { border-radius: 10px; padding: 12px; display: flex; flex-direction: column; gap: 9px; }
.ucf-col-side { background: var(--ucf-soft); border: 1px solid var(--ucf-line-soft); }
.ucf-col-mid { background: var(--ucf-accent-bg); border: 1px solid var(--ucf-accent-line); }
.ucf-col-hd { display: flex; align-items: center; gap: 6px; }
.ucf-item { display: flex; align-items: center; gap: 7px; font-size: 12.5px; color: var(--ucf-txt); }
.ucf-col .ucf-core-name, .ucf-col .ucf-rules { justify-content: flex-start; }
.ucf-col .ucf-core-sub { text-align: left; }
.ucf-foot { margin: auto 0 0; padding-top: 10px; font-size: 11px; line-height: 1.4; color: var(--ucf-muted); }
.ucf-arrow { display: grid; place-items: center; }
.ucf-arrow svg { width: 100%; height: 20px; overflow: visible; stroke: var(--ucf-line); }
.ucf-arrow svg path + path { stroke: var(--ucf-arrow); }

.ucf-footer {
  display: flex; flex-wrap: wrap; align-items: center; gap: 6px;
  margin-top: 16px; padding-top: 12px; border-top: 1px solid var(--ucf-line-soft);
}
.ucf-footer-lbl {
  font-size: 10px; font-weight: 600; letter-spacing: .1em; text-transform: uppercase;
  color: var(--ucf-muted); margin-right: 2px;
}
.ucf-role { font-size: 12px; color: var(--ucf-txt); background: var(--ucf-soft); border-radius: 6px; padding: 2px 7px; }

/* ── narrow fallback ──────────────────────────────────────────────────────
   Keyed on the CARD's width, not the viewport, because the docs column varies
   enormously: measured at 457px on a 1280px laptop (both rails showing) and
   664px at 1680px. A viewport media query would leave the three-column row
   crushed to an 83px middle on the most common laptop. Below 470px of card the
   layout collapses to one column and the horizontal wires become the same
   dashed vertical link used elsewhere, so the reading order stays
   trigger -> agent -> outcome. */
@container (max-width: 470px) {
  .ucf-grid, .ucf-mid3 { grid-template-columns: 1fr; gap: 0; }
  .ucf-wire, .ucf-arrow { display: none; }
  .ucf-grid > * + *, .ucf-mid3 > * + * { position: relative; margin-top: 22px; }
  .ucf-grid > * + *::before, .ucf-mid3 > * + *::before {
    content: ""; position: absolute; top: -22px; left: 50%; height: 22px;
    border-left: 1px dashed var(--ucf-dash);
  }
  .ucf-core { text-align: left; justify-items: start; }
  .ucf-core-name, .ucf-rules { justify-content: flex-start; }
  /* nodes size to their content and sit side by side instead of becoming
     full-width bars, which halves the height of the stacked form */
  .ucf-stack { display: flex; flex-wrap: wrap; gap: 5px; }
  .ucf-node { font-size: 12px; padding: 5px 8px; }
  .ucf-band { justify-content: flex-start; }
  .ucf-cap-band { text-align: left; }
  .ucf-body { padding: 16px; }
  .ucf-gate-g { text-align: left; border-radius: 10px; }
}
      `}</style>

      {tagline ? <p className="ucf-tagline">{tagline}</p> : null}

      <div className="ucf-body">
        {layout === "roles" ? <div className="ucf-roles">
            {from ? <div className="ucf-strip">
                <span className="ucf-num">1</span>
                <span className="ucf-cap">{from.label}</span>
                {from.text ? <span className="ucf-strip-txt">{from.text}</span> : null}
                <span className="ucf-strip-spacer" />
                <span className="ucf-chiprow">{(from.nodes || []).map(c => chip(c))}</span>
              </div> : null}
            <div className="ucf-mid3">
              {rolesCol(reads, "side", 2)}
              {arrow()}
              {rolesCol(agent, "mid", 3)}
              {arrow()}
              {rolesCol(to, "side", 4)}
            </div>
            {gate ? <div className="ucf-strip ucf-strip-dashed">
                {typeof gate === "string" ? null : <span className="ucf-cap">{gate.label}</span>}
                <span className="ucf-strip-txt">{typeof gate === "string" ? gate : gate.text}</span>
              </div> : null}
          </div> : <>
            {band(reads)}
            {band(reads) ? link() : null}
            <div className="ucf-grid">
              {stack(from)}
              {core(agent)}
              {stack(to)}
            </div>
            {human ? link() : null}
            {humanRow(human)}
            {second ? link() : null}
            {second ? <div className="ucf-grid">
                {stack(second.from)}
                {core(second.agent)}
                {stack(second.to)}
              </div> : null}
            {gate ? link() : null}
            {gateRow(gate)}
          </>}

        {builtFor.length > 0 ? <div className="ucf-footer">
            <span className="ucf-footer-lbl">Built for</span>
            {builtFor.map(role => <span key={role} className="ucf-role">
                {role}
              </span>)}
          </div> : null}
      </div>
    </div>;
};

export const Tldr = ({children}) => <div className="tldr not-prose">
    <style>{`
.tldr {
  margin: 1.5rem 0;
  overflow: hidden;
  border: 1px solid #e4e4e7;
  border-radius: 1rem;
  background: #ffffff;
  box-shadow: 0 1px 2px rgba(16,24,40,.03);
}
.dark .tldr {
  border-color: rgba(255,255,255,.10);
  background: rgba(255,255,255,.02);
  box-shadow: none;
}
.tldr-hd {
  display: flex;
  align-items: center;
  gap: 7px;
  padding: 9px 20px;
  border-bottom: 1px solid #e4e4e7;
  background: linear-gradient(90deg, rgba(253,144,255,.13), rgba(253,144,255,.04), transparent);
}
.dark .tldr-hd {
  border-bottom-color: rgba(255,255,255,.10);
  background: linear-gradient(90deg, rgba(253,144,255,.11), rgba(253,144,255,.03), transparent);
}
/* three lines, the last one cut short: the short version of a longer text */
.tldr-ico {
  width: 13px;
  height: 11px;
  flex: none;
  stroke: #c23fce;
  stroke-width: 1.6;
  stroke-linecap: round;
  fill: none;
}
.dark .tldr-ico { stroke: #FD90FF; }
.tldr-lbl {
  font-size: 9.5px;
  font-weight: 700;
  letter-spacing: .12em;
  text-transform: uppercase;
  color: #a3389f;
}
.dark .tldr-lbl { color: #FD90FF; }
.tldr-body {
  margin: 0;
  padding: 15px 20px 17px;
  background: rgba(253,144,255,.03);
  font-size: 15px;
  line-height: 1.65;
  color: #3f3f46;
}
.dark .tldr-body {
  background: rgba(253,144,255,.025);
  color: #d4d4d8;
}
@media (max-width: 640px) {
  .tldr-hd { padding: 8px 16px; }
  .tldr-body { padding: 13px 16px 15px; font-size: 14.5px; }
}
    `}</style>

    <div className="tldr-hd">
      <svg className="tldr-ico" viewBox="0 0 13 11" aria-hidden="true" focusable="false">
        <path d="M1 1.5h11M1 5.5h11M1 9.5h5" />
      </svg>
      <span className="tldr-lbl">TL;DR</span>
    </div>

    <p className="tldr-body">{children}</p>
  </div>;

<Tldr>Most partner marketing managers ship one generic newsletter a month, and pay the cost in cadence, relevance, or both. AI-driven partner marketing automation converts any source content (LinkedIn posts, blogs, product launches, Loom recordings) into segmented partner-facing campaigns customized per tier, region, vertical, and partner type. Output multiplies 10–20× without hiring; segmentation lifts engagement 2–4× over generic blasts.</Tldr>

## How it works

<UseCaseFlow
  layout="circuit"
  tagline="Source content becomes segmented, partner-ready outreach in hours"
  reads={{
label: "Reads whatever you already published",
of: ["notion", "confluence", "linkedin", "loom", "introw:Release notes"],
}}
  from={{ label: "Starts from", nodes: ["A launch or an update", "notion:Your source content"] }}
  agent={{
name: "Introw agent",
logos: ["introw"],
does: ["Judge relevance", "Segment", "Write the variants"],
}}
  to={{
label: "Distributed via",
nodes: ["gmail:Email", "slack:Slack", "microsoft-teams:Teams", "introw:The portal"],
}}
  gate="One variant per segment, by tier, region, vertical and type, with engagement tracked."
  builtFor={["Partner Marketing Manager", "Vendor Marketing"]}
/>

## What is partner marketing automation?

**Partner marketing automation is the use of AI agents to generate, segment, and distribute partner-facing campaigns from any source content, including executive LinkedIn posts, product launches, press releases, blog posts, and Loom recordings, with each variant tailored per tier, region, vertical, partner type, and language.** It replaces the manual partner-newsletter model with a continuous, segmented stream of relevant communications that scales without expanding the partner marketing headcount.

## The partner marketing impossible triangle

Every partner marketing manager knows the constraint set:

* **Cadence**: partners need a continuous stream of relevant content to stay engaged
* **Relevance**: generic blasts get ignored
* **Headcount**: nobody has the budget to hire 10 partner marketing managers

You can have any two. You can never have all three. Most programs end up with low cadence (one newsletter a month), low relevance (the same content for every segment), or both, which is why partner email open rates and content download rates are widely treated as "engagement theater" by the people producing them.

The cost isn't just unread newsletters. **96% of B2B marketers expect to increase revenue attributable to channel partners** (Demand Gen Report / Channel Marketing Benchmark), but most can't, because their partners aren't sufficiently informed or motivated to sell. Communication is the carrier wave for everything else, campaigns, announcements, product launches, competitive responses. Get the carrier wave wrong and the rest doesn't matter.

## How does AI campaign generation work for channel marketing?

Introw's campaign system rebuilds the workflow around continuous, segmented, agent-assisted output.

A **background agent scans the vendor's LinkedIn weekly** and converts relevant posts into partner-segmented outreach the partner marketing manager can publish with one click. Every published post becomes the seed for a partner-relevant variation: an email to enterprise SIs, a Slack drop to high-velocity resellers, a portal announcement for the regional partners who serve healthcare. The marketing team doesn't have to lift the post into a campaign; the campaign is generated from the post.

The on-page **AI Assistant** lets the partner marketing manager edit announcements in natural language. *"Make this more technical for our SI segment."* *"Shorten this and add a CTA to the new MDF-eligible co-marketing program."* *"Translate this into German and adapt for our DACH resellers, who care more about compliance than the use case."* What used to require a copywriter and a half-day of revisions is now an inline agent prompt.

Campaigns can also be generated **from scratch** off any source material, a blog post, a product launch announcement, a press release, even a Loom recording the CEO sent on Slack. The agent extracts the core message, generates audience-segmented versions, and queues them for review.

Segmentation rules live in Introw, by tier, region, partner type, vertical, so every recipient gets a relevant version. No spray-and-pray. The agent does the audience-specific rewriting that human marketers don't have time to do. (For deeper detail on how segmentation works, see [the partner segmentation deep-dive](/headless/agentic-use-cases/partner-segmentation).)

## Who wins, and how

**Partner Marketing Managers** see their output multiply by **10–20×** without hiring. The same person who used to ship one newsletter a month is now shipping segmented updates after every product launch, every executive LinkedIn post, every competitive shift. The bottleneck stops being content production and starts being content strategy, which is the work the role should have been doing all along.

**Partner Sellers** start receiving communications that actually relate to their business. The healthcare-focused SI gets healthcare positioning. The high-velocity SMB reseller gets transactional offers. Industry research consistently shows that relevance is the single biggest driver of partner content engagement, a generic blast to a tier produces a fraction of the response of a tailored message to a specific segment.

**Vendor Marketing Teams** stop watching their best work die in the partner channel. The CEO's banger LinkedIn post used to be invisible to the partner ecosystem until someone got around to repackaging it. Now the agent ships partner-segmented versions of it within hours.

**Partners' end customers** see consistent, current messaging from every partner in the ecosystem. The competitive battle card that the vendor updated yesterday is in the field today, in every language, in every region.

## Key statistics: partner marketing automation impact

* **B2B marketer expectations**: 96% expect to increase channel partner revenue (Channel/Partner Marketing Benchmark Survey)
* **Output multiplier**: partner marketing managers move from \~4 partner-facing communications/month to **40–80** with agent assistance, a 10–20× lift
* **Engagement lift from segmentation**: comparable B2B benchmarks show segmented content drives **2–4× the open and click rates** of generic blasts
* **Time-to-market for announcements**: from days/weeks to hours; product launches reach every partner segment within 4 hours of public release
* **Localization economics**: agent-assisted translation collapses the cost of running region-specific campaigns to near zero
* **Partner-facing content velocity**: competitive responses (e.g., a new competitor entering the market) ship to all enabled partners within an hour, not weeks

## Release notes are the highest-leverage source

Partner-marketing radars usually focus on LinkedIn and blog posts. The source most often missed, and the highest-leverage, is the vendor's own release-notes feed. Every shipped feature is something partners need to position with prospects this week, but most release notes never reach partner-facing comms in time. The agent reads each release entry, filters out internal-only churn, and converts the rest into three derivatives per partner segment: a one-line “what's new” alert, talking points for partner sellers in active deals where the feature matters, and a customer-ready outreach template the partner can forward into their pipeline. There's also the partner-side mirror: a unified calendar of every vendor's upcoming launches, MDF cycles, webinars, and tier windows so the partner can plan customer outreach *around* vendor activity, not after it.

## The deeper shift

Partner marketing has been stuck in a 1995 newsletter model for far too long. Templates, blasts, lowest-common-denominator copy, manual segmentation when there's time. Most program-level data shows partners increasingly tune out vendor communications, not because they don't want to hear from the vendor, but because the cost of parsing irrelevant content has finally exceeded the value of finding the relevant bits.

The agentic model rebuilds the relationship around relevance. Every partner gets a feed that actually applies to them. The vendor's best content, the executive LinkedIn posts, the product launches, the competitive intelligence, the customer wins, flows continuously into the partner ecosystem in the right shape, in the right language, to the right segment.

Partner marketing stops being a content factory and starts being an editorial operation. The output goes up by an order of magnitude, the relevance goes up at the same time, and the headcount stays flat. That's the ratio that finally cracks the partner marketing impossible triangle. For complementary capabilities, see [AI partner training](/headless/agentic-use-cases/training) (which uses the same content sources for course generation) and [partner segmentation](/headless/agentic-use-cases/partner-segmentation) (which feeds the segmentation rules).

## Key takeaways

<Card title="Key takeaways" icon="list-check">
  * **Definition**: AI-driven partner marketing automation uses background agents to convert any source content (LinkedIn posts, product launches, blogs, Loom recordings) into segmented partner-facing campaigns customized per tier, region, vertical, and partner type.
  * **The cost of generic blasts**: 96% of B2B marketers expect channel revenue to grow, but most struggle to scale partner-facing communications because manual production caps cadence and relevance.
  * **Introw's approach**: a background agent scans the vendor's LinkedIn weekly and converts posts into segmented outreach; an inline AI Assistant edits announcements in natural language; segmentation rules ensure every recipient gets a relevant version.
  * **Headline outcome**: partner marketing managers ship **10–20× more partner-facing content** with the same headcount, and segmentation typically lifts engagement 2–4× over generic blasts.
  * **Stakeholders**: Partner Marketing Managers, Partner Sellers, Vendor Marketing, partners' end customers.
</Card>

## Frequently asked questions

<AccordionGroup>
  <Accordion title="What is partner marketing automation?">
    Partner marketing automation is the use of AI agents to generate, segment, and distribute partner-facing campaigns at scale, from any source content (LinkedIn posts, blogs, product launches, Loom recordings) and customized per tier, region, vertical, partner type, and language. It replaces manual newsletter production with a continuous, segmented content stream.
  </Accordion>

  <Accordion title="How does AI generate partner-facing campaigns?">
    An AI agent scans source content (executive LinkedIn posts, blog publications, product launches, internal Loom recordings) and converts each into multiple partner-segmented versions. Each version is tailored to a specific audience, enterprise SIs, high-velocity resellers, regional MSPs, vertical specialists, using segmentation rules defined in the PRM. The partner marketing manager reviews and publishes with one click.
  </Accordion>

  <Accordion title="How much can partner marketing output increase with AI?">
    Partner marketing managers using AI campaign generation typically ship **10–20× more partner-facing communications** with the same headcount. Where the manual model produces \~4 newsletters per month, the agentic model produces 40–80 segmented campaigns covering every product launch, executive post, and competitive shift.
  </Accordion>

  <Accordion title="What is partner content segmentation?">
    Partner content segmentation is the practice of customizing communications per partner tier, region, vertical, partner type (reseller, SI, referral), and language. Effective segmentation typically drives **2–4× the engagement** of generic blasts, because partners invest attention in content that's relevant to their actual business motion.
  </Accordion>

  <Accordion title="Can AI translate partner communications into multiple languages?">
    Yes, Introw's campaign generation includes natural-language translation and localization, allowing a single source post to be adapted for partners in DACH, LATAM, APAC, and other regions. The agent doesn't just translate; it adapts tone and emphasis (e.g., compliance-forward for DACH, use-case-forward for the US) per regional preferences.
  </Accordion>

  <Accordion title="How does AI partner marketing integrate with existing tools?">
    Introw connects to source content systems (LinkedIn, blog CMS, asset libraries, Notion, Slack, Loom) via MCP, and to delivery systems (email platforms, Slack workspaces, partner portals, Microsoft Teams). The agent orchestrates the workflow without requiring a rip-and-replace of the existing marketing stack.
  </Accordion>

  <Accordion title="What's the difference between to-partner and through-partner marketing?">
    **To-partner marketing** is the vendor's communications *to* their partners, newsletters, announcements, product updates, competitive intelligence. **Through-partner marketing** is the marketing assets the vendor provides for partners to use *with their end customers*, campaigns, social posts, email templates, landing pages. AI partner marketing automation accelerates both, generating segmented to-partner messaging and customizable through-partner assets from the same source content.
  </Accordion>
</AccordionGroup>

## Run it in Claude Code

Each workflow ships as a Claude Code skill, a `SKILL.md` file you drop into `.claude/skills/<skill-name>/SKILL.md`. Claude triggers it on the prompts in the skill's description. See the [full skill library](/headless/skills) for the complete files.

<CardGroup cols={2}>
  <Card title="Content Radar & Distribution" icon="wrench" href="/headless/skills/vendor/content-radar">
    Continuously scans the vendor's LinkedIn, blogs, industry publications, and competitor news; filters to partner-relevant content; transforms into partner-ready language per segment; distributes and tracks via Introw.
  </Card>

  <Card title="Cross-Vendor Content & Activity Calendar" icon="wrench" href="/headless/skills/partner/cross-vendor-content-calendar">
    Partner-side: unified calendar of every vendor's upcoming launches, webinars, MDF programs, and tier windows, ranked by relevance to the partner's actual customer base. Plan outreach around vendor activity, not after it.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.