Skip to main content

Flowise Guide (2026): Features, Architecture & Sunset

Project Status: End of Life. Flowise has entered end-of-life status. Active feature development ceased on July 29, 2026, the upstream GitHub repository was archived on August 13, 2026, and official core-team support concluded on August 31, 2026. Existing deployments may continue to run, but users must independently assess maintenance, security patching, and migration responsibilities. This guide documents Flowise's technical architecture, historical capabilities, and the practical decisions facing existing and prospective users.

Flowise was an open-source, visual development platform for building AI agents, LLM workflows, chatbots, and Retrieval-Augmented Generation (RAG) applications. It allowed developers and technical teams to assemble complex AI pipelines by connecting pre-built nodes on a drag-and-drop canvas, abstracting away much of the boilerplate involved in LLM API integration, prompt engineering, retrieval, vector databases, tool calling, and workflow orchestration.

For several years, Flowise was one of the most accessible ways to move from an idea to a working LLM application without writing the entire orchestration layer from scratch. It built a substantial following, accumulating tens of thousands of GitHub stars and an active community of builders. Its visual approach made it a popular choice for rapid prototyping of RAG chatbots, internal knowledge assistants, and multi-step agent workflows.

However, the project has since been wound down. The Flowise team announced its sunset in July 2026, citing a fundamental shift in how developers build AI applications: as models became more capable at reasoning, developers increasingly turned to coding agents and code-first approaches for complex tasks, and the rigid, low-code workflow paradigm began to hit its limits at higher complexity. This guide serves as a complete technical reference for understanding how Flowise worked, what it offered, and what the project's end-of-life means for anyone who built on it.

Flowise at a Glance​

ItemDetails
ProductFlowise
Product TypeVisual AI Agent and LLM Workflow Builder
Primary PurposeBuilding AI agents and LLM-powered applications through visual node composition
Core ConceptsAssistant, Chatflow, Agentflow (V1 and V2)
Key CapabilitiesRAG, tool calling, workflow orchestration, multi-agent systems
Deployment ModelSelf-hosted (Docker, npm) and historical cloud offering
Source CodePublic GitHub repository (FlowiseAI/Flowise)
LicenseApache 2.0 (open-source core), with historical commercial enterprise components
Project StatusSunset / End of Life (2026)
Best AudienceDevelopers and technical teams studying legacy systems or maintaining existing deployments

What Is Flowise?​

Flowise was designed to solve a practical problem: building a functional LLM application required stitching together a surprising number of moving parts. A typical RAG chatbot, for example, involves an LLM provider integration, a prompt template, an embedding model, a vector database, a document loader, a text splitter, a retriever, and often a memory layer—all wired together with error handling and exposed through an API or chat interface.

Flowise approached this problem through node-based visual orchestration. Instead of writing code to instantiate and connect each component, users dragged nodes onto a canvas and connected them. Each node represented a discrete capability—an LLM, a retriever, a tool, a conditional branch—and the connections between nodes defined the execution flow. The platform handled the underlying plumbing, allowing users to focus on the logic of their application.

This visual, low-code model lowered the barrier to entry for building LLM applications. It was particularly valuable for:

  • Rapid prototyping: Testing an idea for a RAG pipeline or agent workflow without committing to a full engineering build.
  • Technical teams exploring LLM orchestration: Understanding how components like retrievers, embeddings, and tools interact in practice.
  • Internal tooling: Building chatbots and knowledge assistants for internal use, where a visual, maintainable representation of the workflow was an advantage.

It is important to note that Flowise did not eliminate the need for technical understanding. Complex integrations, custom node development, production deployment, security configuration, and system integration still required engineering expertise. The platform reduced the boilerplate of orchestration; it did not replace architectural judgment.

Flowise Architecture​

Flowise’s architecture was built around a visual builder that compiled node graphs into executable workflows. The core components included:

  • Visual Builder: The canvas where nodes were placed and connected.
  • Nodes and Components: Discrete units of functionality—LLM nodes, retriever nodes, tool nodes, condition nodes, and so on.
  • LLM Providers: Integrations with model providers such as OpenAI, Anthropic, Google, Azure OpenAI, and others.
  • Embedding Models and Vector Stores: Components for generating and storing vector representations of documents.
  • Document Loaders and Text Splitters: Components for ingesting and chunking source material.
  • Retrievers and Rerankers: Components for fetching relevant context at query time.
  • Memory: Components for maintaining conversational context.
  • Tools: Integrations with external APIs, functions, and services.
  • Agents: Nodes that performed reasoning and tool selection.
  • APIs and Embedded Chat: Mechanisms for exposing flows to applications and end users.

