graph-flow Workflow Framework

Build stateful Rust workflows that can pause for input and resume later.

Stars
★ 390
Last updated
1mo ago
License
MIT
Primary language
Rust

At a glance

How it runs
Library / SDKFrameworkSelf-hosted service
Works with
Universal · cross-platformOpenAI API (Partial support)
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
RustTokioPostgreSQL (optional)rig-core and rig-agent (optional)Shell / CLINetwork accessLocal filesystem
Typical use
Rust service developers building resumable LLM-driven claim intake, classification, review, and human approval flows.
Not a fit if
  • Teams looking for a ready-made hosted chat app
  • Users who need a no-code workflow editor
Maintenance
Commits in the last 30 dayslast commit 2026-10-21

What does this agent do, and when should you use it?

graph-flow is a LangGraph-inspired Rust library for complex, interactive, resumable workflows. Developers implement Task and use the thread-safe Context to read and write state serialized with each session, then define tasks, edges, and conditional routing with GraphBuilder. FlowRunner loads, executes, and saves a session one step at a time; tasks can also continue through subsequent steps or wait for user input. Sessions can use in-memory or PostgreSQL storage, and the repository includes an Axum insurance-claims service example and a recommendation-system example. It is a framework to embed in Rust applications or use in self-hosted services, not a ready-made chat product.

Developers implement the Task trait for workflow steps; each task reads inputs and stores results through Context, then returns a TaskResult and NextAction. GraphBuilder assembles and validates the graph, supporting ordinary edges, conditional edges, and FanOutTask child tasks running in parallel as a graph node. FlowRunner.run(session_id) loads a session, runs the workflow, and saves state; the result includes a response and ExecutionStatus. Tasks can return control after a step, continue executing, jump to another task, wait for input, or end the workflow. Sessions can be persisted with InMemorySessionStorage or PostgresSessionStorage; with the rig feature, chat history in Context can integrate with Rig's Message.

  1. Rust service developers building resumable LLM-driven claim intake, classification, review, and human approval flows.
  2. Interactive applications that need to run one workflow step per request, return a result, and resume the session on a later request.
  3. Applications that route work to different tasks based on classifications or business data in Context.
  4. Developers who need to run several child tasks concurrently and aggregate their outputs into shared context.
  5. Services that need PostgreSQL session persistence and optimistic-lock detection for concurrent saves to the same session.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Environment variables
OPENROUTER_API_KEY
Config files
Cargo.toml

How do you install or deploy this agent?

Add graph-flow to your Rust project's Cargo.toml. PostgreSQL support is enabled by default; disable default features if you do not need that storage backend. To use Rig message integration, enable the rig feature and add the relevant Rig crates. The README does not document Rust toolchain installation; LLM examples also require provider credentials, such as OPENROUTER_API_KEY.

How do you use this agent?

Implement a Task, then add tasks and edges with GraphBuilder and build the graph. Create a Session, save it through SessionStorage, and execute it with FlowRunner.run, checking the returned status. Choose the appropriate NextAction for continuous execution or waiting for user input. The repository includes a runnable insurance-claims service example:

What are this agent's strengths and limitations?

Pros
  • Provides a clear, typed Rust workflow interface through Task, Context, GraphBuilder, and NextAction.
  • FlowRunner and session storage support stepwise execution, input pauses, and resumption; PostgreSQL provides persistent sessions.
  • Includes conditional routing, parallel child tasks with FanOutTask, per-task timeouts, execution-step limits, and optimistic-lock conflict detection.
  • The optional rig feature connects context chat history to Rig Message, and the claims example demonstrates human review.
Limitations
  • It is a Rust library and framework; adopters need to implement tasks, assemble graphs, and integrate it into an application.
  • PostgreSQL is enabled by default, so projects that do not need it must set default-features = false; the example service can also use in-memory storage.
  • Rig integration must be enabled explicitly and uses rig-core; the agent runtime in the example uses rig-agent.
  • The README documents API cleanup from 0.5 to 0.6 and a migration guide, so projects using older APIs should assess migration work.

