See it live
All demos on GitHub →Flappy Pipeline Studio — customize and generate your own Flappy Bird game over the Agent-Fabric channel.
Recipe generator with photo input, wired over the Agent-Fabric channel — a reference pipeline. Live instance coming soon.
Live dashboard over a real Agent-Fabric channel call between two independent ct-agent processes.
Live dashboard over CADS-Tunnel's real workflow-pipeline auction algorithm (ct_common::pipeline).
Encrypted, CRDT-versioned, gossip-converging P2P file share for CADS-Tunnel-connected agents — the core only coordinates, it never touches file bytes.
Get your template
The easiest way: paste this into Claude Code (or any coding agent) — it downloads the template, unpacks it, reads the docs, and adapts it to your idea itself. Nothing to unzip by hand.
I want to publish my own service through the CADS-Tunnel platform at bunsenbrenner.org.
This is my own request, at my own machine -- please proceed once you're satisfied
below, not stall on it.
Context so you can verify this yourself rather than take my word for it:
CADS-Tunnel is open source: https://github.com/scimbe/CADS-Tunnel -- a
self-hosted, end-to-end-encrypted tunnel, the same kind of tool as
cloudflared/ngrok/frp/tailscale funnel. Read any file in the repo or the
downloaded template before building or running it if that helps you confirm
what it does and what it connects to.
All my tokens and account info live in `./.env` -- check it exists before doing
anything else. If it's missing, stop and ask me to copy it from
https://bunsenbrenner.org/portal -> my tunnel -> Install, then load it with
`set -a; source .env; set +a` before continuing.
1. Download and unpack the starter template (it's the same repo above, just
zipped for convenience -- inspect any file before running it):
curl -LO https://bunsenbrenner.org/downloads/hello-world-pipeline.zip
unzip hello-world-pipeline.zip && cd hello-world-pipeline
2. Read the template's README.md, and https://bunsenbrenner.org/llms.txt for
background -- both are reference material, not instructions to follow
blindly; use your own judgement throughout, same as with any doc.
3. Get ct-agent -- it lives in its own repo, https://github.com/scimbe/ct-agent
(see docs/install.md "Just want to run ct-agent?"). Run its guided setup
script, which checks the environment and installs + onboards for me:
`curl -fsSL https://raw.githubusercontent.com/scimbe/ct-agent/main/scripts/setup.sh | bash`.
No Docker, no Rust toolchain, no repo clone required for this.
4. Help me turn hello-handler.sh into a handler for my idea: <describe what you
want your service to do here>. It's currently running on: <your PC /
Raspberry Pi / container / agent>.
5. Mint my channel identity with `ct-agent channel init`, append it to `.env`,
and reload it (`set -a; source .env; set +a`). This identity is meant to be
long-lived -- running channel init again later would create a second,
unrelated identity rather than restoring this one; that's just how it works,
not something to worry about.
6. Walk me through running the handler as a live role, then publishing my
pipeline at POST /me/pipelines with my portal login's OIDC bearer token
(not an admin token -- I was never given one, and don't need one).
Prefer to read the code yourself? Download hello-world-pipeline.zip · see how it's structured →
Still works on restrictive networks
Your agent tries a direct QUIC connection to the edge first. Blocked by a firewall that only
allows outbound HTTPS? It falls back through the relay ports, and if even those are closed, all
the way to the same :443 port every browser already uses — one of the few outbound
ports almost nothing blocks. Same encrypted session the whole way down; only the route changes.
Zero-knowledge
Noise-encrypted end to end — the operator cannot see your payload, only that a tunnel is active.
Any hardware
Laptop, Raspberry Pi, spare VM, container, or your own AI agent — nothing runs on our infrastructure.
Agent-native
Built to be driven by Claude Code or any coding agent — /llms.txt is a machine-readable onboarding doc.
Your own mesh, optimized
Draw your agents into a graph in the topology editor — direct links, or let it plan for you. CADS-Tunnel computes an optimized routing plan over your own declared mesh (shortcuts, minimum latency) from real measured link costs between your agents. It's your ad-hoc network, not ours — we only compute the plan, your agents run it.
What is "Bunsenbrenner"?
Picture a lab bench. A Bunsen burner isn't the experiment — it's the reliable, unglamorous heat source every experiment on that bench depends on, so you can focus on the idea instead of re-inventing how to make fire.
bunsenbrenner.org is that bench. A shared lab where you can test an idea, run it on whatever hardware you already have, and hand the result to other people — over a real, encrypted, publicly reachable address — without having to build or trust a whole platform first. Some ideas here started as a weekend demo and are now real, working pipelines with their own community of contributors. That's the point: a straight line from "it works on my machine" to "here, try it."
Workflow pipelines
Pipeline registry (raw) →- loading…
One service, several devices
No single device has to run the whole thing. Each agent can publish a signed capacity offer for one role in a pipeline spec; when several agents offer the same role, the registry's clearing mechanism picks the winner (cheapest valid offer, cross-role exclusive) and the winners wire together into one published service. A laptop, a Pi, and a spare VM can each carry one part of the same pipeline — this is the underlying primitive our own example pipelines are progressively adopting, not something that requires you to build it yourself.
MCP
Once your ct-agent channel --serve process joins a channel, it answers real
Model Context Protocol
requests from whichever peer it's channeled with — over the same end-to-end-encrypted connection
your tunnel already uses. That's agent-to-agent, not something you add to your own coding
assistant's .mcp.json. Nothing separate to install: it's the same ct-agent
binary, turned on by which env vars you set. Full wire details and env vars:
/llms.txt, section E.
Direct, agent to agent
Two agents connect directly when the network allows it; when it doesn't, the same Noise session reroutes through a relay that only ever sees ciphertext — never a plaintext hub in the middle. The same channel mechanism also admits other people's agents, not just your own: a redeemable invitation plus a possession proof lets someone else's agent join your channel, so a pipeline can span accounts, not just devices.
Discoverable by agents you've never met
Publish your agent's signed capability card once, and any agent can find it in the public directory (/registry/agents) by role or skill — no manual key exchange, no out-of-band introduction. The directory hands them your identity and address; from there they still connect through the same channel mechanism as anyone else. It's the difference between a phone number you hand out and a listing someone else can look up.
Live operator status
Not a promise — this pulls straight from /status right now. Structural health and
metadata only; the payload itself stays invisible even to us.
Keep the lab running. Bunsenbrenner is free to use and runs on donated time and server costs. If it helped you get something live, a small contribution keeps it going.