A simplified architectural view of a deployed Flowise application looked like this:

This diagram represents a logical execution view, not the internal source-code architecture of Flowise itself. The key architectural idea was that the visual graph was the application definition—the connections on the canvas determined the execution path, and the platform handled the runtime orchestration.

Flowise Visual Builders​

Flowise offered three primary visual building paradigms, each targeting a different level of complexity and control. Understanding the distinction between them is essential to understanding what Flowise could do.

Assistant​

Assistant was the most beginner-friendly way to create an AI agent in Flowise. It allowed users to create a chat assistant capable of following instructions, using tools when necessary, and retrieving knowledge from uploaded files to answer user queries—a straightforward RAG pattern.

Assistant was designed for users who wanted a functional chatbot without needing to understand the underlying orchestration. It abstracted away much of the component wiring, making it the quickest path from an idea to a working assistant. Typical use cases included document-based Q&A bots and simple instruction-following assistants.

Chatflow​

Chatflow was designed for building single-agent systems, chatbots, and simpler LLM flows. It was more flexible than Assistant, giving users access to a wider range of components and techniques, including Graph RAG, rerankers, retrievers, custom code, and data integrations.

Chatflow represented the "classic" Flowise workflow model: a directed graph of nodes that executed in sequence, with support for branching and retrieval. It was the right choice for applications that did not require the full complexity of multi-agent orchestration but needed more control than Assistant provided.

Agentflow​

Agentflow was positioned as the superset of Chatflow and Assistant. It could be used to create chat assistants, single-agent systems, multi-agent systems, and complex workflow orchestration.

Agentflow introduced capabilities that went beyond simple sequential execution: conditional routing, iteration, human-in-the-loop interactions, and agent composition. It was the most powerful and most complex of the three builders, intended for applications where the workflow itself needed to make decisions about what to do next.

Agentflow V2​

Agentflow V2 represented a significant architectural evolution within Flowise. It shifted the platform toward explicit workflow orchestration using a granular set of specialized, standalone nodes developed natively as core Flowise components.

In the V2 architecture, each node functioned as an independent unit executing a discrete operation. The visual connections between nodes explicitly defined the workflow's path and control sequence. Data could be passed between nodes by referencing the outputs of previously executed nodes, and Flow State provided an explicit mechanism for managing and sharing data throughout the workflow.

This architecture implemented a node-dependency and execution queue system that precisely respected the defined pathways, allowing workflows to support loops, conditional branching, human-in-the-loop interactions, and other complex patterns while remaining maintainable and extensible.

Agentflow V2 was the recommended version for new agentflow projects; V1 was maintained for backward compatibility but deprecated.

Core Flowise Features​

FeatureDescriptionExample Use Case
Visual Workflow BuilderNode-based visual development for LLM applicationsPrototyping a RAG chatbot
LLM IntegrationConnect to multiple language model providersBuilding a chat application
RAGRetrieve relevant documents and inject context into promptsKnowledge assistants
Tool CallingConnect agents to external APIs and functionsAPI-enabled agents
MemoryMaintain conversational context across turnsStateful assistants
Vector StoresStore and retrieve embeddingsSemantic search
Agent OrchestrationCoordinate multiple agents and stepsMulti-step task automation
API IntegrationExpose flows as APIs for backend integrationApplication integration
Embedded ChatEmbed chat interfaces into websitesCustomer-facing assistants
ObservabilityInspect workflow execution and logsDebugging and monitoring
Human-in-the-LoopInsert human review or approval into workflowsApproval workflows

Flowise’s documented capabilities also included support for 100+ sources, tools, and vector databases; execution logs and visual debugging; self-hosted and air-gapped deployment; data transforms and RAG indexing pipelines; MCP client/server nodes; input moderation and output post-processing; JS/Python SDKs and a CLI; customizable embedded chat widgets; template marketplaces; RBAC, SSO, encrypted credentials, secret managers, and rate limiting; and vertical/horizontal scaling.

It is important to distinguish between capabilities that were historically documented and those that remained actively maintained at the time of sunset. The project's end-of-life means that no further official development or security patching occurred after the code freeze.

