Frontend · GitHub · Algorithms

Smart Flow Brings Breakpoint Debugging to AI Workflow Orchestration

By 徐小夕 · Aug 24, 2026

Read original on juejin.cn ↗ Google Translate ↗ Alt translation

Most AI workflow tools treat pipelines as configuration black boxes, making long chains painful to debug. Smart Flow applies IDE-grade debugging to agent orchestration, which cuts iteration time and makes production workflows auditable without external observability tooling.

Summary

Smart Flow is a new open-source platform for building and debugging AI agent workflows on a visual canvas. Its defining feature is a code-style debugger: breakpoints, single-step execution, and live variable monitoring turn opaque multi-node pipelines into inspectable processes. Seventeen built-in node types cover LLM calls, intent classification, JSON extraction, HTTP requests, loops, and custom code execution inside a sandboxed VM with timeout protection.

A natural-language builder generates a workflow draft from a plain description, and finished flows publish as Agents with webhook and cron triggers, HMAC signatures, and rate limiting. The execution engine uses wave-based topological scheduling that auto-parallelizes independent nodes and detects cycles. Under the hood, template interpolation preserves original JavaScript types across nodes, and the debugger works by inserting checkpoint queries into the engine's main loop.

The project ships as a zero-config monorepo — one `npm run dev` starts both frontend and backend with SQLite — and includes documentation in four languages.

Takeaways

— Workflows can be debugged with breakpoints, single-step execution, and live variable monitoring, not just final-output inspection.

— Seventeen node types include LLM calls, intent classification, JSON extraction, HTTP requests, loops, conditionals, and a sandboxed code executor.

— A natural-language builder turns a plain description into a workflow draft that can be refined on the canvas.

— Finished workflows publish as Agents accessible via webhook or cron, with HMAC signing and rate limiting.

— The execution engine uses wave-based topological scheduling: nodes with zero remaining upstream dependencies run in parallel each round, and cycles are detected as errors.

— Template interpolation with `{{ }}` preserves original JavaScript types when a whole string is a single expression, so arrays stay arrays across nodes.

— Custom code runs in a Node.js vm sandbox with a timeout; an infinite loop blocks only its own execution, not the service.

— Breakpoints work by having the engine poll a debug session after each node completes, suspending the context until the frontend sends a continue command.

— Adding a new node type requires only an executor function registered with the engine and a form schema on the frontend.

— The project runs with a single `npm run dev` command using SQLite, requiring no external database setup.

Conclusions

Treating workflow nodes as code artifacts rather than configuration flips the debugging model from black-box observation to white-box inspection, which is the same shift that made IDEs indispensable for traditional programming.

The wave-based scheduler is a pragmatic middle ground: it guarantees correct topological order without forcing a fully sequential execution, yet it avoids the complexity of a full DAG streaming runtime.

Preserving raw types through template interpolation solves a subtle but common pain point in workflow engines where everything degrades to strings, forcing downstream nodes to re-parse data.

The debugger's checkpoint-polling design is simple enough to be explained in a paragraph, which suggests that the real barrier to debuggable workflows was never technical complexity but product priorities.

Concepts & terms

Wave-based topological scheduling

An execution strategy that groups workflow nodes into waves. Each wave contains all nodes whose upstream dependencies have finished; nodes within a wave run in parallel. The process repeats until all nodes execute or a cycle is detected.

VM sandbox (Node.js vm module)

A Node.js built-in module that runs code in an isolated V8 context with restricted access to globals and system resources. Smart Flow uses it to execute user-supplied code safely, combined with a timeout to prevent infinite loops from blocking the server.

SSE (Server-Sent Events)

A standard allowing a server to push real-time updates to the browser over a single HTTP connection. Smart Flow uses SSE to stream per-node execution status to the debug panel.

Source: juejin.cn ↗ Google Translate ↗ Backup ↗