Pinchy vs Flowise
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.
What Happened
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.
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.
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.
The Core Difference
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 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.
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.
Side by Side
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 model | Visual flow / agent builder (sunset, repository archived) | Governed agent platform |
| License | Apache 2.0; enterprise folder under a commercial license | AGPL-3.0 |
| Self-hosting | Yes, free; no longer maintained by its team | First-class (Docker Compose, GHCR) |
| Visual flow canvas | Yes, drag-and-drop node graph | No, not a flow builder |
| Node / integration library | Large (100+ LLMs, embeddings, vector stores; MCP client and server nodes) | Focused (Odoo, email, web search, knowledge base) |
| Local models / offline | Yes (Ollama and others) | Yes (Ollama, fully offline) |
| End-user channels | Embed widget, API, chat | Web UI and Telegram |
| Per-agent tool permissions | Defined inside each flow | Default-deny allow-list per agent |
| Roles and groups | Workspaces and RBAC in Cloud and Enterprise plans | Admin / Member roles free; groups and agent visibility in Pro |
| Audit of agent actions | Login-activity log in Enterprise; not an audit of agent actions | Every row HMAC-SHA256-signed and hash-chained, built-in verifier, CSV export, free |
| SSO / SAML | Yes (OIDC, in enterprise) | On the roadmap, not shipped yet |
| Free tier | Self-host free; Cloud Free plan listed (2 flows, 100 predictions a month) | Free Community edition (AGPL), no user limit |
| Paid pricing | Cloud 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 |
Being Honest
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.
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.
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.
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 Wins
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.
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.
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.
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.
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 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.
Decision Guide
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.
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.
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.
FAQ
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.
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.
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.
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.
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.
Self-host Pinchy yourself in minutes, or book a call to talk it through. Your choice.
Or email us: info@heypinchy.com