Building RAG Applications with Flowise​

Retrieval-Augmented Generation was one of Flowise’s most prominent use cases. The platform provided visual components for every stage of a RAG pipeline.

The RAG Workflow in Flowise​

A typical RAG pipeline in Flowise followed this pattern:

Document Sources
↓
Document Loaders
↓
Text Splitters
↓
Embedding Models
↓
Vector Store
↓
Retriever (and optionally Reranker)
↓
LLM (with retrieved context injected)
↓
Response

Flowise provided nodes for each of these stages: document loaders for files, websites, and databases; text splitters for chunking; embedding model integrations; vector store connectors; retrievers; rerankers; and LLM nodes capable of receiving retrieved context.

RAG Capabilities and Limitations​

Flowise made it visually straightforward to assemble a RAG pipeline and experiment with different chunking strategies, embedding models, and retrieval configurations. This was genuinely valuable for rapid iteration.

However, Flowise did not guarantee RAG quality. Retrieval accuracy depended on the quality of the source documents, the appropriateness of the chunking strategy, the choice of embedding model, the capabilities of the vector store, and the design of the prompt that incorporated retrieved context. Flowise provided the plumbing; it did not automatically solve the retrieval problem. Hallucination risks, retrieval evaluation, and context-window management remained engineering challenges that required deliberate design.

Building AI Agents with Flowise​

Flowise supported the construction of AI agents—systems that use an LLM to reason about a task, select tools, execute actions, and iterate toward a goal.

Single-Agent Workflow​

A basic agent workflow in Flowise followed this pattern:

User Input
↓
Agent Node
↓
LLM (reasoning and tool selection)
↓
Tool Execution (if selected)
↓
LLM (incorporating tool output)
↓
Response

Agentflow V2 supported agent-to-agent communication, where a Supervisor agent could formulate and delegate tasks to multiple Worker agents, with outputs returned to the Supervisor. At each step, agents had access to the complete conversation history, enabling collaboration, delegation, and shared task management across multiple agents.

Multi-Agent Workflows​

Agentflow’s multi-agent capabilities supported conditional logic, loops, iteration, and human-in-the-loop interventions. A multi-agent system might include a supervisor agent that decomposed a task and routed sub-tasks to specialized worker agents—for example, a research agent, a document-analysis agent, and a summarization agent.

It is important to be precise about what Flowise could do versus what it guaranteed. Multi-agent systems in Flowise were only as reliable as the prompts, tool definitions, and routing logic that the user designed. The platform provided the orchestration primitives; the correctness of the resulting system depended on the architect.

Flowise API, SDK, and Embedding​

Flowise was designed to be integrated into applications, not just used as a standalone tool.

REST API​

Flows built in Flowise could be exposed as APIs. The historical API documentation covered categories including Prediction (executing flows), Chatflows, Assistants, Document Store, Feedback, Tools, and Variables. These endpoints allowed applications to programmatically invoke flows, manage chatflows, and integrate Flowise into backend systems.

SDKs​

Flowise provided JavaScript/TypeScript and Python SDKs for integrating flows into applications. A community Python SDK also existed for programmatically building, executing, and monitoring Agentflow V2 flows.

Embedded Chat​

Flowise provided an embedded chat widget that could be integrated into websites, with customization options for appearance and behavior. This made it possible to deploy a Flowise-powered assistant directly to a web page without building a custom frontend.

Production Integration Considerations​

For production integration, teams needed to address API authentication, rate limiting, error handling, timeout management, request tracing, secret management, and logging. Flowise provided mechanisms for some of these—such as API keys and rate limiting—but the overall production posture depended on how the deployment was configured and operated.

Installation and Self-Hosting​

Flowise was fundamentally a self-hosted platform. This was one of its defining characteristics: teams could run it on their own infrastructure, control their data, and customize the deployment.

Prerequisites​

Self-hosting Flowise required Node.js and npm (for the npm-based installation), or Docker (for containerized deployment). Environment variables were used for configuration, and persistent storage was needed for flow definitions, credentials, and any associated data.

Legacy npm Installation​

The historical npm installation pattern was:

npm install -g flowise
npx flowise start

Important: The npm package was listed as deprecated in the project’s sunset announcement, and Docker images were also marked deprecated. These commands are documented as historical reference for existing deployments, not as a recommended path for new production systems. Anyone working with an existing Flowise deployment should first confirm the exact version in use and audit dependencies.

