The harness is open. The code it creates is yours.

The runtime that executes every Pipechat pipeline is open source under the AGPL 3.0 — and it ships inside every project you download. Blocks, graph wiring, extraction rules, and the harness that runs them come out as a plain Python project that works on your machine with or without us.

NO PARTS MISSING

Every pipeline is already a Python project.

There is no export step that flattens or approximates what the canvas does. The graph is this project: each block is a module with a run(payload, context) function, the connections are a list of pairs, and the runtime walks them in dependency order.

Press download and you get all of it — blocks and their configuration, the extraction rules for each source and the captured evidence they were validated against, a lockfile, a Dockerfile, and the harness itself.

The visual editor is not in the box. Nothing else is held back.

Desktop app Coming soon

competitor-prices.zip 14 files

competitor-prices/

blocks/

collect_pages/

block.py

config.json

enrich_company/

block.py

pipeline_runtime/AGPL 3.0

orchestration.py

connections.py

context.py

External_Sources/

rules and evidence

run_pipeline.py

requirements.txt

pyproject.toml

Dockerfile

README.md

pipeline_runtime/ is the open-source harness. It is included in every downloaded project and runs independently of Pipechat hosting.

orchestration.pyconnections.pycontext.py

# pipeline_runtime/orchestration.py — the entire scheduler.

async def execute_pipeline(initial_input=None, *, run_id=None, on_snapshot=None):
    context = PipelineContext.create(run_id or str(uuid.uuid4()))
    parents = {b: [s for s, t in CONNECTIONS if t == b] for b in BLOCKS}
    values, pending = {}, set(BLOCKS)

    while pending:
        ready = [b for b in BLOCKS
                 if b in pending and all(p in values for p in parents[b])]
        if not ready:
            raise RuntimeError(f"graph contains a cycle: {sorted(pending)}")

        for block in ready:
            module = importlib.import_module(f"blocks.{block}.block")
            values[block] = module.run(payload, context)
            pending.remove(block)
            if on_snapshot:
                on_snapshot({"block_id": block, "status": "succeeded", ...})

    # Nothing else. No daemon, no queue, no callback to us.
    return {b: values[b] for b in sinks}

AGPL 3.0 · THREE FILES

Small enough to read in an afternoon.

The harness is pipeline_runtime/. It has one dependency, needs Python 3.11 or later, and does not talk to Pipechat at any point.

connections.pyThe graph as plain data — which blocks exist and which output feeds which input. Generated, and readable.
context.pyThe run context and the record helpers your blocks import. Roughly forty lines.
orchestration.pyExecution. Blocks run in dependency order, and each one's input, output, duration, and error are captured as a snapshot — the same evidence the run history shows you.
run_pipeline.pyThe entry point: python run_pipeline.py --input input.json. Add --snapshots for newline-delimited per-block records.

THE PIPE HARNESS

The thing that builds your pipeline is a harness, not a chat box.

Pipe Harness is the agent that runs behind the builder in the main workflow area. It has the same shape as the coding harnesses you already know — Pi, opencode — a model, a working directory, and a fixed set of tools. Here the working directory is your pipeline's Python project, and the tools know what a pipeline is.

It does not describe a change and leave you to make it. add_pipeline_block, connect_pipeline_blocks, and a write to blocks/<id>/block.py move the canvas, the code, and the stored graph together, so the picture and the project never drift apart.

It reads before it guesses. get_recent_runs, get_block_output, and get_source_build_events let it open the run that went wrong and look at the records a block actually received, rather than asking you what happened.

It runs on your own provider key, and every file it writes is a file in the project you can download and run without us.

What the harness can change

pipe harness · competitor-prices your key

model: gpt-5.3-codex · your provider, your key
cwd: pipelines/competitor-prices
tools: readwriteeditls get_pipelineadd_pipeline_blockconnect_pipeline_blocksbuild_external_sourceget_recent_runsget_block_output

track competitor prices every morning

get_pipelineempty graph

propose_external_source2 urls · your call

both look right

build_external_sourcerules + evidence

add_pipeline_blockenrich_company

writeblocks/enrich_company/block.py

connect_pipeline_blocks3 edges

get_recent_runs412 rows · 10.4s

Built on the open pi-coding-agent harness, with the pipeline tools added on top.

GNU AGPL 3.0

Copyleft, so the harness stays open for everyone downstream.

We chose the AGPL rather than a permissive licence for one reason: a runtime people depend on should not be quietly closed by whoever forks it next. Use it, change it, run it in production, build a business on the pipelines it executes. If you improve the harness and offer that modified version to other people — shipped or hosted — the AGPL asks you to make your version's source available to them on the same terms.

Running your own pipelines for your own organisation is not offering the harness to anyone, and carries no obligation at all.

Run it Anywhere, indefinitely, for any purpose including commercial work. No key check and no expiry — the copy you downloaded is a copy you keep. No conditions

Change it Fork the harness, rewrite the scheduler, strip what you do not need. Private modifications you never hand to anyone else stay private. No conditions

Redistribute or host a modified harness Ship your version, or run it as a service other people use, and those users are entitled to your version's source under the AGPL. Share alike

DETAILS

Frequently Asked Questions

Where is the repository?: The harness lives at github.com/pipechat-ai. You do not have to clone anything to read it, though — the same source ships inside pipeline_runtime/ in every project you download, licence text included.
Is the whole product open source?: No, and we would rather say so plainly. The harness that executes pipelines is open. The visual builder, the agent that writes your blocks, the managed collection service, and the hosted workspace are not.
Are the blocks it generates mine?: The block code is written for you and belongs to you. It imports the AGPL harness, so if you distribute or host the combined project, treat the whole thing as covered by the AGPL. If that matters to your plans, read the licence with your own counsel.
Does an exported pipeline phone home?: No. The harness has no network code of its own beyond what your blocks do. The only outbound calls are the ones your pipeline makes — fetching pages and calling your model provider with your key.
What happens to my projects if Pipechat disappears?: Every project you downloaded still runs. That is the point of shipping the harness with them rather than keeping it on a server.
Can I contribute?: Yes — issues and pull requests are welcome at github.com/pipechat-ai. Accepted fixes land in the runtime that every newly generated project is built with.

Read it before you trust it.

Build a pipeline, press download, and open pipeline_runtime/orchestration.py. It is the whole of what runs your data.

Create your account