Flowise has been sunset.
What now?

Flowise was an open-source visual builder for LLM flows and agents. Its team froze the code on 29 July 2026, the GitHub repository was archived in August, and the core team's presence on GitHub and Discord ended on 31 August 2026 (source: flowiseai.com/sunset). The Apache 2.0 code stays online to fork. This page is for teams that used Flowise for internal agents and are choosing what comes next. Pinchy is a different kind of tool: a governed multi-user platform, not a drop-in replacement.

Flowise has been sunset.
Here is what that means.

What Flowise announced

On 29 July 2026 the Flowise team froze the code: no more feature development and no new pull requests reviewed. In August 2026 the GitHub repository was archived, with issues and pull requests locked and the npm packages and Docker images marked deprecated. On 31 August 2026 the core team's presence on GitHub and Discord ended. The notice does not recommend a successor product.

What it means for a running instance

An instance you already run keeps working. What ends is the project around it: the team no longer develops it or reviews contributions. Its notice points teams to forking the repository to maintain their own updates, so updates are yours to carry or to take from a community fork. Flowise Cloud plans are still listed on flowiseai.com, but the notice gives no end date for Cloud, so ask Flowise before you build on it.

Where Pinchy fits

Pinchy is one option for teams that used Flowise for internal agents a team works through, with permissions and an audit trail. It is not a visual builder and it has no importer for Flowise flows: you set up each use case again as an agent. If you need a canvas, fork Flowise or pick another builder.

Sources: the Flowise sunset notice at flowiseai.com/sunset and the archived repository on GitHub. FlowiseAI was acquired by Workday in August 2025, according to Workday's announcement.

A builder for flows.
Or a platform for governed agents.

Flowise: Visual Flow Builder

Flowise is a drag-and-drop canvas for composing LLM chains and agents, with LangChain and LlamaIndex under the hood. You wire up nodes (models, retrievers, tools, memory) from a large library, prototype fast, and export the flow as an API or chat widget. The center of gravity is building.

Pinchy: Governed Agent Platform

Pinchy is not a canvas. It runs agents for a team with governance built in: each agent gets an explicit tool allow-list, users have roles (and groups in Pro), and every tool call is recorded in a signed, hash-chained audit trail. The center of gravity is control.

Both Open Source, Different Layers

Flowise's code stays on GitHub under Apache 2.0, except its enterprise folder, which is under a commercial license. Pinchy is AGPL-3.0. The difference is the layer they live at: Flowise is the tool you build a flow with, Pinchy is the platform you run governed agents on.

Pinchy vs Flowise: Feature Comparison

Figures as of 16 October 2026, taken from Flowise's public sunset notice, pricing, product and documentation pages. Check Flowise for current details.

Flowise Pinchy
Primary modelVisual flow / agent builder (sunset, repository archived)Governed agent platform
LicenseApache 2.0; enterprise folder under a commercial licenseAGPL-3.0
Self-hostingYes, free; no longer maintained by its teamFirst-class (Docker Compose, GHCR)
Visual flow canvasYes, drag-and-drop node graphNo, not a flow builder
Node / integration libraryLarge (100+ LLMs, embeddings, vector stores; MCP client and server nodes)Focused (Odoo, email, web search, knowledge base)
Local models / offlineYes (Ollama and others)Yes (Ollama, fully offline)
End-user channelsEmbed widget, API, chatWeb UI and Telegram
Per-agent tool permissionsDefined inside each flowDefault-deny allow-list per agent
Roles and groupsWorkspaces and RBAC in Cloud and Enterprise plansAdmin / Member roles free; groups and agent visibility in Pro
Audit of agent actionsLogin-activity log in Enterprise; not an audit of agent actionsEvery row HMAC-SHA256-signed and hash-chained, built-in verifier, CSV export, free
SSO / SAMLYes (OIDC, in enterprise)On the roadmap, not shipped yet
Free tierSelf-host free; Cloud Free plan listed (2 flows, 100 predictions a month)Free Community edition (AGPL), no user limit
Paid pricingCloud plans listed at $35 and $65 per month, no end date given for Cloud. Enterprise: custom pricing (not published)Community free (AGPL), no user limit; Pro €1,188/yr for up to 10 users, quote above

What Flowise did well.

Visual Flow Composition

If you want to see and shape the logic of a chain or agent as a node graph, Flowise is built for exactly that. The drag-and-drop canvas makes branching, retrieval and tool wiring visible and editable. Pinchy has no flow canvas.

Rapid Prototyping

Flowise lets you stand up a RAG chain or a multi-step agent in minutes, then expose it as an API or embeddable widget. For experimenting with chain designs, that speed is hard to beat. Pinchy is for running governed agents, not iterating on flow internals.

Large Node and Integration Library

Flowise ships 100+ integrations: many models, embeddings, vector stores, document loaders and tools from the LangChain and LlamaIndex ecosystem, plus MCP client and server nodes. Pinchy's integration list (Odoo, email, web search, knowledge base) is deliberately narrow and governance-focused, and it has no MCP support.

Developer Flexibility

Because flows are composed from primitives, developers can express custom logic, swap components, and extend with their own nodes. If you need that level of control over the pipeline itself, Flowise gives it to you. Pinchy intentionally constrains agents rather than exposing the pipeline.

Where Pinchy is the better choice.