How does this agent compare with similar options?

The README describes graph-flow as a Rust implementation inspired by LangGraph, providing graph execution and stateful workflow features. It does not provide benchmarks or a feature-by-feature comparison with LangGraph.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
graph-flow Workflow Framework This agent 59 · Major gaps Library / SDKFree + model costs ★ 390 1mo ago Rust —
Agent Adapter 72 · Some gaps Library / SDKFree + model costs ★ 13 3d ago Python OpenAI API · Claude API
LlamaAgents 59 · Major gaps Library / SDKFree + model costs ★ 469 today Python —
KaibanJS 53 · Major gaps CLIFree + model costs ★ 1.5k 6mo ago TypeScript Codex · Claude Code · OpenAI API · Claude API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
59/ 100 5-point scale 3.0 / 5
Trust 12/29
Reliability 6/14
Adaptability 12/18
Convention 14/18
Effectiveness 10/13
Verifiability 5/8
Why each dimension lost points
Trust12 / 29 · 2.1/5

The framework documents task timeouts, step limits, optional persistence, and human-input pauses. The README also discloses that concurrent-run side effects are not rolled back, supporting partial controls and confirmation flow (least_privilege=1, user_confirmation=2, rollback=1). The README explains that state enters Context and sessions can be persisted; service code shows request content being stored, and the recommendation service logs the query. No sensitive-field redaction, retention policy, or access controls are shown (data_flow_transparency=2, sensitive_data_handling=1). Dependency ranges and a CI matrix are visible, but there is no dependency audit or vulnerability mitigation evidence. Example services call external LLMs and databases, bind to all interfaces, and the insurance service uses permissive CORS (dependency_security=1, external_effects=1). An MIT file and contributor copyright notice are present, but maintainer identity and update responsibility are unclear (source_attribution=1).

Reliability6 / 14 · 2.1/5

The README describes a 0.6 API cleanup, while CLAUDE.md still mentions an Error status and other older API details. CLAUDE.md appears to be contributor guidance rather than product runtime instructions, but the discrepancy shows documentation drift (self_consistency=1). The Cargo workspace and CI show Rust dependencies and how the core crate is built. CI explicitly skips services and examples that download ONNX Runtime; external services and databases also require configuration, so availability is only partly documented (dependency_availability=1). Service code handles missing sessions, storage failures, and unexpected workflow pauses. Some errors become generic HTTP statuses or messages, so diagnostics and user-facing guidance are not consistently thorough (failure_messages=2).

Adaptability12 / 18 · 3.3/5

The README covers interactive and continuous execution, conditional routing, parallel tasks, in-memory and PostgreSQL storage, Rig integration, and insurance and RAG examples, giving strong audience and scenario coverage (audience_and_scenarios=3). It documents timeouts, execution limits, concurrency conflicts, FanOut failures, and chained-execution crash behavior; permission, authentication, and production-deployment boundaries are less fully defined (capability_boundaries=2). The repository has a clear overall purpose, but no evidence explains when to choose the framework or when it is unsuitable (trigger_precision=1). Tokio, optional PostgreSQL support, in-memory storage, and environment variables provide some environment guidance, though service examples also use fixed ports and external configuration (environment_fit=2).

Convention14 / 18 · 3.9/5

The README is organized by crate, quick start, execution controls, advanced features, and service examples; CLAUDE.md provides development commands and an architecture overview (information_architecture=3). Cargo dependencies and run examples are provided, with some environment variables and storage defaults, but comprehensive deployment and security setup is absent (install_notes=2). The graph-flow crate and its main concepts have mostly stable names; older API names in CLAUDE.md reduce consistency (naming_stability=2). Progressive examples, a complete service case study, and concrete control patterns support a high score despite no FAQ (examples_and_faq=3). The docs list FanOut limitations, concurrency side effects, persistence differences, and timeout constraints; service deployment and data governance have unresolved documentation gaps (known_limitations=2). A complete MIT license is present and matches the metadata (license=3). The README describes the 0.5 to 0.6 migration and API stability, but does not provide a complete current release history (versioning_changelog=2). The copyright names only contributors; no clear maintainer, support channel, or update commitment is shown (maintenance_responsibility=1).

