Assistant examples: four tasks worked end to end

These are four common tasks people give the Assistant, each shown end to end: the plain-language prompt you type, the steps the Assistant works through, the point where it pauses for your approval, and what you get back. Copy a prompt, adapt it to your own services, and go. Every example uses tools you have already connected to ModuleX. If a task needs a service you have not connected yet, the Assistant asks you to add it right inside the chat — see authentication and credentials. For the bigger picture of what the Assistant is, start with the Assistant overview. For reusable patterns that combine the Assistant with workflows and knowledge, see recipes.

How to read these examples

Each example follows the same shape, so once you have read one you can skim the rest.

The prompt

The exact plain-language message you send to start the turn. One message per turn — there is no form to fill in.

What happens

The steps the Assistant works through: it reads, calls tools one at a time, and may pause to ask you something. You watch it all stream live.

The result

What you get back at the end of the turn — an answer, a summary, or a confirmed action.

The Assistant calls one tool at a time and pauses before anything sensitive — sending a message, creating a record, deleting data. Nothing risky runs until you approve it on the human-in-the-loop card. The tools named below (GitHub, Slack, Gmail, Linear, and so on) are examples; the Assistant uses whatever you have connected from the integration catalog.

Example 1 — Research and summarize

Pull together information that lives across your connected services, or in your own documents, and get a tidy summary back. This is a read-only task, so the Assistant does not need to pause for approval — it gathers and reports.

The prompt

Type a request that names what to find and how you want it summarized.

Prompt

Find the five newest open issues in the acme/api repository and summarize them as a short bulleted list, grouped by label.

What happens

The Assistant works the task one tool at a time, streaming its progress:

It checks which services are connected and confirms GitHub is available.
It calls a read action to fetch the newest open issues from acme/api.
It reads the results, groups them by label, and writes the summary.

Because nothing is created or sent, the Assistant runs straight through without an approval pause.

The result

A short, grouped summary in the chat — for example, a bug group and a feature group, each with a one-line description per issue and a link. You can ask a follow-up in the same chat, such as “Now draft a reply to the top bug,” which becomes Example 3.

Grounding the answer in your own documents

You can point the same kind of task at your knowledge bases instead of, or alongside, a live service. Ask something like “Summarize what our onboarding guide says about SSO,” and the Assistant searches your connected knowledge and answers from your own documents. Searching managed knowledge carries a small credit cost — see credits and metering.

Example 2 — Inbox and triage

Sort through incoming items — emails, support tickets, or issues — and turn a noisy inbox into a ranked, labeled list you can act on. Reading and ranking are safe, so the Assistant does that on its own; if you ask it to apply labels or change anything, it pauses for approval first.

The prompt

Describe what to triage and the order you want.

Prompt

Review my unread support tickets from the last 24 hours, rank them by urgency, and tell me which three I should answer first and why.

What happens

The Assistant confirms your support tool is connected.
It calls a read action to list the unread tickets from the last day.
It reads each ticket, judges urgency from the content, and ranks them.
It reports the top three with a one-line reason each.

If your prompt also asked it to act — “and add the urgent label to the top three” — the Assistant would stop on an approval card before changing any ticket, because applying a label is a write action.

The result

A ranked shortlist with reasons, ready for you to act on. If you approved label changes, you also get a confirmation of exactly what was changed.

Why triage pauses only when it changes something

Listing and reading items never changes your data, so the Assistant does those steps without interrupting you. The moment a step would write — apply a label, archive a thread, reassign a ticket — it pauses and shows you precisely what it is about to do. You can approve, choose a different option, or decline. See human-in-the-loop for the question and approval kinds.

Example 3 — Draft and send

Have the Assistant gather context, write something for you, and send it — with an approval step in the middle so you always see the final draft before it goes out. This is the canonical “pause before a sensitive action” pattern.

The prompt

Say what to write, to whom, and where to send it.

Prompt

Draft a friendly reply to the newest message in the #support Slack channel letting them know we are looking into it, then send it.

What happens

The Assistant confirms Slack is connected.
It calls a read action to fetch the newest message in #support for context.
It writes a draft reply and shows it to you.
It pauses on an approval card — the send does not happen yet.

You approve (or edit)

Review the draft on the approval card. Approve to send it as written, decline to stop, or reply in the chat with a change such as “make it shorter” and the Assistant revises and asks again. Only the person who started the turn can answer its question.

The result

Once you approve, the Assistant calls the send action and confirms the message went out — with a link to it where the service provides one.

The Assistant always pauses before a sensitive action. A draft is never sent, a record is never created, and nothing is deleted until you approve it on the card. If you decline, the turn ends without acting. Read more about how the pause works in human-in-the-loop.

Example 4 — Multi-tool task

Chain several services together in one request. The Assistant plans the steps, calls each tool in turn, carries results from one step into the next, and pauses before the one step that writes.

The prompt

Describe the whole task in one message — the Assistant figures out the order.

Prompt

Find my three newest GitHub issues labeled "bug", create a Linear ticket for each one, and post a summary of what you created to the #engineering Slack channel.

What happens

The Assistant breaks the request into ordered steps and works them one tool at a time:

It reads the three newest bug issues from GitHub.
It pauses on an approval card before creating Linear tickets, since creating records is a write action.
After you approve, it creates one Linear ticket per issue, carrying each issue’s title and link into the new ticket.
It pauses again before posting to Slack, then — once approved — posts a summary of the tickets it created.

The result

