> ## 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.

# Channel Conflict

> Channel conflict screening checks every referred lead against your direct and partner pipeline before crediting, so referrers never lose deals to overlap.

export const Headless = ({children, intro = true}) => {
  const [copied, setCopied] = useState(null);
  const copy = event => {
    const row = event.target.closest("li");
    if (!row) return;
    const text = row.textContent.trim();
    try {
      navigator.clipboard?.writeText(text);
    } catch {}
    setCopied(text);
    setTimeout(() => setCopied(null), 1600);
  };
  return <>
      {intro ? <p>
          Introw is <strong>headless</strong> by design: run everything here in plain language from Claude, ChatGPT,
          Slack, Teams, or your own CRM through Introw's <a href="/features/developer/mcp">MCP server</a>, with every
          action written straight back to your CRM source of truth. The portal is one surface, never the only one.
        </p> : null}

      {children ? <div className="not-prose" data-prompts="block">
          <div data-prompts="head">
            <span>{copied ? "Copied" : "Try it from your LLM"}</span>
          </div>
          <div data-prompts="rows" onClick={copy}>
            {children}
          </div>
          <a href="/headless/prompts" data-prompts="more">
            See all prompts
          </a>
        </div> : <Card title="See the headless motion" icon="wand-magic-sparkles" href="/headless">
          The agentic motion - lifecycle deep dives and a Claude Code skill library that run your partner program from
          Claude, ChatGPT, Slack, and your CRM.
        </Card>}
    </>;
};

export const Tour = ({children}) => {
  const [active, setActive] = useState(0);
  const wrappers = (Array.isArray(children) ? children : [children]).filter(c => c && c.props);
  const frames = wrappers.length === 1 && Array.isArray(wrappers[0].props.children) ? wrappers[0].props.children.filter(c => c && c.props) : [];
  if (frames.length < 2) {
    return <div className="not-prose" data-overview="tour">
        {children}
      </div>;
  }
  const thumb = (frame, index) => <button key={index} type="button" onClick={() => setActive(index)} aria-label={`Frame ${index + 1}`} data-active={index === active ? "true" : "false"} data-index={index + 1}>
      {frame}
    </button>;
  return <div className="not-prose" data-overview="tour">
      <div data-tour="hero">{frames[active] ?? frames[0]}</div>
      <div data-tour="strip">{frames.map((frame, index) => thumb(frame, index))}</div>
    </div>;
};

export const Impact = ({children}) => <div className="not-prose" data-overview="impact">
    {children}
  </div>;

export const Personas = ({children}) => <div className="not-prose" data-overview="personas">
    {children}
  </div>;

export const Pains = ({children}) => <div className="not-prose" data-overview="pains">
    {children}
  </div>;

> Nothing kills a referral program faster than a partner referring a deal your direct team already has. Channel conflict screening checks every referral against your pipeline before it credits, so the referrer knows their intro will be recognized and never quietly duplicated.

## The problem it solves

A referral program leaks trust at the point of overlap:

<Pains>
  | Without Introw                   | With Introw                     |
  | -------------------------------- | ------------------------------- |
  | A partner refers a deal you have | Overlap is caught before credit |
  | Two partners refer one account   | The earlier claim is surfaced   |
  | Duplicates pile up quietly       | Matched against pipeline first  |
  | Disputed credit stops referrals  | Handled on facts, up front      |
</Pains>

## Impact

A referral is a promise about credit. Screening every intro against your own pipeline before it counts is how you keep that promise, and keeping it is why a referrer sends the second one.

<Impact>
  for your business

  * **Trustworthy**
    Overlaps are caught and resolved on facts, so a referrer's intro is honoured rather than quietly duplicated
  * **In your CRM**
    Screening runs against the deals already in HubSpot or Salesforce, not a separate referral database

  for your partners

  * **Self-serve**
    They learn where they stand at submission, instead of finding out at payout time
  * **Enabled**
    Knowing an intro will be screened fairly is what makes referring worth the effort
  * **Efficient**
    One check up front, rather than an argument about credit months later

  [A day in the life of a referral partner](/days-in-the-life/referral-partner)
</Impact>

<Personas>
  * **Partner Managers** - clean credit without policing
  * **Chief Revenue Officer** - direct and referral kept aligned
  * **Referral partners** - an intro that will be honoured
</Personas>

## See it work

<Tour>
  * ![The Channel Conflict Analysis panel, choosing the object to screen against with filters and additional context.](https://assets.introw.io/docs/features/ai/channel-conflict/guides/catch-and-resolve-channel-conflict/steps/04.png)

    **Turn on the screen**

    Pick the object to check against, and narrow it with filters.

  * ![Channel Conflict Analysis enabled on a referral form, with its object, filters and additional context.](https://assets.introw.io/docs/features/referrals/lead-sharing/guides/build-and-share-a-referral-form/steps/11.png)

    **On the referral form**

    The same screen runs on the form partners refer through.
</Tour>

## How it works

When a partner refers a lead, Introw cross-references your CRM for an existing opportunity on the same account. That covers both cases: the direct team already has it, or another partner referred it first. The check runs before the referral creates records or credits anyone. Overlaps are flagged with the context: who's involved and which claim came first. A clean referral flows through and lands attributed; an overlapping one is surfaced so credit is decided fairly instead of the same deal being double-counted.

This is the same [AI channel-conflict engine](/features/ai/channel-conflict) that runs across every submission motion, applied to the referral flow. What's specific to referrals is what's protected - the referrer's trust that a warm intro will be honored, which is the whole basis of a program that keeps producing.

Screening makes a referral a promise you can keep. The partner refers, Introw checks the lead against your pipeline, and only a conflict-free (or fairly resolved) referral becomes attributed pipeline the referrer will be rewarded for.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart LR
  refer["Partner refers"] --> screen["Conflict screen vs. pipeline"]
  screen -->|clear| credited["Attributed, credited lead"]
  screen -->|overlap| resolve["Flagged for fair resolution"]
```

## Run it from your AI assistant

<Headless>
  * Does this referral overlap a deal our direct team already has?
  * Has anyone else referred this account before?
  * Which shared leads conflict with existing pipeline?
</Headless>

## Going deeper

<CardGroup cols={2}>
  <Card title="Set up conflict screening" icon="robot" href="/features/ai/channel-conflict">
    Configure detection and resolution on the AI channel-conflict page.
  </Card>

  <Card title="Catch and resolve channel conflict" icon="book-open" href="/features/ai/channel-conflict/guides/catch-and-resolve-channel-conflict">
    Turn on screening for a referral form and work conflicts from the inbox.
  </Card>
</CardGroup>

**Works with**

<CardGroup cols={2}>
  <Card title="Channel Conflict Resolution" icon="robot" href="/features/ai/channel-conflict">
    The AI engine that detects and resolves conflict.
  </Card>

  <Card title="Lead Sharing" icon="share-from-square" href="/features/referrals/lead-sharing">
    Every referral is screened before it credits.
  </Card>

  <Card title="Referral Rewards" icon="share-from-square" href="/features/referrals/rewards">
    Clean attribution protects the reward that pays out.
  </Card>
</CardGroup>