Gradio Workflow

gr.Workflow is a visual, node-based AI pipeline builder built into Gradio. It lets you chain together Hugging Face Spaces, models, datasets, and your own Python functions on a drag-and-drop canvas. The simplest possible Workflow app is a single line of code: gr.Workflow().launch(). You then open the app, drag Spaces, models, and datasets from the sidebar onto the canvas, connect their ports, and hit Run. The guide describes gr.Workflow as already being a complete Gradio app that must be created at the top level and cannot be nested inside a gr.Blocks context. It is designed for people who want to assemble multi-step AI pipelines visually while keeping their own Python code available as callable nodes on the same canvas. Building an AI pipeline has traditionally meant writing glue code to move data between models and services, downloading weights, and rebuilding the entire pipeline whenever a better model appears. Gradio Workflow is presented as a way around that: pipelines are assembled from nodes on a visual canvas, intermediate inputs and outputs can be inspected, and better models can be swapped in without rebuilding the workflow. Because the nodes call hosted Spaces, models, and datasets, nothing has to be downloaded. The finished pipeline is not locked inside a private session either. It can be shared with a URL or run via a REST API, and its topology is stored in a portable workflow.json file that a coding agent can write or edit, which means workflows can also be created programmatically. On the canvas, a workflow is organized into three node collections, which the guide defines precisely. References are the inputs: uploaded files, editable text, and literal values. Operators are the processing steps: Spaces, models, datasets, and Python functions. Subjects are the outputs, the results being created. As you add, remove, or change nodes and edges, a workflow.json file is automatically created next to the Python script that created the Workflow; you can pass graph= if you want to save it somewhere else. That autosave behavior means the canvas and the file stay in sync without manual export. Node geometry is optional too: include x and y on every node to control how the graph is arranged the first time someone opens it, or leave them out and the canvas auto-arranges the layout instead. Your own Python code becomes part of the pipeline through bind=. Functions passed via bind= appear as callable nodes on the canvas, and Gradio inspects the function signature to auto-generate input and output ports. The guide gives the example of a summarize function that takes a string and returns a string; using a dictionary, for example bind={"My Summarizer": summarize}, gives the node an explicit name. Signature inference is intentionally simple. Parameters annotated as int or float become number ports, bool becomes boolean, and strings, unannotated parameters, and other annotations default to text. Gradio initially generates one output port for each bound function, and any media ports or multiple outputs must be defined explicitly in the workflow JSON. Bound functions can also be wired together in code with edges, a list of (from_fn, to_fn) tuples referring to functions in bind=, using fn_name.port_label to target a specific port when a node has multiple inputs or outputs. The guide notes that edges= only connects bound Python functions while generating a new workflow: it cannot create edges to Space, model, or dataset nodes, it is ignored when the workflow file already exists, and the file must be deleted to regenerate the initial topology. Workflows can also be loaded from disk. Passing a graph= path such as graph="workflow.json" loads a saved workflow topology; the canvas reads from that file on each page load and autosaves back to it whenever nodes or edges change, and if the file does not exist yet it is created on the first authorized edit. The guide is explicit that bind= does not automatically add or wire functions into an existing graph: to combine an existing graph with bound functions you either add the functions from the canvas Functions menu, or include an operator with "kind": "fn" whose "fn" value exactly matches a key passed through bind=. Layout remains flexible for viewers: the file's arrangement is only a starting point, each visitor is free to drag and resize cards, that arrangement is saved in the visitor's own browser rather than in the file, and workflow.json is never rewritten with it. Height is measured from the rendered card, and width is the default every viewer starts from, with a writer's resize becoming the new default the next time an edit is saved. Under the hood, the workflow JSON defines a schema_version, a name, the three node collections, and a list of edges that connect node IDs and port IDs with a stated type. Operators come in four kinds. A space node calls a Gradio Space on the Hub via gradio_client, configured with space_id and endpoint. A model node calls a Hugging Face model via InferenceClient, configured with model_id and a supported endpoint such as text_to_image, while pipeline_tag is also stored for discovery and compatibility with older graphs. A dataset node pulls one row from a Hub dataset per run, selected by the row_index input, configured with dataset_id, dataset_config, and dataset_split. An fn node calls a Python function whose fn value matches a key passed via bind=. Ports are typed so the canvas can validate connections, with support for image, audio, video, text, number, boolean, gallery, file, json, model3d, and any; any is a compatibility fallback that can connect to every port type, and file and any usually come from API schema inference rather than being offered as reference or subject templates in the canvas picker. Pipelines can also fan out: one reference can feed multiple operators simultaneously, and when you run the workflow in the interactive canvas, operators at the same dependency depth run in parallel. The guide adds that when the same workflow is invoked through its generated Gradio API, the server currently executes those branches sequentially. The benefits described in the guide follow directly from this design. Because nodes are wired on a canvas rather than buried in code, intermediate inputs and outputs can be inspected while a pipeline runs, which makes multi-step AI systems easier to debug and reason about. Because each operator is a separate node, a better model can be swapped in without rebuilding the workflow. Nothing needs to be downloaded, since the operators call hosted Spaces, models, and datasets. Shipping is flexible: share links and the ordinary local URL are run-only, while launch() also prints a private write-access URL for editing and saving the workflow, which the guide advises keeping private because edits affect the workflow seen by every visitor. Finally, the workflow.json file is both an autosave artifact and a programmable surface, so the same topology can be authored by hand, by a coding agent, or by bind= and edges= declarations in Python. The guide's fan-out example is a concrete, described workflow: a single product photo reference is fed into four FLUX Kontext branches, showing how one input can drive multiple image transforms at once. Text pipelines are demonstrated in the edges example, where a clean function that strips and lowercases text is wired into a tag function that prefixes the processed text. Model nodes such as black-forest-labs/FLUX.1-schnell with the text_to_image endpoint illustrate text-to-image generation inside a workflow, while dataset nodes make it possible to run a pipeline over a specific row of a Hub dataset, controlled by row_index. Because the same app can be shared with a URL or invoked through a generated Gradio API, the guide frames Workflows both as an interactive canvas for building and inspecting a pipeline and as a deployable app that others can run without editing it. The product is aimed at people building AI pipelines in Python: the guide's code samples are Python throughout, and the canvas is an extension of the Gradio app that the function nodes live in. Integrations called out in the content are the Hugging Face ecosystem, including Spaces on the Hub through gradio_client, models through InferenceClient, and Hub datasets, together with your own Python functions and the generated Gradio API. The relevant technology stack therefore includes Python, Gradio itself, gradio_client, InferenceClient, and REST access to the running app. The guide positions gr.Workflow as part of Gradio's Additional Features, sitting alongside the library's other tutorials and guides, and it must be created at the top level as its own app. No pricing or plan details are stated in the material reviewed here. In short, gr.Workflow brings a visual, node-based editing experience to AI pipelines without taking developers out of Python. You drag Spaces, models, datasets, and your own functions onto a canvas, connect typed ports, and run the result as a Gradio app that can be shared with a URL or called through a REST API. The topology is portable in workflow.json, editable by hand or by a coding agent, and free of downloads because the heavy lifting happens on hosted Hugging Face resources. The primary value proposition is straightforward: build, inspect, and iterate on multi-step AI pipelines visually, and swap in better models without rebuilding the workflow.