Docker Deployment​

Docker was a common deployment method for Flowise, often via Docker Compose. A typical deployment involved configuring environment variables, mounting persistent storage for data, exposing the application port, and managing the container lifecycle. As with the npm package, the Docker images were deprecated as part of the sunset.

The Self-Hosting Trade-off​

Self-hosting offered data control and infrastructure ownership, but it also meant that the operator was responsible for everything: security updates, dependency compatibility, vulnerability management, backup and recovery, and production incident response. The end-of-life status of Flowise amplifies this responsibility—there is no upstream vendor providing patches or support.

Monitoring and Production Operations​

Flowise documented a range of operational capabilities, including execution logs, visual debugging, external log streaming, and support for Prometheus and OpenTelemetry. These capabilities were relevant for teams running Flowise in production and needing to understand workflow behavior, diagnose failures, and monitor performance.

However, the maintenance status of these capabilities must be considered in light of the project’s sunset. After the code freeze, no new operational features or fixes were added. Teams maintaining a Flowise deployment are responsible for ensuring that monitoring integrations remain compatible with their environment and that any gaps are addressed internally.

Scaling considerations—vertical and horizontal—were also documented, along with queue and worker architecture patterns. In practice, the scalability of a Flowise deployment depended heavily on the specific architecture chosen and the operational discipline applied to it.

Flowise Security and Enterprise Considerations​

Flowise documented a range of security and enterprise features, including RBAC, SSO, encrypted credentials, secret managers, rate limiting, and restricted domains. These features were relevant for organizations deploying Flowise in enterprise contexts.

Security Risks in an End-of-Life Context​

The sunset of Flowise introduces specific security considerations. The repository’s security policy explicitly states that the project is being sunset and that no new security vulnerability reports are being accepted. This means that any vulnerabilities discovered after the sunset will not receive official fixes. Organizations running Flowise must:

  • Conduct their own security assessments and penetration testing.
  • Monitor dependencies for vulnerabilities and apply patches internally.
  • Review the project’s historical security advisories and assess exposure.
  • Implement compensating controls (network segmentation, access restrictions, input validation) where appropriate.

The open-source license (Apache 2.0) permits forking and internal patching, but this shifts the full maintenance burden to the organization.

Flowise Project Status: Sunset and End of Life​

The end-of-life timeline is the most important contextual information for anyone interacting with Flowise today. The following milestones are documented in the official announcement and the repository’s archived state:

July 29, 2026 — Announcement and Code Freeze​

Flowise officially announced the wind-down of operations. Active feature development ceased immediately, and the team stopped reviewing or accepting new Pull Requests. The last release, version 3.1.4, shipped on this date.

August 10, 2026 — Planned Repository Archival​

The announcement stated that the repository would be moved to Public Archive status on this date, with code remaining visible but issues and PRs locked, and npm packages and Docker images marked deprecated.

August 13, 2026 — Repository Archived​

The GitHub repository was actually archived on August 13, 2026. It is now read-only.

August 31, 2026 — End of Life (EOL)​

Official core-team presence in Discord and GitHub concluded, and official support ceased.

What Happens to the Source Code?​

The source code remains available on GitHub under the Apache 2.0 license. The Flowise team explicitly encouraged teams to fork the repository to maintain their own internal updates or support community-led forks. This means that the open-source code is not disappearing—but the official upstream maintenance and support are gone.

It is critical to distinguish between these states:

StateStatus
Source code availabilityAvailable (archived, read-only)
Official feature developmentCeased (July 29, 2026)
Official security patchingCeased (no new reports accepted)
Official core-team supportEnded (August 31, 2026)
Existing self-hosted deploymentsMay continue to run
Flowise Cloud serviceVerify current status with official sources; do not assume continued availability

Should You Still Use Flowise in 2026?​

This is the practical question facing anyone who encounters Flowise today. The answer depends on the context.

New Projects​

For new production projects, Flowise should not be the default choice. The project is archived, there is no active upstream development, no official support, and no security patching. Building a new system on an end-of-life platform introduces long-term maintenance risk that most teams should avoid unless they have a specific reason and a clear plan for internal ownership.

Existing Projects​

For existing deployments, immediate migration is not always necessary. A stable Flowise workflow that is working and meeting business needs may continue to operate. The decision should be based on a risk assessment: the criticality of the workflow, the sensitivity of the data, the team’s capacity to maintain and patch the deployment internally, and the availability of suitable alternatives.

