Flow-Like
Strongly typed enterprise-scale workflows: build apps in FlowScript or on a live canvas, execute locally or remotely, with speed, AI integration and deep customization.
README and SECURITY.md describe WASM sandboxing, capability declarations, RBAC, scoped credentials, and device-local secrets kept out of Board/remote payloads; CI shows cargo-audit and container secret-scan tests. However, no evidence in the provided files of explicit user-confirmation flows before externally-visible actions (email, cloud writes, catalog integration nodes), so points deducted.
Repository structure is internally consistent (Cargo.toml members match README layout), and tests cover container publication and secret scanning. But the build depends on many git forks and pinned revs (lance, rdev, copilot-sdk, esaxx-rs, erasable), creating availability risk; failure-message quality is not observable statically.
README targets developer teams, covers Local/Remote/self-host/Kubernetes environments, and discloses a known gap (dispatcher does not yet reject every incompatible remote selection). Trigger precision (App Event selecting entry/version/location) is described conceptually without visible enforcement detail, so scored 1.
Information architecture and install notes are thorough (build steps, Compose steps, repo map, mise tasks); README proactively discloses limitations (stock API image missing AWS feature, incomplete dispatcher check). No CHANGELOG or version release records exist in the provided files (package. at 0.1.0, CI on alpha branch), so versioning scores 0. License is BSL 1.1 with commercial restrictions for large entities — present and clearly stated, hence 2.
Output usability is supported by node-attributed run evidence and FlowScript/canvas round-trip; marginal value lies in typed flows plus capability declarations. Cost-benefit is uncertain: self-hosting requires external object storage, an AWS-feature rebuild, and a multi-service stack, none quantified in evidence, so 1.
Claims in README map to SECURITY.md architecture descriptions; test files statically verify container publication constraints; factual claims are clearly separated from vision. But many security claims defer to external docs (docs/book sites) that cannot be cross-checked from these files alone, hence the deduction.
- License is BSL 1.1; entities over 2,000 employees or €300M revenue may not use the work in any capacity without a commercial license.
- Self-hosted Compose requires external object storage, and the stock API image lacks the AWS runtime-credential feature; read hardening guides before public exposure.
- Dependencies include several git forks and pinned revs (lance, rdev, copilot-sdk, etc.), raising supply-chain and availability risk beyond crates.io-only projects.
- The dispatcher does not yet reject every incompatible remote execution selection; verify each Event's execution location locally before deploying.
- No CHANGELOG or release versioning records exist in the repository; diff versions manually before upgrading.
What does this agent do, and when should you use it?
Flow-Like is a source-available developer platform for building and running application logic. Its core unit is the Flow — one executable process — and its persisted graph, the Board, which the Rust runtime executes locally or on configured infrastructure. An App packages Flows with the Events, Pages, data, packages, members, roles, and release settings a team ships; an App Event selects the Flow entry, version, and execution location for each caller. FlowScript is the typed text form of a Flow, while the canvas renders the same Board as nodes, pins, and wires, and edits in either view round-trip through a parser and reconciler. Studio, a Tauri 2 desktop application, manages Apps, edits Flows, runs logic locally, and traces results back to the Board. Flows can be triggered via APIs, schedules, chat, forms, Pages, REST endpoints, or an MCP server, and the platform ships TypeScript and Python SDKs.
In Studio you create an App and author Flows either as FlowScript text or as canvas nodes over the same Board. When you apply a source edit, Studio parses it, checks it against the node catalog, and writes the change back as Board commands that the Rust runtime executes. Before each run, pre-run analysis walks the Flow and reports runtime variables, OAuth requirements, local-only nodes, and WebAssembly permissions. An App Event exposes a pinned Flow entry to callers including APIs, schedules, chat, forms, Pages, REST endpoints, and MCP servers, choosing local or remote execution. Typed catalog nodes connect Flows to existing services and data, including local files and devices; domain operations can be packaged as native nodes or WebAssembly components with declared host capabilities. Model calls are explicit typed nodes with node-attributed run evidence, running locally or through a configured provider. Deployment spans a hosted web app, downloadable Studio, and a Docker Compose self-hosting stack with API gateway, execution workers, WASM compiler, realtime signaling, PostgreSQL, Redis, and optional Prometheus/Grafana/Tempo monitoring.
- Ops engineers codify incident triage (trim a report, branch on a substring, log accordingly) as a versioned Flow with run evidence, triggered via API or schedule.
- Backend teams expose a pinned Flow entry as a REST endpoint or MCP server through an App Event instead of duplicating business logic in callers.
- Enterprises run workflows on a self-hosted Compose stack so data and credentials stay inside their own infrastructure rather than an external SaaS automation tool.
- Domain experts compose existing service calls and input validation as canvas nodes, tracing failures to a specific node via run evidence.
- Platform teams manage Flow-Like applications programmatically through the TypeScript SDK or Python SDK.
- Automations requiring local device access (local files/devices) run in local mode, flagged in advance by pre-run analysis.
What are this agent's strengths and limitations?
- FlowScript text and canvas edit the same typed Board with parser/reconciler round-tripping, serving both code review and visual debugging.
- Pre-run analysis reports runtime variables, OAuth requirements, local-only nodes, and WASM permissions before execution starts.
- Runs produce node-attributed evidence, so failures trace back to a specific node on the Board.
- A complete Docker Compose self-hosting stack (with optional Prometheus/Grafana/Tempo monitoring profile) gives full control over data and execution.
- Clear extension paths: catalog nodes, native nodes, WASM components with declared capabilities (templates for 15 languages), plus TypeScript and Python SDKs.
- Licensed under BSL 1.1: organizations with over 2,000 employees or over €300 million annual revenue need a commercial license, and MPL 2.0 only applies after each version's Change Date or fourth anniversary.
- The self-hosted stack requires external object storage and does not create buckets; the stock .env selects AWS while the default API image omits the AWS credential feature, forcing a supported provider or an image rebuild.
- The current dispatcher does not yet reject every incompatible remote execution selection based on the pre-run local-access flag, so local/remote placement needs manual care.
- Building from source requires mise, Bun, Tauri 2 dependencies, protoc, and a C/C++ toolchain — a high setup bar for contributors.
- AWS/Azure/GCP backend deployment work exists in the repo, but each target's status must be checked before relying on equivalent behavior.
How do you install or deploy this agent?
Build from source (dev branch): install Git, mise, Tauri 2 system dependencies, protoc, and a C/C++ toolchain, then run:
git clone --branch dev https://github.com/Rheosoph/flow-like.git
cd flow-like
mise trust
mise install
bun install
cp apps/desktop/.env.example apps/desktop/.env
mise run dev:desktopSelf-host with Docker Compose:
git clone --branch dev https://github.com/Rheosoph/flow-like.git
cd flow-like/apps/backend/docker-compose
cp .env.example .envcp flow-like.config.example. flow-like.config.
../../../tools/gen-execution-keys.sh --export# Add generated keys, OIDC settings, public URLs, and storage config to .env; point FLOW_LIKE_RUNTIME_CONFIG_FILE at ./flow-like.config.
docker compose config --quiet
docker compose up -d --buildEasier entry points: the hosted web app at https://app.flow-like.com, or download Studio for macOS/Windows/Linux from https://flow-like.com/download.
How do you use this agent?
Launch Studio or open the web app, create an App, and author Flows in FlowScript (e.g. an eventsGeneric entry using catalog nodes like trim, contains, Branch, and Log) or by wiring nodes on the canvas — both views share one Board. Create an App Event to pick a Flow entry, version, and execution location (Local or Remote), then trigger it from an API, schedule, form, Page, REST endpoint, or MCP server. For development, use mise tasks such as dev:desktop, dev:web, dev:docs, and check. For self-hosting, configure .env (execution keys, OIDC, storage) and flow-like.config. first; note the stack expects external object storage and does not create buckets.