Skip to main content
The Assistant is an agentic chat that gets work done with your connected tools. You describe a task in plain language, and the Assistant decides which tools to call, runs them one step at a time, and pauses to ask you when it needs a decision or an approval. There is no workflow to build first.

​
What the Assistant is

Think of the Assistant as a colleague who already knows how to use every service you have connected. You ask, it acts.

It uses your tools

The Assistant can search your connected integrations and call their actions directly — for example, list your repositories or send a message — using your organization’s stored credentials.

It works step by step

Each turn is an agentic loop: the Assistant reasons, picks a tool, runs it, reads the result, and repeats until the task is done or it needs you.

It pauses when it should

Before a destructive action, or when it needs a credential or a decision, the Assistant stops and asks. Nothing risky happens without your say-so.
The Assistant is workflow-independent: it has no tools to inspect, build, run, or edit a workflow. It exists to answer questions and complete tasks directly. If you want to design a reusable workflow graph instead, that is what the AI Composer is for.
For the full product walkthrough — capabilities, models, examples, and limits — see the Assistant overview.

​
What the Assistant can do

Answer questions

Plain language-model Q&A, with no tools required when none are needed.

Search your knowledge

Retrieve answers from your connected knowledge bases. See Knowledge & RAG.

Find and call integration tools

Discover what you have connected and run a tool action directly. See Integrations overview.

Connect new services

When a task needs a service you have not connected yet, the Assistant asks you to add the credential — including an OAuth connect flow. See Credentials & OAuth2.

​
How a turn works

Every message you send is one turn — one request that the Assistant works on until it finishes or stops to ask you something.
1

You send a message

You type a task. The Assistant starts a run and begins streaming its work back to you in real time.
2

The Assistant reasons and acts

It writes out its thinking, then calls a tool — for example, discovering your integrations or executing a specific action. You see each tool call and its result as it happens.
3

It pauses if it needs you

If the next step is risky, needs a decision, or needs a credential, the Assistant pauses and shows you a question. The turn waits for your answer. See Approval gates and questions.
4

It finishes

When the task is complete, the Assistant returns its final answer and the run ends.
The Assistant’s actions stream live over Server-Sent Events. The same stream powers the in-app chat and the SDKs — see SSE run streaming and Streaming responses.

​
Approval gates and questions

The Assistant is built to act, not to ask permission for everything. It runs ordinary, low-risk actions on its own — but it draws a hard line at anything that could change or remove your data, and at anything it cannot do without input from you.
Any action that looks destructive — deletes, drops, truncates, purges, raw database statements, and similar — always pauses for a yes/no approval before it runs. The Assistant shows you an approval card describing the action; only an explicit yes lets it proceed. Secret-looking values in the preview are redacted.
For non-destructive actions, the Assistant just runs them as part of getting your task done. This keeps everyday work fast. (This is the key difference from the Composer, which gates most write actions while it is editing a workflow.)
When the path forward is ambiguous, the Assistant can ask you a structured question: pick one option, pick several, answer yes/no, or type free text. Your answer steers the rest of the turn.
If a task needs a service you have not connected, the Assistant asks you to add the credential. For OAuth services, completing the connect flow resumes the turn automatically — you do not have to re-send your message.
A chat can hold one pending question at a time. While the Assistant is waiting on your answer, sending a new message to that chat is rejected until you respond, so a turn can never fork. For the full pause-and-resume model, see Human-in-the-loop and the HITL resume reference.

​
Assistant and Composer share one chat store

The Assistant and the AI Composer are two surfaces over the same chat machinery. Both store their conversations in the shared ComposerChat store and reuse the same agent engine, streaming, approval/resume flow, and billing. A single field tells them apart: Every operation is scoped by kind, so an Assistant chat and a Composer chat can never act on each other’s conversations. Because both live in the shared store, OAuth connect-and-resume works identically across both surfaces.

​
When to use the Assistant vs the Composer

Use the Assistant

For one-off or ad-hoc tasks you want done now: ask a question, pull data from a tool, search your knowledge, or chain a few tool calls together. Nothing is saved as a reusable graph.

Use the AI Composer

When you want a repeatable automation. The Composer turns a plain-English description into an editable workflow graph you can run again, schedule, and call from the API.
A simple rule: if you would run it more than once, build it with the Composer. If you just need it handled, ask the Assistant.

​
Who can use it, and what it costs

Access

The Assistant requires an organization owner or admin role. The legacy member role is retired and cannot use the Assistant. See Organizations, roles & membership and Roles & permissions.

Cost

Each Assistant turn is metered usage and runs through the billing gate, so it consumes credits. Resuming a paused turn after you answer a question is part of the same turn — you are not charged twice.

​
When usage is blocked

Because Assistant turns are managed usage, they pass through the live billing admission gate before any work starts. If your organization is out of credits, over a limit, or rate-limited, the turn is rejected up front with a structured denial: These denials use ModuleX’s flat denial envelope (code, layer, key, current, limit, reason), which is different from ordinary validation errors. For the exact shapes and how to handle them, see Usage gating & limits, Permissions & limits, and Errors & status codes.

​
Where to go next

Assistant overview

The full product tour of the Assistant.

Chat overview

Where you talk to the Assistant in the app.

AI Composer

Build a reusable workflow from a prompt instead.