Internal Forks​

For teams that choose to continue using Flowise, forking the repository is the recommended path. This means taking ownership of the codebase: applying security patches, managing dependency updates, running regression tests, maintaining documentation, and planning for long-term maintenance. A fork shifts the responsibility from the former upstream team to the organization.

Decision Matrix​

ScenarioRecommended DirectionMain Consideration
New production projectEvaluate actively maintained alternativesLong-term support and security
Existing stable deploymentControlled maintenance or planned migrationOperational risk and team capacity
Internal experimental projectExisting deployment or internal forkLow-cost continuity
Enterprise deploymentFormal maintenance and security assessmentGovernance and compliance
Flowise-dependent applicationPlan migrationTechnical dependencies and timeline

Flowise Migration Strategy​

For teams that decide to migrate away from Flowise, a structured approach reduces risk.

1. Inventory Existing Flows​

Document what exists: Assistant configurations, Chatflows, Agentflows, prompt templates, model configurations, tool definitions, document stores, vector database connections, API integrations, and embedded chat interfaces.

2. Export and Back Up​

Export workflow definitions where possible. Back up configuration, document data, environment variables, model credentials, and API integrations. Note that a Flowise JSON export does not necessarily contain all credentials, external database contents, or runtime state—different data types require different backup methods.

3. Map Dependencies​

Identify the LLM providers, embedding models, vector stores, custom tools, external APIs, authentication mechanisms, memory systems, and data ingestion pipelines that the workflows depend on.

4. Select a Target Platform​

Choose a replacement based on the workload’s requirements. The alternatives section below provides guidance on which platforms fit which use cases.

5. Reimplement and Validate​

Reimplement workflows on the target platform and validate functional equivalence, prompt behavior, retrieval quality, agent execution, API compatibility, latency, cost, security, and operational readiness.

6. Plan a Gradual Cutover​

Run the replacement in parallel with the existing Flowise deployment where feasible, test thoroughly, and cut over when confidence is sufficient. Do not assume that Flowise JSON can be directly imported into another platform—most alternatives require reimplementation.

Best Flowise Alternatives​

Because Flowise is archived, the alternatives landscape is a critical part of this guide. The following platforms are actively maintained and serve overlapping use cases, though they are not all direct equivalents.

Langflow​

Langflow is a visual builder for AI agents and workflows, released under the MIT license. It is the closest conceptual alternative for teams that want a visual, node-based builder and value a permissive license. It is best suited to teams that want visual AI workflow construction with a familiar paradigm.

Dify​

Dify is a visual platform for building agents and agentic workflows, with strong RAG knowledge-base capabilities. It is licensed under Apache 2.0 with added conditions. It is best for teams building knowledge-base-backed AI applications that need to be deployed as web apps, APIs, or MCP servers.

n8n​

n8n is a workflow automation platform with AI agent nodes, licensed under the Sustainable Use License (fair-code). It is best for teams that want to add AI agents to existing business automations—it is automation-first rather than AI-first, which is a meaningful distinction.

LangGraph​

LangGraph is a code-first framework for building stateful, controllable AI agents, released under the MIT license. It is best for engineers who prefer code-based control over agent behavior and persistent state. It is not a visual builder—it is a lower-level orchestration framework for teams that want maximum control.

CrewAI​

CrewAI is a multi-agent orchestration framework (Python), licensed under MIT. It is best for teams that want to define multi-agent collaboration through code, with a role-based model for agent coordination.

OpenAI Agents SDK​

The OpenAI Agents SDK is a code-first agent development SDK. It is best for developers building programmatic agent workflows within the OpenAI ecosystem.

Comparison Table​

PlatformProduct TypeDevelopment ApproachLicenseBest Fit
FlowiseArchived visual AI builderVisual / low-codeApache 2.0Existing deployments and historical reference
LangflowVisual AI builderVisual / component-basedMITVisual AI workflows
DifyAI application platformVisual / platform-basedApache 2.0 + conditionsAI applications and RAG
n8nWorkflow automationVisual / automation-firstSustainable Use LicenseBusiness automation with AI
LangGraphAgent frameworkCode-firstMITStateful agent workflows
CrewAIMulti-agent frameworkCode-firstMITMulti-agent orchestration
OpenAI Agents SDKAgent development SDKCode-first—Programmatic agent development

