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

# AI Approvals

> An AI reviewer that validates partner submissions - deal registrations, MDF requests, claims, leads - against your rules and escalates only the exceptions.

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>;

> Every partner submission - a registered deal, an MDF request, a claim, an invoice - waits in a queue for someone to check it. AI Approvals reviews each one against your own rules the moment it lands, clears the routine ones, and escalates only what genuinely needs judgment.

## The problem it solves

Manual approval is where partner momentum dies:

<Pains>
  | Without Introw                   | With Introw                      |
  | -------------------------------- | -------------------------------- |
  | Submissions sit in a queue       | Reviewed the moment they land    |
  | Routine cases still need a human | Cleared above your certainty bar |
  | Reviews vary between people      | Checked against written rules    |
  | Approvers drown in volume        | Only uncertain cases escalate    |
</Pains>

## Impact

Approval speed is the clearest signal a partner gets about whether you want their business. Seconds instead of days changes what they bother bringing you at all.

<Impact>
  for your business

  * **AI, not admin**
    The reviewer does the first pass on deal regs, MDF, claims, ROI, invoices and shared leads
  * **Cost to run**
    You write the rules in plain language, or let Introw draft them from the form, with no engineering
  * **Trustworthy**
    Every submission is judged on the same rules, and the reasoning is shown to your approvers

  for your partners

  * **Self-serve**
    A well-documented request comes back approved in seconds rather than waiting on a queue
  * **Enabled**
    A returned submission says what is missing, so the second attempt is the last one
  * **Efficient**
    Nothing sits unread: the review starts the moment they press submit

  [A day in the life of your partners](/days-in-the-life)
</Impact>

<Personas>
  * **Partner Operations** - the rules and the certainty bar
  * **Partner Marketing** - MDF approvals that move
  * **Partners** - an answer while it matters
</Personas>

## See it work

<Tour>
  * ![The Approval Gate on a form's automations, which holds a submission for a human decision before any automation runs on it.](https://assets.introw.io/docs/features/ai/approvals/shots/gate.png)

    **Put a gate in front of it**

    Nothing automated runs until a person has said yes.

  * ![A form submission open for review, with the submitted fields on its activity thread and the partner it came from beside them.](https://assets.introw.io/docs/features/ai/approvals/shots/submission.png)

    **Decide on the real thing**

    The submission, its fields and the partner behind it, in one view.
</Tour>

## How it works

AI Approvals - **Introw AI validation** in the product - puts an AI reviewer on the front of your approval workflows. You write the rules in plain language, or let Introw draft them from the form. When a partner submits, the AI checks the submission against them. Is the proof attached? Is the amount in policy? Does the deal look real? Is anything missing? It then guides the outcome - accept, decline, or return for more information - with the reasoning shown to your approvers.

Turn on auto-execution and set a certainty threshold, and the AI acts on its own above that bar, escalating only the submissions it isn't confident about to your human [acceptance steps](/features/forms/submissions-approvals). The same reviewer works across deal registrations, [MDF](/features/mdf) requests, claims, ROI, and invoices, and shared leads - anywhere partners submit a form. [Channel conflict](/features/ai/channel-conflict) screening runs alongside it as the conflict-specific check.

A partner no longer waits for a person to open their submission. The AI validates it against your rules on arrival and clears the clear cases. Your team gets only the ones that need a decision, with the facts already laid out.

```mermaid theme={"theme":{"light":"github-light","dark":"github-dark"}}
flowchart LR
  submit["Partner submits"] --> review["AI validates against your rules"]
  review --> clear["Clears routine cases"]
  review --> escalate["Escalates the rest to a human"]
```

## Run it from your AI assistant

<Headless>
  * Review this MDF claim against our proof-of-spend rules.
  * Is this deal registration complete enough to approve?
  * Return the submissions that are missing required documents.
</Headless>

## Going deeper

<CardGroup cols={2}>
  <Card title="How to" icon="screwdriver-wrench" href="./technical">
    Configure AI validation, instructions, and the certainty threshold.
  </Card>

  <Card title="API reference" icon="code" href="/general/introduction">
    Endpoints and code.
  </Card>
</CardGroup>

**Works with**

<CardGroup cols={2}>
  <Card title="Submissions & Approvals" icon="table-list" href="/features/forms/submissions-approvals">
    Runs inside the submission approval workflow.
  </Card>

  <Card title="Deal Registration" icon="file-signature" href="/features/deal-registration/registration">
    Validates deal registrations before they sync.
  </Card>

  <Card title="Channel Conflict Resolution" icon="robot" href="/features/ai/channel-conflict">
    The conflict-specific screen alongside validation.
  </Card>
</CardGroup>