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

# Ask AI Integrations

> Let the AI in an Ask AI node call actions on your connected apps — a mini agent inside your workflow

The [Ask AI](/nodes/actions/ask-ai) node can do more than read and write text. Bind one or more connected apps — Gmail, Jira, Slack, and 2,700+ more — to the node, and the AI can *use* those apps while the step runs: look up an email thread, create a Jira ticket, post a Slack update, then write its answer.

Think of it as a mini agent inside your workflow. You decide which apps and which actions it may touch; the model decides when to call them and with what inputs.

<Frame caption="The Integrations section in the Ask AI config panel, right after Built-in Skills. The summary row shows what's bound; Configure opens the panel.">
  <img src="https://mintcdn.com/glorium/WGa08X6oIR3tE49_/images/nodes/node-ask-ai-integrations-section.png?fit=max&auto=format&n=WGa08X6oIR3tE49_&q=85&s=410cf021ec54e433bb5d7efbabd4773b" alt="Ask AI node config panel with the Integrations section expanded" width="1440" height="538" data-path="images/nodes/node-ask-ai-integrations-section.png" />
</Frame>

## How it works

Every action you enable becomes a **tool** the model may decide to call — the same way [conversation flow actors use capabilities](/conversation-flows/build/capabilities). During a single Ask AI step the model can call several tools, in any order, as many times as the task needs, before producing its final response.

```mermaid theme={null}
flowchart LR
    A[Prompt] --> B{Model reasons}
    B -->|calls tool| C[Find Email]
    C --> B
    B -->|calls tool| D[Send Email]
    D --> B
    B --> E[Final response]
```

Each action call runs on the **connection you bound** — the model acts as that account.

## Ask AI Integrations vs App Action

Both can send an email. The difference is who decides.

|               | [App Action](/nodes/actions/app-action) | Ask AI with integrations                                          |
| ------------- | --------------------------------------- | ----------------------------------------------------------------- |
| **What runs** | One action you picked, once             | Any enabled action, model-decided                                 |
| **Inputs**    | You map every parameter                 | The model fills them from context                                 |
| **Behaviour** | Deterministic, same every run           | Judgment-based, adapts to the data                                |
| **Best for**  | "Always send this email"                | "Read the thread, decide, then reply and file a ticket if needed" |

<Tip>
  If you know exactly which action to run and what to pass it, use App Action — it's predictable and easier to debug. Reach for Ask AI integrations when the step needs judgment: choosing between actions, chaining several, or extracting the inputs from messy text.
</Tip>

## Set up integrations

<Steps>
  <Step title="Open the Integrations section">
    In the Ask AI node's config panel, expand **Integrations** (right after **Built-in Skills**). The badge shows how many apps are already connected. Click **Configure** on the summary row to open the integrations panel.
  </Step>

  <Step title="Add an app">
    Click **Add Integration** and browse or search the catalog. Pick the app the step needs. Added apps appear as cards showing the app, its provider, how many actions are enabled, and the connection's health.

    <Frame caption="The integrations panel. Each card shows the enabled action count, connection health, and whether the model has guidance on when to use the app.">
      <img src="https://mintcdn.com/glorium/WGa08X6oIR3tE49_/images/nodes/node-ask-ai-integrations-panel.png?fit=max&auto=format&n=WGa08X6oIR3tE49_&q=85&s=de7115b8bff4618dbf4ba93cb134dabf" alt="Integrations panel with Gmail and Jira bound to the node" width="1312" height="810" data-path="images/nodes/node-ask-ai-integrations-panel.png" />
    </Frame>
  </Step>

  <Step title="Choose a connection">
    Pick one of your existing connections or click **Connect** to authorize a new account. Connections are shared workspace-wide — see [Integrations](/features/integrations) for how to manage them.
  </Step>

  <Step title="Pick which actions to enable">
    Tick only the actions this step actually needs. Use **All** / **None** to bulk-toggle. You need at least one enabled action to save.
  </Step>

  <Step title="Add &#x22;When to use?&#x22; notes">
    For each enabled action, click **When to use?** and write a short note telling the model when it should run that action. The model reads these notes every time it decides what to do next — they are the single biggest lever for reliable behaviour.

    <Frame caption="Configuring Gmail: pick the connection, tick the actions, and add a &#x22;When to use?&#x22; note to guide the model.">
      <img src="https://mintcdn.com/glorium/WGa08X6oIR3tE49_/images/nodes/node-ask-ai-integrations-configure.png?fit=max&auto=format&n=WGa08X6oIR3tE49_&q=85&s=8033649b1beb59194107ea1bd1bdb271" alt="Gmail action selection with a When to use note expanded" width="1312" height="1388" data-path="images/nodes/node-ask-ai-integrations-configure.png" />
    </Frame>
  </Step>

  <Step title="Save">
    Click **Save** and then save the node. Enabled actions are now available to the model on every run of this step.
  </Step>
</Steps>

<Warning>
  **Enable only what the step needs.** The model decides on its own when to call an enabled action, and every call runs for real on the connected account. If you enable "all of Gmail", a prompt that mentions deleting can end with deleted emails. Narrow scope is the safety mechanism.
</Warning>

## Connection health

Each integration card shows the state of its connection so a broken binding never fails silently:

| Badge                   | Meaning                                                              | Fix                                            |
| ----------------------- | -------------------------------------------------------------------- | ---------------------------------------------- |
| **Connected**           | The bound connection exists and is active                            | Nothing to do                                  |
| **No connection**       | An app was added without picking a connection                        | Open the app and choose or create a connection |
| **Connection removed**  | The connection was deleted in [Integrations](/features/integrations) | Open the app and bind a different connection   |
| **Connection disabled** | The connection exists but is turned off                              | Re-enable it on the Integrations page          |

## Guiding the model

An enabled action is an ability, not a command. The card badges tell you whether the model has guidance:

* **Usage notes** — at least one enabled action has a "When to use?" note. Recommended.
* **On user request only** — no notes yet; the model will only reach for the app when the prompt explicitly asks for it. Mention the app in your prompt or add notes.

You can combine both: describe the overall task in the node's prompt, and put per-action rules ("never email anyone except the customer on the ticket") in the notes.

## Cost

The Ask AI node itself is free to run. The final cost depends on how many times the model invokes each enabled built-in skill or integration action — each call is billed individually. A step that decides not to call any tools costs nothing extra.

## Related

<CardGroup cols={2}>
  <Card title="Ask AI" icon="brain" href="/nodes/actions/ask-ai">
    The node this feature lives on — prompts, models, memory.
  </Card>

  <Card title="App Action" icon="plug" href="/nodes/actions/app-action">
    Run a single, fixed app action deterministically.
  </Card>

  <Card title="Integrations" icon="link" href="/features/integrations">
    Connect accounts and manage connections workspace-wide.
  </Card>

  <Card title="Actor capabilities" icon="wand-magic-sparkles" href="/conversation-flows/build/capabilities">
    The same concept for conversation flow actors.
  </Card>
</CardGroup>