Important caveats: These platforms are not all direct equivalents. Langflow is the closest visual-builder alternative; Dify is a broader application platform; n8n is automation-first; LangGraph and CrewAI are code-first frameworks. Teams should select based on their specific workflow requirements, not simply on surface-level similarity.

Flowise Strengths and Limitations​

Historical Strengths​

Flowise’s technical value during its active life was real:

  • Visual LLM workflow construction: A genuinely accessible way to assemble LLM pipelines.
  • Low-code AI application development: Reduced boilerplate for common patterns like RAG chatbots.
  • RAG integration: Comprehensive components for document ingestion, embedding, retrieval, and context injection.
  • Agent orchestration: Support for single-agent and multi-agent workflows, particularly with Agentflow V2.
  • Broad model and integration ecosystem: Connections to many LLM providers, vector stores, and tools.
  • API and embedding capabilities: Mechanisms for integrating flows into applications and websites.
  • Self-hosting flexibility: Data control and infrastructure ownership.
  • Open-source extensibility: Apache 2.0 licensing allowed forking and customization.

Current Limitations​

The end-of-life status introduces significant limitations:

  • Archived upstream project: No active development or feature additions.
  • No official support: Core-team support has ended.
  • No official security patching: New vulnerability reports are not being accepted.
  • Maintenance burden shifted to operators: Dependency updates, regression testing, and security fixes are the responsibility of the deploying organization.
  • Integration compatibility may degrade: External APIs and model providers evolve; unmaintained integrations may break.
  • Long-term commercial support uncertainty: The former commercial offering and enterprise components are not actively maintained.
  • New developer experience: Setting up and troubleshooting an archived project is increasingly difficult, as documentation and community activity decline.

Flowise’s popularity during its active years should not obscure the practical reality of its current state. It is a valuable case study in visual AI orchestration, but it is no longer a supported platform.

Who Should Learn Flowise?​

Despite its sunset, understanding Flowise retains value for certain audiences.

AI Developers and LLM Engineers​

Flowise is a useful reference for understanding visual LLM orchestration—how retrievers, embeddings, tools, agents, and prompts fit together in a working system. Its Agentflow V2 architecture, with explicit node-dependency and execution-queue semantics, is a worthwhile study in workflow orchestration design.

Software Architects​

Architects evaluating low-code AI platforms can learn from Flowise’s strengths and limitations—particularly the trade-off between accessibility and control, and the way rigid low-code workflows can constrain complexity.

Technical Founders and Teams Maintaining Legacy Systems​

For anyone responsible for an existing Flowise deployment, understanding the architecture, export mechanisms, and migration paths is directly actionable.

Enterprise Teams​

Enterprise teams managing Flowise deployments need to understand the security, governance, and maintenance implications of an end-of-life open-source dependency.

Even if Flowise is no longer a platform to build new systems on, its design and trajectory offer practical lessons about the evolution of AI application development.

Flowise sits within the broader ecosystem of AI agent development and LLM application platforms. The following tools are relevant for teams evaluating alternatives or studying the space:

  • LangGraph Guide — Code-first framework for stateful, controllable agents.
  • LangChain Guide — The framework ecosystem that Flowise’s visual abstractions were built on.
  • CrewAI Guide — Multi-agent orchestration framework.
  • OpenAI Agents SDK Guide — Code-first agent development SDK.
  • AutoGen Guide — Multi-agent conversation framework (note: also in maintenance mode, succeeded by Microsoft Agent Framework).
  • Dify Guide — Visual AI application platform with strong RAG capabilities.

Other platforms mentioned in the alternatives section (Langflow, n8n) may have dedicated guides on AIToolsDevPro as the site’s coverage expands.

Frequently Asked Questions​

What Is Flowise?​

Flowise was an open-source visual development platform for building AI agents, LLM workflows, chatbots, and RAG applications through a drag-and-drop node canvas.

Is Flowise Open Source?​

Yes. The core source code was released under the Apache 2.0 license. Some historical commercial components may have had different terms. The source code remains available on GitHub.

Is Flowise Still Actively Maintained?​

No. Active feature development ceased on July 29, 2026, and the repository was archived on August 13, 2026. No further official development is occurring.

Is Flowise Discontinued?​

Yes. Flowise has reached end-of-life status. The project was officially sunset, and official core-team support ended on August 31, 2026.

When Did Flowise Reach End of Life?​

