Roadmap

The initial architecture validates the core platform on a single-user, single-machine basis. Local inference stays zero-egress by default. Cloud AI and service-node API integrations are opt-in, off-by-default carve-outs. The enterprise capabilities below preserve that boundary. Shared coordination services handle metadata only, never inference data or spool content.

Product editions

The platform ships as several editions on one shared Rust core and node registry: Flow Studio (desktop, current), Flow Code (VS Code, shipped), Flow Server (private cloud, available), and Flow CLI (terminal and CI, preview), with Flow Mobile and Flow Edge as exploratory editions. See Flow editions for the edition matrix and the one-UI-one-backend structure.

Shipped capabilities

The following capabilities are implemented:

• The agentic engine - review-then-run generation, the monitor role with failure interception, context-aware and surgical fixes, sub-flows, the autonomous convergence loop with iteration/wall-clock/token budgets, per-step destructive gates, pre-apply verification, durable working memory, and per-interception DSL snapshots with revert. See agentic and autonomous runs.
• Agentic context engineering - a host-neutral context layer that makes a coding-agent turn context-aware, skill-driven, and safety-gated, shared by Studio, Flow Code, the CLI, and the server. It loads Agent Skills with progressive disclosure (the catalog up front, a skill’s full instructions on demand, bundled resources read only when referenced), puts the project’s CONTRIBUTING.md first so the project’s own rules take precedence, runs a static safety gate over external skills before their body is loaded, keeps a per-project working memory that fuses keyword relevance with recency-based decay and reinforcement, and scores context quality. Tool and shell output is compressed at the run boundary with a failure focus and unconditional credential scrubbing. All of it runs in-process and stores its data outside the repository.
• Capability-driven AI execution - reasoning, tool loops over sandboxed adapters, vision, embeddings, classification, structured output with native schema enforcement, and per-node provider failover, across local and cloud providers.
• Execution concurrency (opt-in) - available behind a setting, with the default preserving the original one-node-at-a-time behavior. When you raise max_parallel_nodes above 1, an acyclic graph without sub-flows or gates runs its dependency-complete independent nodes at the same time; a node becomes ready only once every predecessor is terminal, so it still sees all of its upstream outputs exactly as it would have run sequentially. You can cap how many nodes of a given kind (shell, CLI, service, or AI) run at once, and a bounded inference queue lets AI assistance degrade onto its .fail path before the rest of the graph stalls. Pause holds new dispatch and cancel drains in-flight nodes so none are aborted mid-side-effect. Graphs with a single human gate still run sequentially today, because the review verdict is shared per run.
• Model runtime scaling (opt-in) - available behind a setting, with the default keeping a single active model where loading a new one stops the previous. When you raise max_loaded_models above 1, several local models can stay resident at once, each on its own local server, and an already-loaded model is reused instantly. The registry evicts the least-recently-used model under capacity or memory pressure, you can warm-load a model ahead of a run so it pays no cold-start latency, and each resident model gets its own inference slots. It works across the desktop app, the server, and Flow Code, with a resident-models view and preload and unload controls in the React Model Hub and in the Flow Code model picker.
• Scheduling - per-flow persisted timers, the visual schedule picker, cadences with timezone handling and catch-up policies, and the background scheduler in all three surfaces. See scheduling.
• Service nodes - the generic data-driven REST adapter with full OAuth2 and keyring-held connections.
• Flow CLI - the headless runner, the tabbed TUI, generation, concurrent runs, and packaged distribution. See the CLI.
• Flow Server - the HTTP/SSE runtime, the browser-delivered shell with host-facade parity, in-instance model runtime, persistence, and bearer-token auth. See the server.
• Flow Code (VS Code edition) - a native sidebar that generates a Flow DSL from a prompt, runs it on the orchestrator with a live per-step tree, and lets the model monitor and repair the run. The workspace is pinned to the open VS Code folder, and the engine owns every write. Each tab picks its own model, a run-config popover sets the context size and toggles reasoning, a context-usage indicator shows how much of the window a run is using, and runs are editable and exportable from the run panel. Flow DSL gets syntax highlighting in .flow files and in the in-panel previews. A built-in code-intelligence graph adds three tree views (the symbol graph, blast radius, and stats), a status bar, source-control “review changes” actions, impacted-file decorations that refresh as you save, and a force-directed graph view, all backed by the shared graph over the orchestration sidecar. See Flow Code.
• Unified settings - one shared settings file backs every edition, with a field set tagged per-edition and rendered the same way in Studio, Flow Code, the CLI, and the server.
• Hubs - the Model Hub client with device compatibility and verified downloads, the Template Hub, and the Node Hub install pipeline with CLI-tool version probes.
• AI governance and contracts - opt-in contract-bound ai nodes with engine-enforced confidence routing (auto-approve, human review gate, suppress), deterministic .fail fallbacks, and a complete AI decision audit trail. Static governance checks, an input-security envelope with prompt-injection scanning, admin-extensible PII rules, engine-derived token-level confidence, a context-window strategy, flow-level contract-version pinning, agent-feature gating (the tool loop and autonomous run as opt-ins), and OS-level isolation for the managed model server. The governance verdict is surfaced across Studio, the CLI/TUI, and Flow Code. See AI governance.
• Flow export / Code Generator - transpile a flow into a standalone Bash or PowerShell script that runs without the Flow runtime. The script preserves node ordering, retry policies, and conditional routing. When it runs, it prints readable steps and prompts for any required inputs. Service and cron nodes become documented manual stubs. Flows with AI or agentic nodes are not exportable because they need the runtime. Export is available from the CLI (flow export), across hosts via the shared core, and from the Studio canvas toolbar. See the CLI.

In progress and planned

• Model Hub registry service - the hosted metadata API, semver with app-compat pinning, package signing and provenance, publisher trust gates, update channels, shadow mode, and model observability.
• Template Registry - hosted, versioned, approval-gated template sharing with approved-model validation.
• Engine distribution - per-OS managed sidecar packaging with code signing and notarization.
• Remaining agentic budgets - planning-call token accounting, a confidence gate before auto-accept, multi-agent roles, and parallel fix proposals.
• Concurrency for human-gated graphs - a per-node verdict redesign so that graphs containing a single human gate can run their independent nodes concurrently too, rather than falling back to sequential execution.
• Deeper code intelligence and memory - live semantic memory retrieval behind an opt-in setting (off by default because embedding calls mean provider cost and egress), a richer relationship taxonomy in the code graph beyond call edges, test-coverage signals in the source-control view, and richer context-quality signals once session-level token tracking exists.

Enterprise services (later)

Flow scales horizontally across users. Each user runs local inference on their own machine, and there is no centralized inference. Coordination comes from three shared, metadata-only services:

Service	Purpose	Handles
Model Hub	Versioned AI model distribution	Model artifacts, metadata, version history
Governance Service	RBAC, approval gates, template permissions	Flow-graph metadata only
Template Registry	Shared flow-template repository	Graph structure: nodes, connections, configuration

Two team-level capabilities sit on top of these services. The first is tamper-evident execution history with metadata-only SIEM forwarding. The second is multi-user collaboration through standard version-control semantics on template definitions.

None of these services process inference data. The zero-egress boundary is preserved by design.

Related

• Adoption strategy
• Regulatory compliance