Search arXiv⌕ Search

arXiv · 2610.37673

Well-Typed ComfyUI Cannot Go Wrong: Gradual Refinement Types for Generative-AI Workflow Graphs

Abstract

Generative-AI workflows are programs assembled from independently developed models and operators. Their correctness depends on relationships among model families, tensor geometry, control modalities, and quantization levels. In ComfyUI, these relationships can be violated even when every connection is accepted by its validator, causing expensive runtime crashes or silent failures. To measure how often such semantic composition failures occur, we classify all 8,766 issues and 1,368 discussion threads of ComfyUI's GitHub repository with an LLM, checked for cross-model agreement. They account for 8\% of issue reports and 21\% of issue-tracker runtime failures, and 32\% of them are silent. Because execution cannot reliably reveal those failures, we present ComfyTy, a gradual refinement type system that checks component compatibility before execution as a compositional property of workflow graphs. Each node declares a reusable schema that states which model families, sizes, modalities, and quantizations it accepts and produces. Wiring nodes together combines their schemas into constraints, which ComfyTy solves to find and report incompatibilities. To evaluate ComfyTy, we first inject faults into official ComfyUI workflows and execute every resulting graph. ComfyTy detects 66.4\% of the confirmed injected faults, all of which ComfyUI's own validator admits. On real workflows across more model families, it raises no false alarm on 765 known-good workflows and detects 67\% of 108 failures rebuilt from user reports. Finally, in a user study with 10 participants, its diagnostics raise fault-localization accuracy on faulty workflows from 35.0\% to 87.5\% and repair accuracy from 30.0\% to 62.5\%.

Explore related subjects

Keep this discovery

Explore connections, maps & timelines

BibTeXRIS

Pingchuan Ma, Zhantong Xue, Hui Li, Zhaoyu Wang, Yuguang Zhou, Shuai Wang, Xiaoqin Zhang. 2026-10-03. Well-Typed ComfyUI Cannot Go Wrong: Gradual Refinement Types for Generative-AI Workflow Graphs. https://arxiv.org/abs/2610.37673

Cite the original work for its findings. Save a collection to share your selection of sources.

KEEP EXPLORING

Related papers

Automated Verification of Hamiltonian Simulation by Quantum Signal Processing

We present, to the best of our knowledge, the first fully automated verification framework for QSP-based Hamiltonian simulation. Our framework exploits the structure of the simulation algorithm: Hamiltonians are given as weighted sums of Pauli strings, embedded into larger unitaries through block encodings, and transformed into time-evolution operators by quantum signal processing (QSP). Using a symbolic Pauli-sum semantics for ancilla-indexed circuit blocks, our verifier proves that the distinguished all-zero ancilla block is proportional to the target Hamiltonian and infers the subnormalization factor automatically. It then verifies the QSP layer by extracting the implemented polynomial transformation and certifying its approximation error. This structure-aware abstraction is essential for scalability. Composing our verified block encoding and QSP wrapper yields an estimated macro-expanded size of about 1.52 million gates. The verifier certifies the block encoding once and checks the QSP layer through its abstract interface, without expanding the oracle calls. Our implementation verifies block encodings of structured Pauli-sum Hamiltonians with up to 256 system qubits and verifies QSP Hamiltonian-simulation instances by extracting their implemented polynomials and checking the resulting approximation bounds. These results show that fully automated verification can handle common Hamiltonian-simulation circuits at substantial scale when it exploits their algorithmic structure.

cs.PL↗

Countable Nondeterminism in Weighted Programming with an Application to Mechanized Foundations for Probabilistic Program Verification

Weighted programming is a framework by Batz et al. for describing mathematical models or optimization problems as imperative programs parametrized over semirings and then analyzing them with program verification techniques like weakest precondition calculi. Applications include reasoning about expected outcomes of probabilistic programs and competitive analysis of online algorithms. We extend weighted programming with (1) countable nondeterminism and (2) user-defined additive rewards, where programs are parametrized over modules instead of semirings. The resulting framework enables reasoning about expected resource consumption of probabilistic programs and about optimal scores of combinatorial games. A technical challenge is that wp-calculi for weighted programs with (1) and (2) over arbitrary modules can be unsound, because it is well-known that continuity properties commonly used in program semantics break in the presence of countable nondeterminism. We study conditions under which a wp-style transformer for reasoning about weighted programs is sound with respect to an operational ground truth defined in terms of weighted decision processes (WDPs) - transition systems that generalize Markov decision processes by drawing transition weights and state rewards from a module. Based on those conditions, we show that a range of concrete instances of the weighted programming framework enjoy sound weakest precondition reasoning. We demonstrate the usefulness of our wp-semantics through case studies for different modules. We mechanized our extended weighted programming framework and our main soundness results in the interactive theorem prover Lean. Instantiating these results for probabilistic programming yields, to the best of our knowledge, the first mechanized proof of a fixed point characterization of minimal expected rewards in Markov decision processes with countable nondeterminism.

cs.PL↗

A Type System for Communication-Safe Hardware Design

Hardware components communicate through clock-cycle-sensitive protocols. Hardware Description Languages (HDLs), however, provide limited support for expressing these protocols or for checking that independently developed components agree on them. When components disagree, the composed design can perform unsynchronized exchanges or stop making progress. We call these failures communication-safety violations. Communication safety is thus a global property, determined by interactions between components. This makes it difficult to check modularly. This paper presents Pact, a typed extension of Anvil for modular verification of communication safety in synchronous hardware. Pact types describe message-passing, control-flow, and clock-cycle behaviour. Each component is checked against its type. Compatible types guarantee that the components compose into a communication-safe system. Pact also supports incremental design. It can check a subsystem before the rest of the system exists. The check produces a summary type that captures the communication behaviour left for future compositions. To reduce annotation burden, Pact infers types by abstracting payload values while preserving communication, timing, control, and fairness. These inferred types are optimal for the checker: whenever some checker-accepted types can prove compatibility, the inferred types can prove it as well. Type inference and type checking are decidable, and compatibility is decided by a sound and complete algorithm. We implement Pact by extending the Anvil compiler and evaluate it along five dimensions: detecting communication errors in incremental design, expressiveness on ten clock-cycle-accurate translations of open-source hardware IPs, compatibility-checking time, generated hardware overhead, and annotation burden. Pact expresses realistic protocols and verifies all ten benchmarks in reasonable time.

cs.PL↗