Dev & Engineering multi-agent-orchestrationworkflow-enginefastapicheckpoint-recoverytoken-accountingplugin-systemhuman-in-the-loopdocker

DeterminFlow

A production-oriented AI workflow runtime that runs uncertain LLMs inside versioned, validated, recoverable deterministic workflows.

FollowAgents review · FARS-2.1
Use with care
66/ 100 5-point scale 3.3 / 5
1 2 3 4 5 6
1Trust19 / 29 · 3.3/5

Evidence: README claims per-node tool allowlists, minimal context, approval nodes, token ledgers, and checkpoints; SECURITY.md explicitly states Plugins run as trusted local code inheriting Core process permissions without sandboxing, and gives credential guidance via env vars/Secret Files; tests show token rotation and subject validation. Deductions: all claims are documentation, not visible implementation code; sandbox absence and plugin trust risk are self-acknowledged; external effects (API/DB nodes) lack code-level constraint evidence.

2Reliability8 / 14 · 2.9/5

Evidence: all dependencies exactly pinned with lock files, Docker config check, three CI pipelines (backend/frontend/container); tests show structured error codes (version_changed, authentication_failed, 409 conflicts) and clear messages. Deductions: pyproject version is 0.1.0 while README installers say 1.1.0, an internal version inconsistency; core runtime code is absent from evidence, so failure-message quality is only inferred from tests.

3Adaptability12 / 18 · 3.3/5

Evidence: target audience (production AI workflow developers) and scenarios (novel pipeline, API service, Cron) are clearly described; environment fit covers Windows/macOS/Docker/source with executor-mode fallback, earning full marks. Deductions: trigger semantics (Cron/event inputs) are covered only in passing; capability boundaries are stated in Roadmap and security notes but per-node permission limits remain assertions.

4Convention14 / 18 · 3.9/5

Evidence: clean doc structure (architecture, plugin spec, extension guide), per-platform install notes with version requirements, compatibility aliases (AI_COMPANY_* → DETERMINFLOW_*) documented, honest known limitations (unsigned macOS, manual updates, no sandbox), full AGPL-3.0 text in repo, SECURITY.md with private reporting. Deductions: no CHANGELOG file, internal version contradiction (0.1.0 vs 1.1.0), single unidentified maintainer with only a release badge supporting update cadence.

5Effectiveness9 / 13 · 3.5/5

Evidence: concrete feature comparison against single-agent frameworks, clear differentiated value in node-level resume and per-node billing, cost table with three scenarios. Deductions: the 70%–89% savings are author-estimated against a hypothetical single-agent baseline with no independent corroboration; no execution data validates output usability.

6Verifiability4 / 8 · 2.5/5

Evidence: README labels estimates as estimated and notes pricing timing, showing good fact/inference separation; test files corroborate documented behaviors (marketplace review, token handling, packaging verification) reasonably. Deductions: headline claims (11 sessions, 176,584 tokens, 9.1×) cannot be traced to raw ledger data in the repo; core runtime source is absent from evidence so claims cannot be checked against implementation.

Evidence confidence: Low Reviewed Sep 07, 2026 Reviewed revision 898d1346e379
Before you use it
  • Plugins run as trusted local code with no sandbox; install only trusted sources and follow SECURITY.md advice on a dedicated run account and minimal environment variables.
  • Token savings (70%–89%) are author estimates; benchmark independently before adoption.
  • pyproject version (0.1.0) contradicts installer version (1.1.0); treat GitHub Releases as authoritative and verify the deployed version.
  • The macOS build is ad-hoc signed and not notarized; first launch requires manual approval in Privacy & Security.
  • Publisher is an unverified single maintainer; assess bus-factor and AGPL-3.0 network-service compliance obligations before enterprise use.
See the full review method →

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

