Power using ModuleX

You already know how to run a workflow, chat with the Assistant, and connect a tool. This section is about the next step: the patterns and habits that turn ModuleX from a thing you use into a thing you build with. None of it is required — it is the shortcut to doing more with less effort.

New to ModuleX? Start with how ModuleX works and run your first workflow first. This section assumes you have built or run something at least once.

Who this is for

Builders going deeper

You have shipped a workflow or two and want to combine features — the Assistant, the AI Composer, knowledge, and integrations — into something repeatable.

Teams scaling up

You run real work through ModuleX and want it to stay fast, predictable, and affordable as usage grows.

Tinkerers and explorers

You like to know what every feature does and how the pieces fit, so you can reach for the right one without guessing.

You do not need to be a developer to use this section. Where code helps, we show it — but every pattern works from the app too.

How to use this section

Power using is three short reads, each answering a different question. Take them in any order.

Feature map

“What can ModuleX do, and where do I find it?” Every feature, what it is for, and the one page that explains it in depth. Use it as your index.

Recipes

“How do I combine features to solve a real problem?” Reusable patterns that mix the Assistant, Composer, workflows, knowledge, and tools — with links to the guides that walk each one.

Optimization

“How do I make it faster, cheaper, and more reliable?” Tune workflows and usage for speed, reliability, and credits. This one is the most technical of the three.

Pro tips and patterns

A handful of habits pay off across almost everything you build in ModuleX.

Pick the right surface for the job

ModuleX gives you three ways to get work done, and choosing well saves the most time of anything here.

Prove it with the Assistant

Use the Assistant to do a task once, right now. It calls your connected tools step by step and answers in the chat — nothing to build first. Great for “is this even possible?”

Build it with Composer

When you will repeat the task, describe it to the AI Composer and it lays out an editable workflow graph you can save, schedule, and run again.

Refine it on the canvas

Open the workflow builder to fine-tune by hand: branching, loops, retries, and precise control over each node.

The fastest path most people miss: prove a task with the Assistant first, then rebuild the keeper as a workflow. You learn which tools and steps you actually need before you commit to building anything.

Let data flow between steps

Workflows get powerful when one step uses the output of an earlier step. ModuleX does this with references written as {{node_id.field}} — for example, pull a value produced by an LLM node into the prompt of the next node. You rarely type these by hand; the builder and the AI Composer wire them for you. Understanding the idea, though, is what unlocks multi-step automations. See variables and references.

Ground answers in your own knowledge

Both the Assistant and your workflows can answer from your own documents instead of guessing. Connect a knowledge base, and retrieval pulls the relevant context automatically at run time. This is the difference between a generic answer and one that knows your company’s policies, products, or tickets.

Reach for the 175 integrations

ModuleX ships with 175 integrations exposing 600+ tools — connectors to the services you already use, each with callable actions. Browse them in the integration catalog and connect what you need in authentication and credentials. The same connected tools are available to the Assistant, the Composer, and your workflows, so you connect a service once and use it everywhere.

The integration registry is open and grows over time, so the live count can be higher than the figure above. Treat the catalog as the source of truth for what is connectable today.

Keep humans in the loop on purpose

Agentic steps can pause to ask you a question or get approval before doing something sensitive — then carry on once you answer. Use this deliberately: let the Assistant or an interrupt node check in at the risky moments, and run unattended everywhere else.

Spend credits where they earn their keep

Managed usage in ModuleX is metered in credits. The two habits that keep costs predictable: choose the right model for each step (you do not need your most capable model everywhere), and watch where the usage gate would stop a run before it spends. If you bring your own provider keys, that usage is billed directly by the provider with no ModuleX markup. The optimization page goes deep on this.

Reuse beats rebuild. A saved workflow you can schedule or trigger from an API costs you nothing to set up twice — so turn any task you do more than once into a workflow.

Drive ModuleX from your own code

Everything in the app is also available over the API and the official SDKs, so you can fold ModuleX into your own tools and scripts. Every request authenticates the same way: an Authorization: Bearer mx_live_… header plus your X-Organization-ID. Here is the shape of a run, three ways.

curl -X POST https://api.modulex.dev/workflows/wf_your_workflow_id/run \
  -H "Authorization: Bearer mx_live_your_api_key" \
  -H "X-Organization-ID: org_your_organization_id" \
  -H "Content-Type: application/json" \
  -d '{
    "input": { "topic": "quarterly board update" }
  }'

from modulex import Modulex

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

run = client.executions.run(
    workflow_id="wf_your_workflow_id",
    input={"topic": "quarterly board update"},
)
print(run.run_id)

import { Modulex } from "modulex-js";

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

const run = await client.executions.run({
  workflowId: "wf_your_workflow_id",
  input: { topic: "quarterly board update" },
});
console.log(run.runId);

For the full walkthrough — authenticate, run, and stream the result — follow run a workflow. For the complete request lifecycle and headers, see authentication.

Good to know before you go deep

Who on your team can do what

Some surfaces are restricted by role. As built today, the Assistant and the AI Composer require the owner or admin role in the organization; the older member role has been retired and is not a current role. If a teammate hits a permission error, check their role first. See roles and permissions.

Runs are metered, and the gate fails closed

Managed runs, Assistant turns, Composer edits, and managed knowledge calls all pass through a billing gate before they spend anything. If your plan allowance is exhausted and overage is off, the call is declined up front with a clear message rather than running and surprising you later. Read credits and the billing model and usage gating and limits.

Not everything is shipped yet

A few app paths are known to be incomplete or unavailable today. Before you build a pattern around a feature, it is worth a glance at known limitations so you are not designing around something that is not ready.

When a word is unfamiliar

ModuleX has a precise vocabulary — runs, turns, nodes, credits, knowledge bases, and more. The glossary is the single source of truth for what each term means.

Where to go next

Feature map

The index of everything ModuleX can do and where each feature is documented in depth.

Recipes

Reusable patterns that combine features to solve real problems, with links to the guides.

Optimization

Tune workflows and usage for speed, reliability, and cost.

Assistant examples

Worked, end-to-end examples of common Assistant tasks to copy and adapt.

Billing & credits

Data & limits

Guides

Power using

Who this is for

Builders going deeper

Teams scaling up

Tinkerers and explorers

How to use this section

Feature map

Recipes

Optimization

Pro tips and patterns

Pick the right surface for the job

Prove it with the Assistant

Build it with Composer

Refine it on the canvas

Let data flow between steps

Ground answers in your own knowledge

Reach for the 175 integrations

Keep humans in the loop on purpose

Spend credits where they earn their keep

Drive ModuleX from your own code

Good to know before you go deep

Where to go next

Feature map

Recipes

Optimization

Assistant examples

​Who this is for

Builders going deeper

Teams scaling up

Tinkerers and explorers

​How to use this section

Feature map

Recipes

Optimization

​Pro tips and patterns

​Pick the right surface for the job

Prove it with the Assistant

Build it with Composer

Refine it on the canvas

​Let data flow between steps

​Ground answers in your own knowledge

​Reach for the 175 integrations

​Keep humans in the loop on purpose

​Spend credits where they earn their keep

​Drive ModuleX from your own code

​Good to know before you go deep

​Where to go next

Feature map

Recipes

Optimization

Assistant examples

Who this is for

How to use this section

Pro tips and patterns

Pick the right surface for the job

Let data flow between steps

Ground answers in your own knowledge

Reach for the 175 integrations

Keep humans in the loop on purpose

Spend credits where they earn their keep

Drive ModuleX from your own code

Good to know before you go deep

Where to go next