Effectiveness10 / 13 · 3.8/5

Rust API examples, workflow diagrams, service cases, and usable storage and execution snippets can guide implementation (output_usability=3). Graph execution, resumable sessions, human pauses, routing, and Rig integration provide clear framework value, but there is no evidence quantifying gains over alternatives (marginal_value=2). The in-memory and PostgreSQL options and feature switches expose some cost choices, but LLM, database, and ONNX-related operating costs are not quantified (cost_benefit=2).

Verifiability5 / 8 · 3.1/5

The README links major capabilities to crate paths, examples, and specific service tasks, and the supplied service code corroborates some HTTP, storage, and logging behavior. Performance and production-suitability claims have less direct support (claim_traceability=2). The README, Cargo manifest, CI, and service entry points corroborate features, dependencies, and configuration. CLAUDE.md differs on API details, and the framework's main source is not included in this evidence packet (cross_source_corroboration=2). Documentation generally labels examples, defaults, and limitations, but performance and suitability claims are not quantified, and the packet is insufficient to independently verify all framework behavior (fact_inference_separation=2).

Risks and how to mitigate them
  • Example services persist request content or user queries in session state; the recommendation service also logs the query. Review access controls, log redaction, and retention before deployment.
  • The insurance service uses permissive CORS and listens on 0.0.0.0; authentication is not shown in the supplied entry point. Do not treat these example defaults as a secure public deployment configuration.
  • The docs state that task side effects are not rolled back on concurrency conflicts, and a crash during a chained run may cause the chain to restart. Tasks with side effects need idempotent designs.
  • CLAUDE.md API details differ from the README's 0.6 description. This assessment uses only the supplied static material and did not execute builds or tests.
Evidence confidence: Low Reviewed Nov 11, 2026 Reviewed revision 9bbca193f20a
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/rs-graph-llm.svg)](https://followagents.com/en/agents/rs-graph-llm)
<a href="https://followagents.com/en/agents/rs-graph-llm"><img src="https://followagents.com/badge/rs-graph-llm.svg" alt="FARS review"></a>

FAQ

Can I use it without an LLM integration?
Yes. The core graph-flow crate provides graph execution and session management; Rig message integration is an optional rig feature.
Can sessions resume after a process restart?
Use PostgresSessionStorage for persisted sessions. InMemorySessionStorage is suitable for development but keeps data in memory.
What happens if two runs update the same session?
Sessions use optimistic-lock versions; the losing save returns GraphError::SessionConflict. Task side effects from the failed attempt are not rolled back, so the docs recommend idempotent tasks.
What happens if a process crashes during continuous execution?
A session is saved only after a ContinueAndExecute chain finishes. A crash mid-chain means the next run starts again from that chain's first task.
Does it include a ready-to-use web app?
The repository shows an Axum insurance-claims HTTP service example, but graph-flow itself is a framework for integrating into applications.
Is graph-flow Workflow Framework free?
The software is free, but graph-flow Workflow Framework calls an AI model, and you pay that model provider for usage (or run a local model).
Is graph-flow Workflow Framework open source?
Yes. The source code is on GitHub (a-agmon/rs-graph-llm) under the MIT licence.
Is graph-flow Workflow Framework safe to use?
FollowAgents' FARS review (Nov 11, 2026) scored graph-flow Workflow Framework 12/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is graph-flow Workflow Framework still maintained?
Yes. The latest commit on GitHub is from 2026-10-21, within the last 30 days.
Who makes graph-flow Workflow Framework?
graph-flow Workflow Framework is published on GitHub by the account a-agmon. FollowAgents has not verified which person or company is behind that account.
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts