Global workflows for LLM agents

ZipperGen is a Python DSL and runtime for multi-agent LLM systems. You write one global protocol: who talks to whom, who calls tools or LLMs, and who owns each decision. ZipperGen projects the protocol into a local program for each participant, runs them durably, shows exactly where each participant is waiting, and deploys the result as a real service.

Coordination deadlocks are ruled out by construction, not by runtime checks.

View on GitHub Read the paper

Studio run inspection showing each participant's position in its projected local program — A blocked run shows exactly where every participant is waiting, in its own projected program.

Global protocols

Write the coordination once: messages, decisions, tools, LLM calls, and human approval points.

Local agents

ZipperGen projects the protocol to one local program per lifeline. Each agent receives only the sends, receives, decisions, and actions it needs.

Durable execution

The projected agents run concurrently against a durable store. A run survives a crash or a closed terminal and resumes where it stopped, and external effects are journaled so they are not repeated.

Deployed as a service

One guided command turns a reviewed workflow into a supervised service with its own durable store, on your machine or an ordinary Linux server. No cluster and no vendor account.

Formal core

The projection is based on Message Sequence Charts and choreographic programming. The core deadlock-freedom theorem is machine-checked in Lean 4. The implementation is on GitHub.

Bollig, Függer, Nowak. Provable Coordination for LLM Agents via Message Sequence Charts. arXiv:2604.17612 [cs.PL]. Accepted at ISoLA 2026.

Bollig. Deadlock-Free Parallel Regions for Projected Workflows. Accepted at EXPRESS/SOS 2026. Preprint forthcoming.

Bollig. Causal Past Logic for Runtime Verification of Distributed LLM Agent Workflows. arXiv:2605.20923 [cs.LO]. Under submission.

Example: branching with an owner

Branching with an owner.

The annotation @ Editor says that Editor owns the decision. ZipperGen generates the control communication needed by the other lifelines.

@workflow
def write_tweet(topic: str @ User) -> str:
    User(topic) >> Writer(topic)
    Writer: tweet = draft(topic)
    Writer(tweet) >> Editor(tweet)
    Editor: approved = approve(tweet)

    if approved @ Editor:
        Editor(tweet) >> User(tweet)
    else:
        Editor(tweet) >> Writer(tweet)
        Writer: tweet = revise(tweet)
        Writer(tweet) >> User(tweet)

    return tweet @ User

Example: command center

Two parallel loops, shared agents.

Calendar, Writer, and User are shared lifelines. ZipperGen's projection ensures each receives exactly the messages it needs from whichever branch generated them.

Full source on GitHub

@workflow
def command_center():
    with parallel:
        with branch:
            email_loop()
        with branch:
            chat_loop()

Runtime guards

Reading causally current state.

Guards can read the latest causally visible state instead of a sequential log. Vector clocks and message-carried views make the guard result depend on the asynchronous communication structure.

latest_device_on = At[Device].on == True

if latest_device_on @ Indicator:
    ...

Run locally

Run the first examples without API keys.

The built-in mock backend returns placeholder model outputs. To use real model calls, set the provider to OpenAI, Mistral, or Claude with one configuration line. ZipperGen also accepts OpenAI-compatible local model servers such as vLLM.

git clone https://github.com/zippergen-io/zippergen.git
cd zippergen
uv sync

uv run zippergen run examples/hello.py:hello --llm mock \
  --input 'topic=Say hello to ZipperGen'

uv run zippergen studio   # guided specification, review, and deployment

Start from the examples.

The README, the tutorial, and the full development and deployment manual are on GitHub.

Get the code About the project