Default-Deny Tool Allow-List

Pinchy agents get no tools beyond their own workspace until an admin grants them, per agent. Templates propose a starting set, and only admins create agents. Governance is the default posture, not something you remember to wire into a flow. There is also no shell or code execution.

Signed, Chained Audit Trail in the Free Edition

Every agent action is recorded in an audit row that is HMAC-SHA256-signed and hash-chained to the one before. A built-in verifier checks the chain and you can export it to CSV. It is tamper-evident, in the free Community edition. Flowise's enterprise audit module records login activity, not what agents did.

Multi-User Roles, Groups in Pro

Pinchy ships Admin and Member roles for a real team, free under AGPL. Groups (who can use which agent) and agent visibility are part of Pro. Granular custom RBAC and SSO are on the roadmap, not shipped yet, but the multi-user governance baseline is there today.

Agents That Reach Users

Pinchy agents talk to people over a web UI and Telegram, not just an embed widget or API. They are meant to be used by a team day to day, with per-user and per-org context, rather than wired into someone else's app.

ERP-Native (Odoo)

Pinchy ships a deep Odoo integration over read-write JSON-RPC: query stock, create orders, reconcile invoices, all from chat or Telegram. Acting inside a business system is a governed, first-class use case, not a generic connector node.

The Core Is Free, at Any Size

The allow-list per agent, the signed audit trail, the integrations and offline operation are in the free Community edition with no user limit. Pro adds groups, agent visibility and usage analytics (€1,188 per year for up to 10 users). The license covers neither your servers nor your model usage. The license key is validated offline, API keys are encrypted at rest with AES-256-GCM, and there is zero telemetry.

Pick the path that matches the goal.

Stay on a Flowise fork when…

Your goal is to visually compose custom LLM flows, and you have engineers to maintain and update the code yourselves or can rely on a community fork. Your existing flows are worth keeping, and you are comfortable owning the pipeline.

Move to Pinchy when…

You want a maintained platform to run governed agents for a team: a default-deny tool allow-list per agent, roles (groups in Pro), and a signed, hash-chained audit trail, with agents acting in Odoo and email and reaching users over web and Telegram. It means running a Docker Compose stack and choosing a model. You want a platform, not a canvas.

The deciding question

Are you building the flow, or governing the agent? If you need to design and tweak chain logic visually, that points to a Flowise fork or another builder. If you need to control what agents may do and prove what they did, that points to Pinchy.

Frequently asked questions.

What happened to Flowise?

Flowise was sunset. Its team announced a code freeze on 29 July 2026, the GitHub repository was archived in August 2026 (issues and pull requests locked, npm packages and Docker images deprecated), and the core team's presence on GitHub and Discord ended on 31 August 2026. The Apache 2.0 code stays on GitHub and the notice encourages teams to fork it (source: flowiseai.com/sunset). It does not name a successor product. FlowiseAI had been acquired by Workday in August 2025.

Can I keep running Flowise?

Yes. An instance you already run keeps working, and the code is Apache 2.0 outside its enterprise folder; the enterprise folder, which holds SSO, workspaces and RBAC and login activity, is under a commercial license. What ends is the team behind it: it no longer develops Flowise or reviews contributions, and points teams to forking the repository to maintain their own updates. Updates and fixes are then yours to carry or to take from a community fork. Pinchy is self-hosted first too, shipped as a single Docker Compose stack, and runs fully offline with local models.

Is Pinchy a good Flowise alternative?

For teams that used Flowise to run internal agents with permissions and an audit trail, Pinchy is one option, but not a drop-in replacement. It has no flow canvas and no importer for Flowise flows: you set up each use case again as an agent and grant it the tools it needs. In return you get an allow-list per agent, Admin and Member roles (groups in Pro), a tamper-evident audit trail that is HMAC-SHA256-signed and hash-chained, a knowledge base for your documents, and agents that reach users over a web UI and Telegram. If your goal is bespoke flow composition, a Flowise fork or another builder is the better fit.

How do Pinchy and Flowise compare on pricing?

Flowise's code is free to self-host under Apache 2.0. As of 16 October 2026 flowiseai.com still lists Cloud plans: Free at $0 (2 flows, 100 predictions a month), Starter at $35 per month, and Pro at $65 per month with 5 users and $15 per extra user. The sunset notice gives no end date for Cloud, so ask Flowise before building on it. Enterprise is custom-priced and not published. Pinchy's Community edition is free under AGPL-3.0 with no user limit; Pro is EUR 1,188 per year (EUR 99 per month billed annually) for up to 10 users, with a quote above that. Neither Pinchy license covers your servers or your model usage.

When should I stay on Flowise instead of moving to Pinchy?

Stay on a Flowise fork when your goal is to visually compose custom LLM flows, you have engineers to maintain and update the code, and your existing flows are worth keeping. Choose Pinchy when you want a maintained platform to run governed agents for a team: a default-deny tool allow-list per agent, roles (groups in Pro), and a signed audit trail, with agents acting in business systems like Odoo and email and reaching users over web and Telegram. Pinchy means running a Docker Compose stack and choosing a model, either a hosted provider with your own key or a local one via Ollama.

Want governed agents on your own infrastructure?

Self-host Pinchy yourself in minutes, or book a call to talk it through. Your choice.

Or email us: info@heypinchy.com