Flock: a Tauri desktop harness for LangGraph agents, built on a personal Rust port
A desktop multi-agent harness built with Rust, Tauri, and React, powered by langgraph-rust.
At a glance
- What is it?
- Flock packages a multi-agent runtime, a ReactFlow workflow editor and a sandboxed VNC desktop into one Tauri application, with the graph engine supplied by langgraph-rust, the maintainer's own Rust reimplementation of LangGraph. The interesting question is not what it does but what you inherit when you adopt it.
- Who is it for?
- Adopt Flock if you want a local desktop surface for LangGraph-style agent graphs and you accept that the graph engine is a personal Rust port rather than the upstream Python project. Do not adopt it if you need a headless service, a stable plugin API, or a runtime you can patch without understanding langgraph-rust.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 71 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap Flock is trying to fill between a chat client and a CI runner
Most desktop LLM clients stop at a conversation window. Flock's README draws the contrast explicitly in a comparison table, listing visual workflow building, filesystem access, multi-step autonomy, cron scheduling and multi-agent collaboration as things traditional chat clients do not offer. The target user is therefore someone who wants to watch an agent read files, run shell commands and drive a browser from a local GUI, with an approval prompt in front of the destructive steps, rather than wiring that up behind an API. The README's own framing is a harness: it orchestrates agents locally or inside sandbox containers and states that you see everything the agent does. That is a different product category from an SDK. It is also a different category from a server-side orchestrator, because the whole thing ships as a Tauri desktop application with a React and Mantine front end talking to a Rust core over Tauri commands.
The crate split, and why langgraph-rust is the load-bearing dependency
The architecture diagram shows the Tauri UI communicating with src-tauri over IPC, which in turn talks to flock-agent over a JSON protocol. Below that sits the graph state machine, and the README names it directly: langgraph-rust. This matters more than the feature list. The README states that Flock is built on top of langgraph-rust, described as the maintainer's personal Rust implementation of the LangGraph framework. The module table then splits responsibilities across five crates: flock-core for configuration schemas, SQLite models, encryption utilities and IPC channels; flock-agent for the executor loop, state engine, checkpointer and memory; flock-workflow for node logic and a JSON-to-LangGraph AST compiler; flock-tools for built-in and sandboxed tools plus VNC websocket proxies and sandbox managers; and flock-skills for the system prompt loader. The JSON-to-LangGraph compiler in flock-workflow is the piece worth noticing. It means the visual canvas is not the runtime representation. The ReactFlow graph is serialised, compiled into a langgraph-rust graph, and executed there. Any node type the compiler does not understand is a hard boundary, not a soft one.
Ten node types and what the compiler has to do with them
The README lists ten shipped node types: start and answer for workflow inputs and final delivery; llm and agent for pure inference and tool-enabled agents; classifier and ifelse for semantic routing and conditional branching; code for custom JavaScript or Python runners; human for interactive interrupts; and plugin and parameter_extractor for exposing tools and extracting structured data. Two of these are structurally different from the rest. The human node is an interrupt, which in LangGraph terms means the graph must be able to suspend and resume, and that requires checkpointer support in the underlying engine. The code node executes arbitrary JavaScript or Python, which is exactly the kind of node the sandbox exists for. If you are evaluating Flock, the first thing to check is whether langgraph-rust implements interrupts and checkpointing to the depth your workflow needs, because the README describes the checkpointer as living in flock-agent backed by SQLite but does not document its semantics. That is not a criticism of the design, it is an admission that the documentation stops one layer above the part that will actually break.
Getting it running: what the README actually tells you
The quick start section is referenced in the navigation but the supplied README text does not include the commands, so I cannot give you a verified build invocation. What is documented is the configuration story: the built-in agent is described as zero configuration, requiring only that you paste an API key for OpenAI, Gemini, Anthropic Claude, AWS Bedrock or a local Ollama instance. MCP servers are configured once and the README states that all assistants and workflows automatically inherit the newly exposed schemas and tools. Skills are loaded from YAML-frontmatter prompt files and support hot reloading on file change, which means editing a prompt file does not require restarting the application. Scheduled tasks use standard cron syntax. The honest summary is that the runtime configuration surface is described in prose and the build instructions are not present in the material I have, so treat the repository's quick start section as the thing to read before you commit an afternoon to compiling it.
The sandbox and VNC design is the most opinionated choice here
Flock does not try to make shell execution safe by restricting it. It moves execution into an isolated container and then streams that container's desktop back into the UI. The diagram shows the path: the sandbox client talks to an X11 and VNC server, x11vnc plus websockify, which pushes a websocket stream to the UI. The README describes VNC screen takeover as a feature for the moment an agent gets stuck on a captcha, where you take over mouse and keyboard. That is a coherent design. It also means the sandbox is not a security boundary in the sense a server operator would expect, because a human is invited to interact with it. The isolation protects your host from the agent, not the agent from you. Browser automation runs through Playwright inside that environment, and computer use runs through OS-level commands such as xdotool against the virtual desktop's framebuffer. If your deployment target cannot run containers with a VNC stack, most of the interesting half of Flock is unavailable to you.
The Python rewrite is the maintenance fact that should drive your decision
The README states that Flock was completely rewritten from a Python application using LangGraph, LangChain and FastAPI into the current native desktop application, and that the original codebase is preserved in the legacy/python branch for reference. It frames the rewrite as bringing improvements in performance, reliability and user experience. Take the framing as marketing and the fact as the fact: the project has already changed its entire runtime once, and the graph engine underneath it is a personal port rather than the upstream project. The release cadence visible in the supplied data runs v0.2.9 in early June, v0.3.0 the next day, and v0.3.1 two weeks later. That is a fast-moving pre-1.0 line. Anyone adopting Flock should assume that crate boundaries, node types and the langgraph-rust API are all still in motion, and should budget for reading Rust source rather than only documentation when something behaves unexpectedly.
Where Flock is the wrong tool, and what to use instead
Flock is a desktop application. If you need an agent graph running headless on a server, triggered by HTTP or a queue, the Tauri shell is dead weight and the IPC layer between the UI and flock-agent is a boundary you would have to bypass. The natural alternative is the upstream Python LangGraph, which the README itself identifies as the origin of this project's approach. The difference is not features, it is the execution model and the ecosystem. Upstream LangGraph runs in Python with the surrounding LangChain tooling, a large body of community examples and a checkpointing layer that has been exercised by many more users than a personal Rust port. Flock's counter-argument is the one the README makes: a native binary, a visual editor, a sandbox with a streamed desktop, and no Python environment to manage. If your work is interactive and local, that trade is reasonable. If your work is a scheduled pipeline that must run unattended and be debuggable from logs, the Python path has fewer unknowns. A second alternative worth naming is simply writing the graph in langgraph-rust yourself, since Flock's engine is a separate crate you could depend on without the desktop shell, though the README does not document langgraph-rust as a standalone product, so you would be reading that repository's own material to judge it.
Licence and the cost of keeping up
The repository is Apache-2.0, which permits commercial use and modification and includes an explicit patent grant, with the usual requirements around notices and stating changes. That is a permissive licence and it is the least of your concerns. The real maintenance cost sits in two places. First, the langgraph-rust dependency, because Flock's graph semantics, checkpointing and interrupt behaviour are defined there and not in Flock. Second, the sandbox and VNC stack, which is a container image plus x11vnc and websockify, and which you will need to rebuild or mirror if your environment restricts image pulls. Neither cost is documented in the material I have as a versioning or support policy. Before adopting, check the Cargo.toml pin on langgraph-rust, check whether the sandbox image reference is configurable, and read the legacy/python branch only if you are considering the older FastAPI design, which the README presents as superseded. This is not legal advice; read the Apache-2.0 text yourself if notice obligations matter to your distribution.
Editorial conclusion
Adopt Flock if you want a local desktop surface for LangGraph-style agent graphs and you accept that the graph engine is a personal Rust port rather than the upstream Python project. Do not adopt it if you need a headless service, a stable plugin API, or a runtime you can patch without understanding langgraph-rust. Verify first that the crate split still matches the README, that the sandbox image is something you can build offline, and that the langgraph-rust version pinned in Cargo.toml has the checkpointer and interrupt behaviour your workflows depend on.
Community notes