AI Composer: text to workflow

The AI Composer is the text-to-workflow agent in ModuleX. You describe what you want in plain English, and it builds an editable workflow on the canvas for you — adding nodes, wiring them together, and setting up inputs as it goes. You stay in control the whole time. The Composer pauses to ask you questions when it needs a decision or a credential, streams its work live, and never makes its changes permanent until you approve them.

Build by describing

Type a request like “summarize new support emails and post them to Slack” and watch the workflow take shape on the canvas.

You approve every change

Composer edits are pending until you save them. Don’t like the result? Revert in one click and the workflow returns to where it was.

What the Composer does

The Composer is an AI agent that edits a workflow’s graph for you. Instead of dragging nodes onto the canvas yourself, you tell it the outcome you want and it assembles the steps. As it works, it can:

Add and connect nodes

It adds any of the nine node types — for example an LLM node, a tool node, or a knowledge node — and wires them in the right order.

Set up inputs

It defines the inputs your workflow accepts so the steps have the data they need to run.

Use your integrations

It looks at the integrations your organization has connected and picks the right tools for the job.

Test as it builds

It can do a test run of the workflow while building so it can catch problems early.

The Composer edits the workflow live, but those edits are held as pending changes until you decide what to do with them (see Save and revert).

See it in the builder

This page explains the concept. To use the Composer hands-on inside the canvas, see AI Composer in the builder.

Composer vs Assistant

ModuleX has two AI agents, and they are easy to mix up. They share the same underlying chat engine, but they do different jobs.

	AI Composer	Assistant
What it produces	An editable workflow on the canvas	Answers and actions, in a chat
Works on a workflow?	Yes — it builds and edits one	No — it has no workflow tools
Where you find it	The workflow builder	Chat
Calls your integration tools?	While building and test-running	Directly, to get a task done
Save / revert changes	Yes (pending changes on the canvas)	Not applicable — no canvas to change

Use the Composer when you want to build something reusable you can run again and again. Use the Assistant when you want to get a one-off task done now in a conversation.

Both agents pause the same way when they need your input, which is covered next.

When the Composer asks you a question

The Composer doesn’t guess on important decisions. When it needs a choice, a piece of text, or access to a connected service, it pauses and asks. This is called human-in-the-loop (HITL). While it is waiting, the conversation stays open and nothing changes until you respond. You can also skip most questions if you’d rather the Composer decide.

A choice between options

The Composer offers a short list of options and you pick one (or several). For example, choosing which model provider to use for a step.

A yes or no

A simple confirmation before it does something — for instance, before running a sensitive action while test-building.

Some free text

A short written answer, such as the exact wording for a message or the name of a channel.

A credential for an integration

If a step needs a service you haven’t connected yet, the Composer asks you to connect it. For services that use OAuth, this opens the provider’s sign-in flow, and the Composer continues on its own as soon as you finish — you don’t need to re-send your request.

Only one question can be open per conversation at a time, and only the person who was asked can answer it. If you start a new request while a question is still open, the Composer asks you to answer the open one first.

For the developer-facing detail on how pause-and-resume works over the API, see Human-in-the-loop resume. The same idea also exists as a workflow step you can place yourself — the Interrupt node.

Save and revert

Composer changes are never silently committed. After the Composer finishes a turn, its edits sit on the canvas as pending changes, and an action bar gives you two choices.

Describe what you want

Send your request. The Composer streams its work and applies edits to the canvas as it goes.

Review the pending changes

When the turn finishes, the workflow shows the Composer’s edits with a pending-changes action bar. Nothing is locked in yet.

Save or revert

Save keeps the changes and updates the workflow’s saved snapshot. Revert restores the workflow to its last saved snapshot and discards the edits.

Save

Confirms the Composer’s edits and refreshes the saved snapshot of your workflow. This becomes the new baseline for the next revert.

Revert

Restores the workflow to the snapshot from before this turn and clears the pending changes — a clean undo of the Composer’s latest edits.

You can keep iterating without committing: send another request, see the new result, and only save once you’re happy. Each save sets the baseline that a later revert will return to.

Building a turn programmatically

Most people use the Composer through the builder. If you’re working from code, a Composer turn starts with a single call that creates or continues a chat and kicks off the agent. The response gives you a stream URL you can follow to watch the build live. Every request needs your API key and your organization context — see Authentication.

curl -X POST https://api.modulex.dev/composer/chat \
  -H "Authorization: Bearer mx_live_8Kqp2wZ7nR4tVx1aB6cD3eF" \
  -H "X-Organization-ID: 7f3a2b10-9c4d-4e8a-b1f6-2d5c8e0a9b41" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "a1b2c3d4-5e6f-4708-9a1b-2c3d4e5f6a7b",
    "message": "Add an LLM node that summarizes the input text",
    "llm": {
      "integration_name": "anthropic",
      "provider_id": "anthropic",
      "model_id": "claude-haiku-3.5"
    }
  }'

