Terms
What flowRS does with what you make, written from what the code does. flowRS has no accounts, so there is nothing to sign: this is how the site treats you.
1. What you make is yours
Your graphs, your files, the programs flowRS exports for you and everything they compute belong to you. flowRS claims no rights in them beyond what it needs to do what you ask (to compile a firmware you asked it to build, say) while it does it. It does not train any model on them.
2. The open parts stay open
The runtime crates every export carries are under MIT OR Apache-2.0, the published engine under Apache-2.0, and the document format's prose under CC BY 4.0, with its schema and corpus under the code's licence. Nothing in these terms limits what those licences allow, including studying, changing and reverse engineering them.
3. Contributing
Contributing is your own free choice. You keep your copyright. What you contribute is under the licence of the part you contribute to, and it is accepted when it benefits the project. CONTRIBUTING.md says how.
4. Where your graph goes
The editor runs in your browser. Your graphs are saved in your browser (its local storage and its file store) and exported as files you download. A graph or a file reaches flowRS's server only as this table says, and only for that use.
| What | What goes | When | Routes |
|---|---|---|---|
| Standing checks on the canvas | The graph's text and which nodes to compare. | Only once you turn on "Compare on flowRS's server" below the canvas, for each node whose compiled comparison the browser cannot make itself. It is off until you do, and your choice stays in this browser. | /api/reverify |
| The hosted agent | Your request, the graph's text, and the conversation so far. | When you ask it something. | /api/agent/api/agent/budget |
| A firmware build | The graph to build, and the board. | When you press Build. | /api/forge/build/api/forge/targets |
| A processor-in-the-loop check | The graph to compile and run on a simulated core. | When you start the check. | /api/pil |
| The Linux twin | The graph to build and run on an emulated board. | When you run it, on a server that offers it. The Run button says so when this one does not. | /api/linux/machines/api/linux/run |
| Instrument programs and energy estimates | The program or the numbers to check, and nothing else of the graph. | When you ask for the check or the estimate. | /api/instruments/validate/api/instruments/program/api/energy/estimate |
| Registry signature check | A package's signed record, not your work. | When you install a package. | /api/registry/verify |
| An agent's connection (MCP and tasks) | What an agent sends: its graphs, its builds, its checks. | Only with the agent's secret token. None is set on flowrs.openie.dev, so there it answers discovery and refuses the rest. Anyone can read a task's status; its request no one, and its answer only the client that asked. | /mcp/mcp/server-card/api/tasks/api/tasks/{id}/api/tasks/{id}/cancel/api/tasks/{id}/resume |
| An agent runtime's connection (RAP) | What an agent runtime sends: a tool call, and the address its answer should go to. | Only with the agent's secret token, on a server whose operator lists the addresses answers may go to. Neither is set on flowrs.openie.dev, so there every one of these refuses and keeps nothing. | /rap/.well-known/rap-toolset/rap/invoke/rap/cancel_tool_call/rap/close_thread |
| Agent threads on a server you run | What an agent asks of a long-running thread: its request, the graph, and the thread's history, kept beside its task. | Only with the agent's secret token, on a server someone runs themselves. None is set on flowrs.openie.dev, so there each of these refuses and nothing is stored. Threads in your browser use none of these: they are kept in your browser. | /api/threads/api/threads/{id}/api/threads/{id}/input/api/threads/{id}/decide/api/threads/{id}/close |
| Bench gateways | Connections to instruments, debug probes, LSL streams, ROS routers and a Foxglove view. | Off on flowrs.openie.dev, where they say so and do nothing. They work only on a server someone runs on their own bench and turns them on. | /api/instruments/gateway/api/instruments/discover/api/instruments/connect/api/instruments/disconnect/api/instruments/connections/api/live/gateway/api/live/attach/api/live/rtt/api/live/sample/api/live/detach/api/lsl/gateway/api/lsl/resolve/api/lsl/open/api/lsl/stream/{id}/api/lsl/close/api/lsl/record/api/lsl/record/stop/api/lsl/recordings/api/lsl/recordings/{name}/api/lsl/outlet/api/lsl/outlet/close/api/lsl/push/{name}/api/foxglove/api/foxglove/start/api/foxglove/stop/api/foxglove/publish/api/ros/gateway/api/ros/graph/api/neuro/recordings/api/neuro/recordings/{name} |
| Approvals and the bench's control plane | Leases, proposals and releases of values, which change anything only with a person's or an agent's secret token. | No such token is set on flowrs.openie.dev, so nobody can act through these there. Reading them is open, and they hold nothing of a visitor's work. | /api/sessions/api/sessions/acquire/api/sessions/release/api/sessions/intervene/api/sessions/reconcile/api/sessions/apply/api/sessions/fence/api/proposals/api/proposals/new/api/proposals/decide/api/proposals/claim/api/proposals/finish/api/proposals/resolve/api/proposals/request/api/agents/api/agents/hello/api/inbox/api/inbox/stream/api/releases/api/releases/new/api/releases/decide/api/releases/revoke/api/audit/api/audit/export/api/audit/append |
| What the page reads | Nothing of yours: these only answer. | When a page needs to know what this server offers. | /api/health/api/capabilities/a2ui/v0_9_1/catalogs/flowrs-app-1/catalog.json/api/energy/meter/api/instruments |
The flowrsc command-line tool does all of its checking, running and exporting on
your own machine, and sends nothing to flowRS.
Firmware you load into the twin panel stays in your browser. "What does this firmware do?" runs
it on a twin in the page and reports what it did there: no route of the server takes your firmware,
so none is in the table above. The same report from flowrs-mcp or
flowrsc firmware explain runs on your own machine, and a hosted agent's workspace is not
offered it.
5. AI
flowRS offers these ways to use a model, and says which one is in use.
- In your browser. A local model (WebLLM) runs on your machine, from weights served by flowRS's own site. What you type to it stays in the browser.
- The hosted agent. Your request, the graph's text and the conversation so far go to flowRS's server, which sends them to Anthropic's API to answer you. It needs no account, and one key pays for everyone within limits set on the server: 10 requests a minute and 60 an hour from one address, 500 a day across all visitors, 5000000 model tokens a day, and 512 KiB a request. Past a limit it says so and when to try again.
- Your own key. Your request goes from your browser straight to
api.anthropic.comwith your key. The key stays in that browser tab (in memory, or in the tab's session storage if you tick the box) and is never sent to flowRS.
flowRS does not use your graphs, files, prompts or results to train any model, and does not sell or share them except as these terms say.
What Anthropic says of the hosted agent's requests, as we read it on 2 November 2026: its commercial terms (effective 17 June 2025) say
Anthropic may not train models on Customer Content from Services.
and its page on data retention (dated 1 July 2026) says
For Anthropic API users, we automatically delete inputs and outputs on our backend within 30 days of receipt or generation
with exceptions it lists there, among them enforcing its Usage Policy (up to 2 years for inputs and outputs its automated systems flag) and the law. Those are Anthropic's words and its to change; read them there.
6. Neural data
Values read from neural recordings (EEG and other biosignals) are not sent to a model by flowRS, by any of these routes; the editor, flowRS's agents and exported apps withhold them, along with everything computed from them. The graph's own text can still go, as section 5 says. On a server of your own, you can release one value you choose to your agent: that release is yours to make, is recorded, and cannot be made on flowrs.openie.dev, where no person's token is set.
7. What the server keeps
- Request logs. For each page and API request the server logs its method, its path (no query and no body), the client's address, the status and how long it took, to run and secure the service. A line is kept for at most 30 days: the server deletes older lines itself. The log is also capped in size, so heavy traffic can shorten that.
- Builds and checks. A firmware build, a processor-in-the-loop check, an agent's compile check or a task keeps its request and answer for 24 hours after it ends, so a client that lost its connection can still fetch the answer. Then they are erased, and what stays is that it ran: its kind, status, times and what it spent. A task left waiting is cancelled and erased after 30 days. Build directories are removed when the build ends. The compiler's cache keeps the last compiled output for each target until the next build replaces it or the cache is trimmed.
- Standing checks. The graph is used and dropped. The comparison's result stays in the server's memory, filed under a hash of what it read, until it is pushed out or the server restarts; another visitor gets it only by asking about the same node on the same inputs.
- Rate limits. An address is on disk only while it is being limited, and goes once its allowance has filled again.
- The hardware audit log. Every hardware decision (a proposal made, approved,
rejected, claimed and finished, a lease taken back) and every payload of neural data or of a request
about it that leaves the server is an entry in a hash-chained log: who or what caused it, what it
was about, where it went, its size and SHA-256, never the payload. The server appends to it and
never deletes from it, for as long as the service runs, and anyone can read it at
/api/audit. - When a request fails on its way. flowrs.openie.dev runs behind two web proxies and a tunnel on flowRS's own machines. If a request cannot reach the server (it is restarting, say), they write the failure to their own error logs, with that request's path, headers and client address. Those logs belong to the machines, which host other sites too, and they are not on the 30-day clock: today nothing limits their age.
None of it is sold.
8. Who else handles requests
- Cloudflare carries every request to the site. Its privacy policy (effective 4 November 2025, read 2 November 2026) says it processes visitors' IP addresses and other information about their traffic, and gives no fixed period for keeping it.
- Anthropic answers the hosted agent, as section 5 says.
- Tailscale: the machines that serve the site talk to each other over its private network, encrypted between them.
Your browser reaches a few other places itself, and only when you ask: play.rust-lang.org, lindi.neurosift.org, api.dandiarchive.org, dandiarchive.s3.amazonaws.com, api.anthropic.com. That is
compiling on the Rust Playground, opening a recording from the DANDI archive, and your own key with
Anthropic. The site's Content-Security-Policy lets a page reach those and nowhere else.
9. Changes
flowRS will announce a change to these terms on this page at least 30 days before it takes effect. The continuity pledge's promises are not changed by changing these terms.
10. Contact
Open an issue: the public engine repository's issue tracker.