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

# Interviewers

> What an Interviewer is, every field explained simply, and how to make one — with hiring, training, and mock-interview examples.

An **Interviewer** is the AI persona that runs a [Round](/en/concepts/rounds).
It tells the AI **who to be** and **how to grade** — the personality and the
report card, bundled together.

You make an Interviewer once, then **reuse it across many Rounds and Roles**.
(For example, one "ITOM Specialist" Interviewer can run the ITOM round in
several different [Roles](/en/concepts/roles).)

## What it controls

<CardGroup cols={3}>
  <Card title="Who it is" icon="user-round">
    The name and personality the candidate talks to.
  </Card>

  <Card title="How it talks" icon="messages-square">
    Friendly or strict, easy or hard, deep follow-ups or light ones.
  </Card>

  <Card title="How it scores" icon="sliders">
    The list of things it grades, and how much each one counts.
  </Card>
</CardGroup>

## Every field, in plain words

<ParamField path="name" type="string" required>
  A label for you, like `"Senior Backend Interviewer"`.
</ParamField>

<ParamField path="persona" type="string" required>
  The first thing the AI says about itself, like `"Hi, I'm Alex, a senior
      engineer."` This sets the mood.
</ParamField>

<ParamField path="useCase" type="hiring | admissions | training | custom_api" required>
  Pick why you're interviewing. This changes the words in the final verdict
  (for example *hire* vs *ready to practice more*).
</ParamField>

<ParamField path="evaluationDimensions" type="array" required>
  The things to grade. Each one is `{ name, description, weight }`. The
  **weights must add up to 100**. Example: System Design 50, Coding 30,
  Communication 20.
</ParamField>

<ParamField path="interaction" type="object">
  How the chat feels:

  * `tone` — friendly, professional, strict, or challenging
  * `style` — structured, conversational, or adaptive
  * `difficulty` — easy, medium, hard, or adaptive
  * `probingDepth` — low, medium, or high (how much it digs in)
</ParamField>

<ParamField path="scoring" type="object">
  How numbers are made: `scale` (0-10, 0-5, or 0-100) and `scoringMethod`
  (weighted\_average or rule\_based).
</ParamField>

<ParamField path="context" type="object">
  Extra background so the AI sounds like it belongs: `organizationContext`,
  `domainContext`, `scenarioContext`.
</ParamField>

<ParamField path="output" type="object">
  What ends up in the report: `includeTranscript`, `includeScoreBreakdown`,
  `includeRecommendation`, `includeImprovementFeedback`. All on by default.
</ParamField>

## Make one, step by step

You can do this two ways — in the dashboard (no code) or over the API. Both
create the exact same thing.

<Tabs>
  <Tab title="Dashboard (UI)">
    <Steps>
      <Step title="Open Interviewers">
        In the team dashboard, click **Interviewers** in the left sidebar.
      </Step>

      <Step title="Start a new one">
        Click **New** (or **Create Interviewer**).
      </Step>

      <Step title="Name it and give it a personality">
        Fill in the **Name** and the **Persona** (one sentence on how the AI
        introduces itself).
      </Step>

      <Step title="Pick the use case">
        Choose the **Use case** (Hiring, Admissions, Training…).
      </Step>

      <Step title="Add what to grade">
        Add 2–4 **evaluation dimensions** and set each one's weight so they add
        up to **100**. Set the **tone** and **difficulty**.
      </Step>

      <Step title="Save">
        Click **Save**. Your Interviewer now appears in the list, ready to attach
        to a Round.
      </Step>
    </Steps>
  </Tab>

  <Tab title="API">
    <Steps>
      <Step title="Give it a name and personality">
        Choose a `name` and a `persona`. Keep the persona to one sentence.
      </Step>

      <Step title="Pick the use case">
        Set `useCase` to match your goal (`hiring`, `training`, etc.).
      </Step>

      <Step title="List what to grade">
        Add 2–4 `evaluationDimensions`. Make the `weight` values add up to 100.
      </Step>

      <Step title="Send the request">
        ```bash theme={null}
        curl -X POST "https://www.intervyo.ai/api/v1/interviewers?accountSlug=<slug>" \
          -H "x-api-key: iv_live_your_key_here" \
          -H "Content-Type: application/json" \
          -d '{
            "name": "Senior Hiring Agent",
            "persona": "Alex, a senior engineer at Acme.",
            "useCase": "hiring",
            "evaluationDimensions": [
              { "name": "Technical Depth", "description": "System design & coding", "weight": 60 },
              { "name": "Communication",   "description": "Explains clearly",        "weight": 40 }
            ],
            "interaction": { "tone": "professional", "difficulty": "hard", "probingDepth": "high" }
          }'
        ```
      </Step>

      <Step title="Save the ID">
        The response gives you an `id`. You'll attach it to a stage later.
      </Step>
    </Steps>
  </Tab>
