Sim

The trait that decides it is per-run cost tracking sitting next to the thing you built. Most builders in this category let you discover spending at the end of the month; here the number attaches to the run, so an expensive branch of a workflow is visible while you are still willing to change it. That is a small feature that changes how you design.

You can also build by describing what you want, or drop into code when the canvas gets in the way. Pick it for that visibility. Pick Langflow if Python and self-hosting are the whole requirement.

Two constraints combine badly during evaluation. The free allocation is a credit balance refreshing on a weekly cycle, so serious testing is rationed by time rather than by capability. And there is no unattended execution mode, which means you cannot script a hundred runs overnight to find the flaky step. Assessment therefore happens by hand, slowly, in weekly instalments.

Budget for a paid month if you intend to evaluate seriously. What it does right: traces and logs are built into the workspace, so when a run does fail, the failure is inspectable rather than reconstructed from guesswork.

1. The same workflow can be authored visually, described in prose or written as code, which implies a single representation underneath and is the correct way to offer a canvas without trapping anyone on it. 2. Context is attached explicitly through knowledge bases, structured tables and stored files, so retrieval sources are declared rather than inferred at runtime.

2. Verification is post hoc, by reading the trace of a completed run. No benchmark accompanies the project and no accuracy claim is made, which is at least consistent: nothing is asserted that would need measuring.

The ladder is textbook and none the worse for it: a metered free tier for individuals, published mid tiers for small teams, and negotiated enterprise terms where self-hosting is the feature that closes the deal. Roughly a thousand integrations is the surface that makes the middle of that ladder plausible, and twenty-nine thousand stars supply the top of the funnel.

Moat: integration breadth, which is expensive to replicate and cheap to copy incrementally. Likely acquirer: an automation platform buying the agent-native interface rather than the connectors. Position: sound execution, crowded category, watch net retention.

The number is $1,500 a month for sixty people at the standard tier, before consumption, which is comfortable. What is less comfortable is the support position: below the negotiated tier, the escalation path is a public repository, and a workflow our operations team depends on cannot have a public issue as its incident process.

Directory integration is not described outside those negotiated terms either, so the honest comparison is enterprise pricing against the self-hosted route and an internal owner. Onboarding is a few hours on the canvas. Approved with conditions: fifteen seats, an internal owner named, escalation path agreed in writing.

Apache-2.0 on the whole thing, not on a hollow core with the interesting parts behind a login, which is the trick I check for first. One setup command and a container stack gets it running on hardware I own, and the hosted account becomes optional rather than the only door.

Local endpoints are supported, so the models stay on my network, and it speaks MCP as a client, so my servers become its tools without waiting for an integration to be prioritised. The only thing missing is the other direction, exposing its own workflows as tools. That would make it a peer rather than a consumer.