August 31, 2026, according to the official announcement.

Is the Flowise GitHub Repository Archived?​

Yes. The repository (FlowiseAI/Flowise) was archived on August 13, 2026, and is now read-only.

Can I Still Run Flowise Locally?​

Yes, an existing self-hosted deployment can continue to run. However, no official updates or security patches will be provided. You are responsible for maintenance and security.

Can I Still Self-Host Flowise?​

Yes. The source code is available, and the Apache 2.0 license permits self-hosting and forking. The operational and security responsibilities fall entirely on the operator.

Is Flowise Cloud Still Available?​

The status of the historical Flowise Cloud offering is not confirmed by the available sources and should be verified directly with official Flowise channels before relying on it. The sunset announcement focuses on the open-source project and the core team; it does not provide a definitive statement about the cloud service’s current operational status.

What Is the Difference Between Flowise Chatflow and Agentflow?​

Chatflow was designed for single-agent systems, chatbots, and simpler LLM flows, with support for advanced RAG techniques. Agentflow was the superset, supporting multi-agent systems and complex workflow orchestration with conditional logic, loops, and human-in-the-loop interactions.

What Is Agentflow V2?​

Agentflow V2 was a re-architecture of Flowise’s agent workflow system, emphasizing explicit workflow orchestration with specialized, standalone nodes, a node-dependency execution queue, and Flow State for data management. It supported loops, conditional branching, and human-in-the-loop patterns.

Can Flowise Build Multi-Agent Systems?​

Yes. Agentflow supported multi-agent systems, including supervisor-worker patterns and agent-to-agent communication with shared conversation history.

Can Flowise Be Used for RAG Applications?​

Yes. Flowise provided visual components for document loading, text splitting, embedding, vector storage, retrieval, reranking, and LLM integration—covering the full RAG pipeline.

Does Flowise Support APIs and SDKs?​

Yes. Flowise exposed flows as REST APIs and provided JavaScript/TypeScript and Python SDKs, along with an embedded chat widget.

Is Flowise Suitable for New Production Projects?​

No. For new production projects, an actively maintained alternative is strongly preferable. Flowise’s archived status, lack of official support, and absence of security patching introduce unacceptable long-term risk for most new deployments.

What Are the Best Flowise Alternatives?​

The most relevant alternatives are Langflow (visual builder, MIT), Dify (AI application platform with RAG), n8n (automation-first with AI nodes), LangGraph (code-first stateful agents), and CrewAI (multi-agent framework). The right choice depends on whether the team prefers visual or code-first development, and on the specific workload requirements.

Can I Fork Flowise and Continue Development?​

Yes. The Apache 2.0 license permits forking, and the official announcement explicitly encouraged forking for teams maintaining their own internal updates or community-led forks. Forking shifts the full maintenance and security responsibility to the forking organization.

Should Existing Flowise Users Migrate?​

Existing users should assess their risk and maintenance capacity. A stable, low-risk deployment may continue with internal maintenance. A critical or security-sensitive deployment should plan a migration. Immediate migration is not mandatory for every case, but a deliberate decision is necessary.

Official Resources​

These sources should be consulted for verification of historical details. The GitHub repository’s archived status and the sunset announcement are the authoritative records of the project’s lifecycle.

Conclusion​

Flowise was a significant and influential platform in the early wave of visual AI application development. It made LLM orchestration accessible to a broad audience, provided a comprehensive set of components for RAG and agent workflows, and demonstrated the value—and the limits—of low-code approaches to building AI systems.

The project’s sunset in 2026 reflects a broader evolution in how AI applications are built. As the Flowise team observed, increasingly capable reasoning models and coding agents have shifted developer workflows toward code-first approaches for complex tasks, while the rigid structure of low-code workflows becomes a constraint at higher complexity. Flowise was not abandoned because it failed; it was wound down because the landscape around it changed.

For existing users, the path forward depends on context. A stable deployment can continue to run with appropriate internal maintenance and risk management. A critical system should be migrated to an actively maintained alternative—whether a visual builder like Langflow or Dify, an automation platform like n8n, or a code-first framework like LangGraph or CrewAI. For learners and architects, Flowise remains a valuable case study in visual orchestration, agent workflows, and the lifecycle of open-source AI tooling.

The source code remains, the lessons remain, and the migration paths are clear. What has ended is the official maintenance and support of a tool that played a meaningful role in the development of the AI application ecosystem.