Three new Linear tickets and one Slack summary post, plus a final message in the chat recapping everything it did and linking to each item it created.

What if a service is not connected yet?

If the task needs a service you have not connected — say Linear in the example above — the Assistant pauses and asks you to add the credential, including starting an OAuth connection, without leaving the chat. Once you connect it, the Assistant picks the task back up automatically. See using tools and authentication and credentials.

When to turn a task into a reusable workflow

The Assistant does a task once, right now. If you find yourself running the same multi-tool task often — or you want to schedule it, trigger it from an API, or add branching and retries — rebuild it as a reusable workflow with the AI Composer or the workflow builder. Many people prove a task with the Assistant first, then promote it to a workflow.

Good to know before you start

A few things shape every example above.

One message per turn

Each turn is a single text message — there is no multi-part form and no file upload. Send your whole request in one message; the Assistant plans the steps from there.

One question at a time

A chat holds only one open question at a time. While the Assistant is waiting for your approval, it will not start another turn on that chat — finish the current step first.

Owner or admin role

As built today, you need the owner or admin role in the organization to use the Assistant. The retired member role is not a current role. See permissions and limits.

Each turn uses credits

A turn is metered like any managed run, with model token usage recorded separately. If your allowance is exhausted, the turn is declined before anything runs. See credits and the billing model.

Try an example from your own code

You can drive any of these tasks programmatically. A turn starts with one authenticated request that creates or continues a chat and returns a stream_url; you open that stream to watch the Assistant work, exactly as you would in the app. Every request uses Authorization: Bearer mx_live_… plus your X-Organization-ID header — see authentication.

curl -X POST https://api.modulex.dev/assistant/chat \
  -H "Authorization: Bearer mx_live_your_api_key" \
  -H "X-Organization-ID: org_your_organization_id" \
  -H "Content-Type: application/json" \
  -d '{
    "message": "Find the five newest open issues in acme/api and summarize them, grouped by label.",
    "llm": {
      "integration_name": "openai",
      "provider_id": "openai",
      "model_id": "gpt-4o"
    }
  }'

from modulex import AsyncModulex

client = AsyncModulex(
    api_key="mx_live_your_api_key",
    organization_id="org_your_organization_id",
)

resp = await client.assistant.chat(
    "Find the five newest open issues in acme/api and summarize them, grouped by label.",
    llm={
        "integration_name": "openai",
        "provider_id": "openai",
        "model_id": "gpt-4o",
    },
)
print(resp.stream_url)  # open this to stream the turn

import { Modulex } from "modulex-js";

const client = new Modulex({
  apiKey: "mx_live_your_api_key",
  organizationId: "org_your_organization_id",
});

const resp = await client.assistant.chat({
  message:
    "Find the five newest open issues in acme/api and summarize them, grouped by label.",
  llm: {
    integration_name: "openai",
    provider_id: "openai",
    model_id: "gpt-4o",
  },
});
console.log(resp.stream_url); // open this to stream the turn

A successful response returns the chat and run identifiers plus a stream_url. Open it over Server-Sent Events to receive the Assistant’s actions and output as they happen — including any human-in-the-loop approval pause, which you answer to continue:

Response

{
  "status": "running",
  "chat_id": "f2b1c0de-1111-2222-3333-444455556666",
  "run_id": "a1b2c3d4-aaaa-bbbb-cccc-dddddddddddd",
  "thread_id": "f2b1c0de-1111-2222-3333-444455556666",
  "stream_url": "/assistant/chat/f2b1c0de-1111-2222-3333-444455556666/listen/a1b2c3d4-aaaa-bbbb-cccc-dddddddddddd"
}

For the full set of Assistant operations, the event stream, and the resume contract, see how the Assistant works, streaming responses, and human-in-the-loop.

Where to go next

Assistant overview

What the Assistant is, what it can do, and how to start a session.

Recipes

Reusable patterns that combine the Assistant with workflows and knowledge to solve real problems.

Using tools

How the Assistant discovers and calls the integration tools these examples rely on.

Human-in-the-loop

The pause-and-approve step that protects every sensitive action above.

Connect an integration

Connect a service so the Assistant can act on it, then call its tools.

Build with the AI Composer

Turn a task you run often into a reusable, schedulable workflow.

App overview

Chat

Knowledge

Collaboration

Builder

Nodes

Execution

Co-editing

Assistant Chat

Assistant examples: four tasks worked end to end

How to read these examples

The prompt

What happens

The result

Example 1 — Research and summarize

Example 2 — Inbox and triage

Example 3 — Draft and send

Example 4 — Multi-tool task

Good to know before you start

One message per turn

One question at a time

Owner or admin role

Each turn uses credits

Try an example from your own code

Where to go next

Assistant overview

Recipes

Using tools

Human-in-the-loop

Connect an integration

Build with the AI Composer

​How to read these examples

The prompt

What happens

The result

​Example 1 — Research and summarize

​Example 2 — Inbox and triage

​Example 3 — Draft and send

​Example 4 — Multi-tool task

​Good to know before you start

One message per turn

One question at a time

Owner or admin role

Each turn uses credits

​Try an example from your own code

​Where to go next

Assistant overview

Recipes

Using tools

Human-in-the-loop

Connect an integration

Build with the AI Composer

How to read these examples

Example 1 — Research and summarize

Example 2 — Inbox and triage

Example 3 — Draft and send

Example 4 — Multi-tool task

Good to know before you start

Try an example from your own code

Where to go next