Visual builder · workflows-as-API

Build AI workflows. Call them as APIs.

Drag a workflow on the canvas. Type the input/output schema. Call it from your backend like any other HTTP API — with persistent state, observability, and multi-provider routing built in.

Start building free See it run

No credit card·Free tier·Multi-provider

OpenAIAnthropicGoogleMistralOllama

↳A real workflow running — nodes execute, state mutates, the endpoint responds with typed JSON.

01 / Quickstart

From node to endpoint in 60 seconds.

Drag a workflow. Define the typed schema. Call it from your backend. No glue code.

↳Three nodes: input → LLM → output. Typed schema in the side panel.

Call your workflowcURL

curl -X POST https://app.assmblx.com/api/run/wf_a3f2 \
  -H "Authorization: Bearer $ASSEMBLIX_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": { "message": "Tell me about pricing" },
    "state": { "user_id": "u_42" }
  }'

Response200 OK

{
  "executionId": "exec_d7c9b585",
  "status": "completed",
  "output": {
    "parsed_message": {
      "intent": "pricing",
      "confidence": 0.94,
      "next_action": "show_pricing"
    },
    "tool_executions": []
  },
  "state": { "user_id": "u_42", "messages_count": 2 },
  "metadata": { "durationMs": 850, "totalSteps": 3 }
}

Postgres-backed state · Webhooks, REST, schedules · Observability built-in.

02 / What's under the canvas

Four things that make it production-grade.

No philosophy. Four concrete pieces that turn a canvas into a callable backend.

01 · Featured

Workflows-as-API

Wire two LLM agents and a tool node, hit publish — you get POST /api/run/wf_… with bearer auth, a typed request schema, and a stable contract. No separate deploy. No infrastructure code.

POST /api/run/wf_a3f2
Authorization: Bearer …
Content-Type: application/json

Persistent state

A user pings you three weeks later and says "continue." The workflow already has their cart, last-seen page, and the retry counter from node 4. State lives in Postgres, accessed from any node via state.set/get.

state.set("customer", lookup);
memory.window: "30d";

Multi-provider

Run intent classification on Mistral (cheap, fast). Reasoning on Anthropic. Summarization on local Ollama. If OpenAI hits a rate limit, the call falls back to the next provider in the chain — same node, no code change.

provider: openai → anthropic
fallback: on_rate_limit

Observability

Workflow stalls in production? Open run #exec_d7c9b585 — node 4 waited 12s on OpenAI, retried twice, succeeded on the Anthropic fallback. Nodes, tokens, latency, errors logged per run, queryable across the endpoint.

GET /api/executions/exec_d7c9b585
status · durationMs · tool_executions

FAQ

Common questions about Assemblix.

Short, direct answers to the things people ask most. Anything still unclear — ping us on Telegram, we reply fast.

What is Assemblix?

Assemblix is a visual builder for AI workflows with a production runtime. You assemble a workflow from nodes (LLM agents, tools, state updates), define a typed input/output schema, and Assemblix exposes the workflow as an authenticated HTTP endpoint. Your backend calls it like any other API.

How is Assemblix different from Flowise, Langflow, and n8n?

The core difference: every workflow automatically becomes a typed HTTP endpoint with auth, versioning, and observability — no separate deploy step or infrastructure code. Persistent state survives restarts and weeks of inactivity. Multi-provider routing across OpenAI, Anthropic, Google, Mistral, and Ollama with automatic fallback chains is built in, not bolted on.

How do I call an Assemblix workflow as an API?

Send a POST request to /api/run/{workflow_id} with a Bearer token. The body carries input (matching your typed schema) and an optional state object. The response is a typed JSON payload with output (including parsed_message and tool_executions), executionId, status, updated state, and metadata (durationMs, totalSteps). Every run is traced and inspectable via /api/executions/{executionId}.

Which LLM providers are supported?

OpenAI, Anthropic, Google, Mistral, and Ollama (for local models). Provider is selected per node, with built-in A/B mode and automatic fallback chains (e.g. openai → anthropic on rate limit). Free tier ships one provider; Pro and Team unlock all of them with fallback.

What is persistent state and how does it work?

Persistent state is the variables, memory, and cross-workflow values that survive between calls — across restarts, deploys, and weeks of idle time. State lives in Postgres, is accessible from any node via state.set/get, and supports memory windows (e.g. memory.window: "30d"). It's what lets you build long-lived assistants that remember session context.

How much does Assemblix cost and what's in the Free tier?

Free is $0 forever: 3 workflows, 3 endpoints, 1,000 API calls per month, 1 provider, community support. Pro is $29/mo: unlimited workflows, 50,000 calls, all providers with fallback, durable runs up to 30 days, priority support. Team is $99/seat/mo: 250,000 calls, RBAC, SSO, audit log, SLA. No hidden seats, no credit card required for Free.

Can I self-host Assemblix?

Today Assemblix runs as managed cloud at app.assmblx.com. For teams with on-premise or private-cloud requirements, an enterprise self-hosted runtime is available — reach out to hello@assemblix.com or to the founder on Telegram.

How does observability and run logging work?

Every workflow run is traced automatically: which nodes executed, in what order, token usage, latency (durationMs), tool_executions performed, and cost (creditsUsed, ownKeyCostUsd). Inspect a single run via GET /api/executions/{executionId} or aggregate metrics across the whole endpoint. Available on every tier including Free.

03 / Pricing