</Tabs>

## A filled-in example (no code)

Not technical? Here's exactly what to type into each dashboard field to build a
simple **"Friendly Screener"** — a warm first-round interviewer you can reuse for
almost any job.

| Field           | What to type                                                          | Why                                                      |
| --------------- | --------------------------------------------------------------------- | -------------------------------------------------------- |
| **Name**        | `Friendly Screener`                                                   | Just a label for your list — candidates never see it.    |
| **Persona**     | `Hi, I'm Riya. I'll ask a few quick questions about your background.` | The AI's opening line. Keep it to one friendly sentence. |
| **Use case**    | `Hiring`                                                              | Sets the verdict wording (hire / no-hire).               |
| **Dimension 1** | `Communication` — weight `40`                                         | How clearly they explain themselves.                     |
| **Dimension 2** | `Motivation` — weight `30`                                            | Why they want the role.                                  |
| **Dimension 3** | `Relevant experience` — weight `30`                                   | Do they have the basics?                                 |
| **Tone**        | `Friendly`                                                            | Warm, not intimidating.                                  |
| **Difficulty**  | `Easy`                                                                | It's a first-round screen, not a deep-dive.              |

The three weights add up to **100** — that's the only rule. Click **Save**, and
your Friendly Screener is ready to drop into the first Round of any Role.

<Tip>
  Reuse beats rebuilding. This one Interviewer can run the opening Round of your
  engineering Role, your sales Role, and your support Role — build it once.
</Tip>

## Examples for each use case

<Tabs>
  <Tab title="Hiring">
    Strict and skill-focused.

    ```json theme={null}
    {
      "name": "Backend Hiring Agent",
      "persona": "Alex, a staff engineer.",
      "useCase": "hiring",
      "evaluationDimensions": [
        { "name": "System Design", "description": "Scalable design", "weight": 50 },
        { "name": "Coding",        "description": "Correct & clean", "weight": 30 },
        { "name": "Communication", "description": "Clear trade-offs", "weight": 20 }
      ],
      "interaction": { "tone": "professional", "difficulty": "hard" }
    }
    ```
  </Tab>

  <Tab title="Training">
    Kind and coaching, so people keep learning.

    ```json theme={null}
    {
      "name": "Sales Coach",
      "persona": "Sam, a friendly sales coach.",
      "useCase": "training",
      "evaluationDimensions": [
        { "name": "Discovery",         "description": "Finds the pain", "weight": 50 },
        { "name": "Objection Handling","description": "Handles pushback","weight": 50 }
      ],
      "interaction": { "tone": "friendly", "difficulty": "adaptive" }
    }
    ```
  </Tab>

  <Tab title="Mock interview">
    Real-feeling but encouraging, with lots of feedback.

    ```json theme={null}
    {
      "name": "Mock Interviewer",
      "persona": "Jordan, a big-tech interviewer.",
      "useCase": "training",
      "evaluationDimensions": [
        { "name": "Problem Solving", "description": "Approach & edge cases", "weight": 60 },
        { "name": "Communication",   "description": "Thinks out loud",       "weight": 40 }
      ],
      "interaction": { "tone": "challenging", "difficulty": "hard" },
      "output": { "includeImprovementFeedback": true }
    }
    ```
  </Tab>
</Tabs>

<Tip>
  Stuck on weights? Start with one big dimension (60) and one small (40), then
  adjust after a few interviews.
</Tip>

## Next

<CardGroup cols={2}>
  <Card title="Roles" icon="file-text" href="/en/concepts/roles">
    Put your Interviewer to work inside a Role.
  </Card>

  <Card title="Create an Interviewer (API)" icon="terminal" href="/api-reference/interviewers/post-interviewers">
    The full endpoint reference.
  </Card>
</CardGroup>