Introducing Daggr Build AI Workflows in Code, Inspect Them Visually

If you've ever built an AI application that combines multiple models or processing steps, you're familiar with the pain points: chaining API calls, debugging opaque pipelines, and losing track of intermediate results. When something fails at step 5 of a 10-step workflow, you often have to re-run the entire pipeline just to inspect what went wrong.

Developers typically resort to writing fragile scripts that are hard to debug or adopting heavy orchestration platforms designed for production, not rapid experimentation. Daggr, a new open-source library from the Gradio team, aims to solve these exact problems.

Daggr's core philosophy is Code-First. Instead of dragging and dropping nodes in a visual GUI editor, you define your workflow in pure Python. Daggr then automatically generates a visual canvas from your code. This gives you the best of both worlds: version-controllable, programmatic definitions and the intuitive debugging power of a visual interface.

import random
import gradio as gr
from daggr import GradioNode, Graph

# Generate an image using a Gradio Space
image_gen = GradioNode(
    "hf-applications/Z-Image-Turbo",
    api_name="/generate_image",
    inputs={
        "prompt": gr.Textbox(
            label="Prompt",
            value="A cheetah sprints across the grassy savanna.",
            lines=3,
        ),
        "height": 1024,
        "width": 1024,
        "seed": random.random,
    },
    outputs={
        "image": gr.Image(label="Generated Image"),
    },
)

# Remove background using another Gradio Space
bg_remover = GradioNode(
    "hf-applications/background-removal",
    api_name="/image",
    inputs={
        "image": image_gen.image,  # Connect to previous node's output
    },
    outputs={
        "original_image": None,  # Hide this output
        "final_image": gr.Image(label="Final Image"),
    },
)

graph = Graph(
    name="Transparent Background Generator",
    nodes=[image_gen, bg_remover]
)
graph.launch()

Running this script automatically serves a visual canvas on port 7860, complete with a shareable live link. You can modify inputs and inspect outputs at each step directly in the UI.

Daggr supports three primary node types, each serving a distinct purpose in building flexible AI pipelines.

Node Type	Description	Primary Use Case
GradioNode	Calls a public/private Gradio Space API or a locally served Gradio app. With run_locally=True, it clones the Space and runs it in an isolated environment.	Integrating models or demos hosted on Hugging Face Spaces into your workflow.
FnNode	Executes a custom Python function.	Adding custom logic like image resizing, text preprocessing, or data transformation.
InferenceNode	Calls a model via Hugging Face Inference Providers.	Easily accessing various foundation models (FLUX, Kimi, etc.) via API.

The run_locally=True fallback for GradioNode is particularly useful for building resilient workflows. If remote API calls fail, Daggr gracefully switches to a local execution. For a deeper dive, check out the original blog post.

Daggr is currently in beta, intentionally kept lightweight and focused on experimentation. Be aware that APIs may change between versions, and while workflow state is persisted locally, data loss is possible during updates.

Despite its early stage, Daggr's ability to let you define complex AI pipelines in code, visualize them in real-time, and debug interactively has the potential to revolutionize the AI application development process. It's especially promising for research, prototyping, and educational purposes.

Getting started is as simple as pip install daggr. The next time you have a project that requires chaining multiple AI models, give Daggr a try. The experience of rerunning individual steps and inspecting intermediate outputs on the generated canvas offers a tangible productivity boost compared to traditional script-based development.