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

# Retrain the Brain

> Compile a new draft from newer conversations and your team's review decisions, without changing anything for customers.

A retrain compiles a new Brain draft. It reads your past imports, your team's
review work, and, if you allow it, your live conversations. It produces a draft
next to the version you run today.

Nothing changes for customers until you review and publish the new draft.

Open it from **Retrain** in the Brain header, or go to `/brain/retrain`.
Retraining is limited to owners and admins.

<Frame caption="The retrain form: sources, depth, and goals.">
  <img src="https://mintcdn.com/kai-support/RaOwCZDRMIUnRjWu/images/en/retrain.png?fit=max&auto=format&n=RaOwCZDRMIUnRjWu&q=85&s=b36fe4725138314055c95923ae8bd350" alt="The retrain form" width="2880" height="3800" data-path="images/en/retrain.png" />
</Frame>

## When to retrain

Retrain when the source material changed, not when a single answer is wrong.

Retrain when:

* your team reviewed a few weeks of live conversations, and the corrections
  should become part of the Brain;
* you changed a product, a package or a process, and you have real
  conversations that show the new one;
* you uploaded a newer chat export;
* Kai keeps missing a question your customers now ask often.

Do not retrain when:

* one answer is wrong. Edit it in the review queue, and publish a new draft.
* a price is wrong. Change the fact. Read
  [Current information](/product/current-information).

## What Kai learns from

<Frame caption="The source list, with a live count next to each source.">
  <img src="https://mintcdn.com/kai-support/RaOwCZDRMIUnRjWu/images/en/retrain-sources.png?fit=max&auto=format&n=RaOwCZDRMIUnRjWu&q=85&s=114b61f36db6921d811d9f7d4247f980" alt="What Kai learns from" width="1456" height="1376" data-path="images/en/retrain-sources.png" />
</Frame>

Selected sources are merged into one corpus, personal data is replaced with
placeholders, and everything is compiled together.

| Source                             | What it contributes                                                                                                                 |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| **Past imports**                   | The chat exports you already uploaded, at onboarding or with an earlier retrain. This is the bulk of what Kai knows. On by default. |
| **Reviewed conversations**         | Conversations your team annotated in the console. On by default.                                                                    |
| **Console test & operate threads** | Rated or corrected replies from the console. On by default.                                                                         |
| **All live conversations**         | Everything your channels handled, reviewed or not. Off by default. You can limit it by source and by date.                          |
| **New files**                      | Another export attached to this run: a WhatsApp `.csv` or `.txt`, or an Intercom `.json`.                                           |

### The rule that protects the Brain

**Kai never learns from its own unreviewed output.**

A reply Kai sent enters the training corpus only when a person acted on it:

* a reviewer marked it **Good output**, or
* a reviewer wrote a **Corrected reply**, and then the reviewer's words replace
  what Kai actually sent.

An AI reply nobody rated is dropped. Internal notes are dropped. A conversation
marked **Needs follow-up** is excluded completely, including the customer's own
messages, because the outcome of that conversation is not yet known.

What customers wrote, and what your team wrote, is always usable. Only Kai's own
words need a human decision first.

<Note>
  This is why turning on **All live conversations** is safe. Kai reads the
  customer side and the human side of every thread, and still ignores its own
  unvetted replies.
</Note>

## How deep to go

Deeper runs cost more and take longer.

| Depth        | What it does                                                                                                 |
| ------------ | ------------------------------------------------------------------------------------------------------------ |
| **Light**    | Reuses everything already understood, and keeps only well-attested patterns. The quick, conservative option. |
| **Standard** | Reuses prior understanding and re-derives every answer, flow and rule. The right choice most of the time.    |
| **Deep**     | Re-reads every conversation from scratch and surfaces rarer patterns. The slow, thorough option.             |

The cost sits in one place: reading a conversation for the first time. Light and
Standard reuse what Kai already understood about a conversation, so a retrain
over a mostly unchanged history is cheap. Deep ignores that and reads every
conversation again, so it costs one reading call for every conversation in the
corpus.

Deep also lowers the threshold at which a pattern is kept, so rare questions
reach the Answer Library. That is what you want after a product change, and it
is not what you want as a monthly habit.

<Tip>
  Start with **Standard**. Choose **Deep** only when you changed something
  fundamental, or when Kai keeps missing a question you can see in the history.
</Tip>

## Goals

Goals are optional. They steer emphasis and phrasing.

You can select a template, for example **Shorter replies**, **Careful with
numbers**, **Escalate sooner**, or write your own.

**A goal is steering, never a fact.** A goal cannot add information your team
never wrote. If you write "our price is 30.000 TL" as a goal, Kai does not learn
a price from it. The Answer Library stays grounded in what your staff actually
said, and a price belongs in
[Current information](/product/current-information).

Good goals describe behaviour: "End replies with a question or a clear next
step." "Address price objections with answers the team has already given."

## Run it

<Steps>
  <Step title="Choose the sources">
    Leave **Past imports** on. A retrain that drops the original history builds
    a Brain from a few dozen live threads and calls it an upgrade.
  </Step>

  <Step title="Choose the depth and the goals">
    Standard, unless you have a reason.
  </Step>

  <Step title="Start the retrain">
    Kai states what happens before it starts: a new draft is compiled, it takes
    a few minutes, and the version you run today keeps serving customers.
  </Step>

  <Step title="Watch it, or close the tab">
    The progress view shows the percentage, the stage, and the counts. Nothing
    breaks if you leave.

    <Frame caption="A retrain in progress.">
      <img src="https://mintcdn.com/kai-support/RaOwCZDRMIUnRjWu/images/en/retrain-running.png?fit=max&auto=format&n=RaOwCZDRMIUnRjWu&q=85&s=7242fa73ec358efcf86018f96cdbfb85" alt="A retrain in progress with stages and counts" width="2880" height="1400" data-path="images/en/retrain-running.png" />
    </Frame>
  </Step>

  <Step title="Review the draft">
    When the run finishes, select **Review the draft**. The new draft opens in
    the [review queue](/product/review-and-publish).
  </Step>
</Steps>

## What happens to your review decisions

A retrain rebuilds every entry from scratch, so the identifiers change. Kai
carries your decisions across by **content**, not by identifier. The rules are
deliberately careful.

| Old state     | What carries over                                                                                                                                               |
| ------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Edited**    | Your words win, whole. The recompiled text is replaced by yours, and the state stays **Edited**.                                                                |
| **Approved**  | Carried only when the recompiled text is the same text you approved. If Kai worded it differently, the entry returns to **Review**.                             |
| **Rejected**  | Carried whenever the same question appears again, whatever the new wording says. A rejection is about the topic, and re-asking a settled question helps nobody. |
| Anything else | Returns to **Review**.                                                                                                                                          |

<Warning>
  An approval must never sit on text nobody approved. This is why an approved
  entry whose wording changed comes back to the queue. Expect some re-review
  after every retrain, and expect more of it after a **Deep** run.
</Warning>

After the run, Kai states that approvals and edits carried over wherever the
content is unchanged.

## Nothing changes until you publish

The retrain creates a draft. Your published version keeps answering customers
the whole time, during the run and after it.

To take the new draft live, work the queue and select **Publish**. Read
[Review and publish](/product/review-and-publish).

## Next

<CardGroup cols={2}>
  <Card title="Review and publish" icon="list-check" href="/product/review-and-publish">
    Decide on the new draft, then take it live.
  </Card>

  <Card title="The knowledge base" icon="book-open" href="/product/knowledge-base">
    What each category holds, and what a review state means.
  </Card>
</CardGroup>
