Visual builder · workflows-as-API · self-hostable

Build AI workflows. Call them as APIs.

Drag a workflow on the canvas, type the input/output schema, and call it from your backend like any HTTP API — persistent state, observability, and multi-provider routing built in. Self-host the whole stack with one docker compose up.

Start building free Self-host it

No credit card·Free tier·Source-available

OpenAIGeminiDeepSeekGigaChat

↳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.

POST /api/workflows/wf_a3f2

Trigger

START

LLM · gemini

AGENT

gpt-4.1-nano → gemini

Return

END

state

user_idu_42

messages2

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

Call your workflowcURL

curl -X POST https://app.assmblx.com/api/workflows/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 / See it in action

The real editor. Build, run, debug.

Not a mockup — the actual product. Drop nodes on the canvas, run the flow, and watch each step trace: provider, latency, tokens, cost.

Assemblix canvas: Start → First agent (gpt-4.1-nano) → Set Variable → second agent (gemini) → End

↳The real canvas — Start → agent (gpt-4.1-nano) → Set Variable → agent (gemini) → End. Drag, wire, publish.

A workflow published as an authenticated HTTP endpoint — 01Workflows-as-API · typed endpoint

Per-node provider selection with fallback chain — 02Multi-provider · per-node + fallback

Execution history with tokens, latency and cost per run — 03Observability · runs, latency, cost

03 / 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/workflows/wf_… with bearer auth, a typed request schema, and a stable contract. No separate deploy. No infrastructure code.

POST /api/workflows/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 DeepSeek (cheap, fast). Reasoning on Gemini. Keep sensitive flows on GigaChat. If OpenAI hits a rate limit, the call falls back to the next provider in the chain — same node, no code change.

provider: openai → gemini
fallback: on_rate_limit

Observability

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

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

04 / Open source spirit

Self-host the whole stack in one command.

Own your stack. Postgres-only core, no phone-home, bring your own keys. Source-available and free to self-host.

Postgres-only core — Redis + worker queue optional
No phone-home · bring your own provider keys
SSRF-guarded HTTP node, secrets encryption, Prometheus metrics in the box
Custom nodes as pip packages, auto-discovered

Star on GitHub Read the docs

Source-available — MIT + Commons Clause. The commercial billing layer is a separate Enterprise license, off by default.

~/assemblix — docker compose

$ git clone https://github.com/nmamizerov/assemblix
$ cd assemblix && docker compose up
→ pulling images…
✓ postgres        ready on :5432
✓ assemblix-api    ready on :8000
✓ assemblix-web    ready on :3000
Assemblix is live → http://localhost:3000

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, Google Gemini, DeepSeek, and GigaChat with automatic fallback chains is built in, not bolted on. And it's source-available — self-host the whole stack with one docker compose up.

How do I call an Assemblix workflow as an API?

Send a POST request to /api/workflows/{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, Google Gemini, DeepSeek, and GigaChat. Provider is selected per node, with automatic fallback chains (e.g. openai → gemini 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?

Yes. Assemblix is source-available (MIT + Commons Clause). Clone the repo at github.com/nmamizerov/assemblix and run docker compose up — a Postgres-only core, no phone-home, bring your own provider keys. The commercial billing layer is a separate Enterprise license and off by default. Prefer managed? Cloud is available at app.assmblx.com.

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.

05 / Pricing