graph-flow Workflow Framework
Build stateful Rust workflows that can pause for input and resume later.
- Source repo
- a-agmon/rs-graph-llm
- Stars
- ★ 390
- Last updated
- 1mo ago
- License
- MIT
- Primary language
- Rust
- FA score
- 59/100 · Major gaps
At a glance
- How it runs
- 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
- 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
- Source review
- 59/100 · Major gaps
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.
- Rust service developers building resumable LLM-driven claim intake, classification, review, and human approval flows.
- Interactive applications that need to run one workflow step per request, return a result, and resume the session on a later request.
- Applications that route work to different tasks based on classifications or business data in
Context. - Developers who need to run several child tasks concurrently and aggregate their outputs into shared context.
- 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?
- Provides a clear, typed Rust workflow interface through
Task,Context,GraphBuilder, andNextAction. FlowRunnerand 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
rigfeature connects context chat history to RigMessage, and the claims example demonstrates human review.
- 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 usesrig-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?
Why each dimension lost points
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).
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).
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).
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).
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).
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).
- 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.
FAQ
Can I use it without an LLM integration?
graph-flow crate provides graph execution and session management; Rig message integration is an optional rig feature.Can sessions resume after a process restart?
PostgresSessionStorage for persisted sessions. InMemorySessionStorage is suitable for development but keeps data in memory.What happens if two runs update the same session?
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?
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?
Is graph-flow Workflow Framework free?
Is graph-flow Workflow Framework open source?
Is graph-flow Workflow Framework safe to use?
Is graph-flow Workflow Framework still maintained?
Who makes graph-flow Workflow Framework?
Thanks — we use this to improve the page.