from modulex import Modulex

client = Modulex(
    api_key="mx_live_8Kqp2wZ7nR4tVx1aB6cD3eF",
    organization_id="7f3a2b10-9c4d-4e8a-b1f6-2d5c8e0a9b41",
)

turn = await client.composer.chat(
    "Add an LLM node that summarizes the input text",
    workflow_id="a1b2c3d4-5e6f-4708-9a1b-2c3d4e5f6a7b",
    llm={
        "integration_name": "anthropic",
        "provider_id": "anthropic",
        "model_id": "claude-haiku-3.5",
    },
)
print(turn.stream_url)

import { Modulex } from "modulex-js";

const client = new Modulex({
  apiKey: "mx_live_8Kqp2wZ7nR4tVx1aB6cD3eF",
  organizationId: "7f3a2b10-9c4d-4e8a-b1f6-2d5c8e0a9b41",
});

const turn = await client.composer.chat({
  workflowId: "a1b2c3d4-5e6f-4708-9a1b-2c3d4e5f6a7b",
  message: "Add an LLM node that summarizes the input text",
  llm: {
    integration_name: "anthropic",
    provider_id: "anthropic",
    model_id: "claude-haiku-3.5",
  },
});
console.log(turn.stream_url);

A successful response confirms the turn is running and tells you where to stream it:

Response

{
  "status": "running",
  "composer_chat_id": "f2c1a890-3b47-4d62-8e15-6a9c0d2e4f73",
  "workflow_id": "a1b2c3d4-5e6f-4708-9a1b-2c3d4e5f6a7b",
  "run_id": "8e7d6c5b-4a39-4218-9f0e-1d2c3b4a5e6f",
  "thread_id": "f2c1a890-3b47-4d62-8e15-6a9c0d2e4f73",
  "stream_url": "/composer/chat/f2c1a890-3b47-4d62-8e15-6a9c0d2e4f73/listen/8e7d6c5b-4a39-4218-9f0e-1d2c3b4a5e6f"
}

From there you follow the stream_url to watch the agent’s steps, answer any human-in-the-loop questions it raises, and then confirm with save or revert.

The Composer runs on managed AI usage, so it consumes credits — one credit per turn, plus the cost of the AI it uses. If your organization is out of credits or over a limit, the call is refused before any work begins with a billing response (a 402, 403, or 429). See Usage gating & limits and Errors & status codes for the exact shapes.

The Composer is available to organization owners and admins. The previous member role has been retired, so any account that can open the Composer can also use it. See Organizations, roles & membership.

Known limitations

A few related behaviors are not fully wired today. We list them here so you don’t build a flow that depends on them.

Bulk deleting nodes on a shared canvas

Deleting nodes one at a time is fully supported and syncs to everyone editing the canvas with you. When collaborating, delete nodes individually — confirming each — rather than in a single bulk action. See Realtime co-editing & external sync.

Reconnecting an expired OAuth integration

When the Composer asks for a credential and you connect a service via OAuth, the connect-and-continue flow works. To refresh an expired OAuth credential, reconnect the integration — that re-runs the sign-in flow and issues fresh tokens. See Managing credentials.

Next steps

Use the Composer in the builder

Open the Composer panel on the canvas and build hands-on.

Build a workflow with Composer

A step-by-step walkthrough from prompt to running workflow.

Meet the Assistant

The chat agent that gets one-off tasks done without a workflow.

How human-in-the-loop works

The developer-facing detail on pausing and resuming a turn.

Welcome

Quickstart

Foundations

Concepts

AI Composer: text to workflow

Build by describing

You approve every change

What the Composer does

Add and connect nodes

Set up inputs

Use your integrations

Test as it builds

See it in the builder

Composer vs Assistant

When the Composer asks you a question

Save and revert

Save

Revert

Building a turn programmatically

Known limitations

Next steps

Use the Composer in the builder

Build a workflow with Composer

Meet the Assistant

How human-in-the-loop works

Build by describing

You approve every change

​What the Composer does

Add and connect nodes

Set up inputs

Use your integrations

Test as it builds

See it in the builder

​Composer vs Assistant

​When the Composer asks you a question

​Save and revert

Save

Revert

​Building a turn programmatically

​Known limitations

​Next steps

Use the Composer in the builder

Build a workflow with Composer

Meet the Assistant

How human-in-the-loop works

What the Composer does

Composer vs Assistant

When the Composer asks you a question

Save and revert

Building a turn programmatically

Known limitations

Next steps