DeterminFlow is a production-oriented AI workflow runtime that organizes LLM calls, scripts, APIs, database operations, and human approvals into versioned, validatable, retryable, recoverable, and auditable workflows. Its core components include four Core Node types (Agent, Script, Approval, Subprocess), a visual Workflow Editor, a FastAPI service, a React console, Cron Automation, WebSocket events, and a Plugin mechanism for packaging complete business capabilities. Each Agent node runs in an isolated session that reads only its local context and uses only whitelisted tools; outputs pass through JSON detection, parsing, repair, and targeted retries. Workflow definitions and inputs are frozen at Task start, and every attempt, token spend, artifact, and checkpoint is persisted so execution can resume from the failed node even after a process restart. The runtime is production-proven in the real AI novel pipeline of Bishu Writing; the open-source bishu-novel plugin contains 7 production workflows, 84 orchestration nodes, 33 Agent/Prompt combinations, and 15 reusable script modules, with node-level context isolation measured to save roughly 70%–89% of tokens. The project is licensed under AGPL-3.0 and maintained by alikon-art.

The execution flow: users define versioned workflows (with variables, conditions, parallelism, loops, human approvals, and subprocesses) via the visual Workflow Editor or API; Task start freezes the workflow definition and inputs; each Agent Node runs in its own session with per-node tool whitelist/blacklist, Workspace, and max-turn settings, producing structured JSON; invalid outputs trigger repair, retry, skip, or human escalation, and downstream nodes can reject results to force targeted upstream rework; Script Nodes handle deterministic work like file conversion, API calls, and database writes; every attempt, error, token count, artifact, and checkpoint is saved, so execution continues past process restarts. Delivery surfaces include FastAPI (http://localhost:8020, docs at /docs), the GET /api/plugins endpoint, a React console, Cron Automation, WebSocket events, and health checks; MCP, Agent/Prompt templates, Skills, and Rules serve as reusable assets, and the Core runs independently of any business Plugin.

  1. Teams with well-defined AI pipelines (e.g., multi-writer + validation + persistence) that want to migrate from a single long-context agent to a node-based, resumable runtime
  2. Cost-sensitive product teams that want each model to read only its local context, saving 70%–89% of tokens on real production tasks
  3. Compliance or cost-control scenarios needing per-node tool permissions and per-model-call token accounting and auditing
  4. Teams packaging mature AI workflows as Workflow + Agent + Prompt + Skill + Rule bundles for installation by other teams or the community (Plugin mechanism)
  5. Situations requiring workflows exposed as APIs, managed background processes, Cron Automation, or WebSocket event services

What are this agent's strengths and limitations?

Pros
  • Node-level context isolation with independent sessions delivers roughly 70%–89% token savings versus long-chain single agents, based on a real production token ledger
  • Workflow definitions and inputs are frozen at Task start; checkpoints persist across restarts and execution resumes from the failed node without rerunning completed work
  • Per-node tool whitelists/blacklists, max-turn settings, and failure policies, plus structured output with JSON validation, repair, and targeted rework
  • Production-proven: the Bishu Writing novel pipeline and the open-source bishu-novel plugin (7 workflows, 84 orchestration nodes, 33 Agent/Prompt combos, 15 script modules)
  • Unified console for chat, Workflows, Cron, Skills, Rules, and Plugins, with FastAPI/React/Cron/WebSocket delivery surfaces
Limitations
  • AGPL-3.0 licensing carries copyleft obligations for closed-source commercial integration or network service use—assess before adopting
  • Core value depends on versioned nodes and structured definitions, so migrating existing prompt/skill pipelines to node-based workflows requires real effort
  • Requires self-provided model API keys (example: DeepSeek) plus Python 3.11+ / Node.js 22.12+ / npm; macOS desktop builds are ad-hoc signed, not notarized, need manual approval to open, and currently update only via manual downloads
  • The resource marketplace initially distributes only Skills, the stronger LLM workspace sandbox is still on the Roadmap, and the single-agent comparison token figures are estimates

How do you install or deploy this agent?

Option 1 — Desktop installers: download from GitHub Releases (https://github.com/alikon-art/DeterminFlow/releases/latest) or https://determinflow.com/download; Core builds are DeterminFlow_1.1.0_x64-setup.exe (Windows) and DeterminFlow_1.1.0_aarch64.dmg (macOS Apple Silicon); Full builds pre-install bishu-novel 0.2.2 and public-api 0.1.37; the desktop bundles include the runtime, so no Python, Node.js, or Git is needed. Option 2 — From source (macOS/Linux):

git clone https://github.com/alikon-art/DeterminFlow.git
cd DeterminFlow
python -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements.lock
cp .env.example .env

cp config/models_config.example. config/models_config.

python run.py

On Windows PowerShell, use .\.venv\Scripts\python.exe -m pip install -r requirements.lock and copy .env and models_config. before running run.py. Alternatively, run docker compose up --build. Prerequisites: Python 3.11+, Node.js 22.12+, npm.

How do you use this agent?

After startup, the Web UI is at http://localhost:8020, API docs at http://localhost:8020/docs, and plugin status at GET /api/plugins. On first launch, configure your model API key in the settings page or set DEEPSEEK_API_KEY in .env (model config reads it via ${DEEPSEEK_API_KEY}); you may also opt into the community-provided free models. In the console, use the Workflow Editor to define nodes, variables, and branches and publish a versioned workflow, then trigger Tasks manually, via API/event, or via Cron Automation. During execution you can inspect status and usage at Workflow, Task, Node, attempt, and model-call granularity, and retry, skip, or resume from the failed node on errors. New configuration uses the DETERMINFLOW_* prefix; the community edition runs tasks with 4 local Workflow Executor processes by default—set DETERMINFLOW_WORKFLOW_EXECUTOR_MODE=inline and DETERMINFLOW_WORKFLOW_EXECUTOR_COUNT=1 to fall back to a single process. For Docker, use docker compose up --build. Verification: python -m pytest -q, plus npm run lint, npm run test:extensions, and npm run build in the web directory.

How does this agent compare with similar options?

The README contrasts DeterminFlow with single-agent frameworks like Codex and Claude: those are well suited to exploring unknown problems, but once a process is defined, DeterminFlow's versioned nodes, local context, structured-output validation, failure-node recovery, per-node tool permissions, and node-level token accounting offer a more engineering-friendly path for process changes, context isolation, failure handling, cost auditing, and external delivery.

FAQ

Can it really save 70%–89% of tokens?
The figure comes from a real production task at Bishu Writing (11 independent model sessions, 176,584 tokens total) using the actual token ledger, compared against estimated long-chain single-agent scenarios (595k–1.61M tokens) based on typical context carrying, tool loops, and rework overhead; single-agent figures are estimates, not measurements. Cost conversions use API input token prices at the time of estimation.
What runtime and model credentials are required?
Source deployments need Python 3.11+, Node.js 22.12+, and npm; desktop installers bundle the runtime. Model API keys can be set in the settings page or via DEEPSEEK_API_KEY in .env; free community-provided models are also available.
What happens when a workflow fails?
Automatic retries, manual retries, and skips are supported; execution checkpoints persist across process restarts, so you resume from the failed node without rerunning completed ones. Each Agent Node has its own session and token ledger, outputs get JSON detection, repair, and model retries, and downstream nodes can reject results to force targeted upstream rework.
Are there commercial-use restrictions?
The project uses GNU AGPL v3 (AGPL-3.0-only), which imposes open-source obligations for network-service or closed-source distribution scenarios—do compliance due diligence before commercial adoption. For custom Workflows, Plugins, private deployments, or product integration, contact the author via WeChat (Reactive404) or email.
Where should I start?
Download the desktop Core or Full edition (Full pre-installs bishu-novel 0.2.2 and public-api 0.1.37), or deploy from source/Docker and open the console at localhost:8020; bishu-novel is a pure local-file workflow requiring no database, standalone API service, or migrations.

Compare agents like this one

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

Related agents