# Flows: 151 real email sequences your agent can read

*Published: 2026-09-17*

Most template galleries show you one email at a time. That is the least useful unit. A single welcome email tells you almost nothing about why it worked, because what makes a sequence work is the order, the gaps between sends, and the job each message does at that point in the arc.

So we kept the whole sequence. A flow in Brew is every email one brand sent after a signup or a newsletter subscribe, in order, with the day each one landed. There are 151 of them today, and all of them are readable from code.

## Key takeaways

- A flow is a captured sequence, not a single design: 151 flows, 151 brands, 1,311 emails, each step carrying its subject, preview text, day offset and wait since the last send.
- Remixing rebuilds the graph by arithmetic, not generation. Brew turns the source's gaps into wait nodes to the nearest hour, then rewrites every email for your brand.
- `GET /v1/flows` and the `list_flows` MCP tool return the same records, so an agent can study all 151 sequences without a human clicking anything.
- Every step carries an `emailId` you can pass straight to `create_email_design` as `referenceEmailId`.

## What is in a flow

Zapier's post-signup sequence runs eight emails over 10.7 days:

| Day | Subject |
| --- | --- |
| 0 | Welcome aboard 👋 \| Let's make some magic with AI |
| 1 | Why you should ditch spreadsheets for Tables |
| 2 | Build your first Zap workflow with Copilot ⚡ |
| 3 | What engineers are automating this week |
| 5 | Put AI to work for you |
| 9 | Go beyond workflows 🚀 |
| 10 | Stuck? Or need automation ideas? |
| 10.7 | Your Zapier trial ends in three days ⏲️ |

Read the days, not just the subjects. Four emails land on consecutive mornings, then the gap stretches to two days, then four. The "stuck?" email arrives on day 10 and the trial-expiry email follows seventeen hours later. Somebody decided that the last useful thing before a paywall is an offer of help, and that the two should almost touch.

You cannot see that in a screenshot of one email.

The viewer opens on the first email, which has a wait only after it. Step into the middle, as in the Ro sequence above, and the gap shows on both sides. Ro's welcome flow is a slower shape than Zapier's, 12 emails over 46.7 days, and the gaps say so before you read a single subject line.

![A grid of captured emails from the flows gallery, including Boomi, Canva, Glossgenius, Sentry, Qualys and Aerospike](https://cdn.brew.new/assets/2026/09/brew-flows-gallery-1d538344.png)

Each step carries the subject, the preview text, the day it landed, the wait since the previous send, a category, and a preview image. Ask for it and you get the rendered HTML too.

## What is in the gallery

The corpus is one sequence per brand, so 151 flows means 151 companies:

- **1,311 emails** across the 151 flows, median 9 per flow.
- **132 newsletter cadences and 19 signup sequences.** Most of what brands actually run on a schedule is the newsletter, and the gallery reflects that.
- **Median span 55 days.** The longest is Busuu at 9 emails over 168 days, which is a different genre of pacing from Canva's 4 emails in 9.4 days.
- **59 flows hit the 12-email capture cap**, so roughly two in five of these sequences run longer than the gallery shows.

![The flows gallery in Brew, showing the Zcal, WorkOS, Wiz, Vyond, Virtuagym and Taskade sequences with the email count and span under each brand](https://cdn.brew.new/assets/2026/09/brew-flows-gallery-app-0bc8fc2e.webp)

That sits alongside the single-design gallery, which holds another 4,098 newsletters, 105 welcome emails and 68 promotions. Flows are the part that tells you the order.

## Remixing one

Remixing is the part people expect to be a copy. It isn't.

Brew builds the automation graph first: your trigger, then the source flow's gaps as wait nodes, then one send node per step. That half is arithmetic, not generation. Nobody asks a model to guess that the fourth email goes out on day three.

![A remixed flow open in Brew's automation canvas: a Newsletter Subscribed trigger, a 53-hour wait, a rebuilt email, a 122-hour wait, and the next email, with the email agent writing each step in the side panel](https://cdn.brew.new/assets/2026/09/brew-flow-remix-automation-37722c2c.webp)

Those wait nodes read 53 hours and 122 hours because that is what the source brand sent, rounded to the nearest hour. A whole-day gap stays a whole day, and anything under an hour becomes one. Only the emails are generated, and they are generated in parallel, each one against your brand. Your colors, your fonts, your voice, your product. Each step also gets a brief describing its job in the sequence and what sits on either side of it, because the subagents writing those emails cannot see each other's work and would otherwise produce eight unrelated messages on a shared schedule.

You get a draft automation with the pacing of a sequence a real company has already run, and copy that belongs to you. You still have to read it. The rebrand is good, not finished.

## Reading flows from code

Every flow is available over the REST API and over MCP, so an agent can read the corpus directly.

```bash
# Every flow, newest first
curl "https://brew.new/api/v1/flows" \
  -H "Authorization: Bearer $BREW_API_KEY"

# One sequence, every step
curl "https://brew.new/api/v1/flows?slug=zapier.com" \
  -H "Authorization: Bearer $BREW_API_KEY"
```

Filter by `brand`, `category`, or `type` (`signup` or `newsletter`). Sort by `emails` for the longest sequences, `span` for the ones that run longest, or `remixes` for what other people found worth copying. Pass `semantic` to search by what a sequence is about, which is how you find a trial-expiry win-back without knowing which brand wrote one.

The same read is a tool and a resource on the [Brew MCP server](/mcp):

```
list_flows                        # the tool, same filters and sorts
list_flows { slug: "zapier.com" } # one sequence with every step
brew://flows                      # @-mentionable in a chat
```

In the TypeScript SDK it is `brew.flows.list()`, and from a terminal it is `brew-cli flows list --slug zapier.com`. All four paths hit the same endpoint and return the same records. Flows are organization-wide, so the call takes no brand.

## What an agent does with 151 sequences

Questions that used to be a matter of taste become a query.

Which signup flows put a discount in the first email, and which wait until the trial is nearly over? What do developer tools send on day two? How long do newsletter welcome sequences run before they stop? How many sequences open with a question rather than a benefit? Every one of those is a filter and a loop over `steps[]`, not an afternoon of opening screenshots.

The handoff that makes this training material rather than reading material is the `emailId` on each step. It is the same reference the template gallery uses, and it is exactly what `create_email_design` takes as `referenceEmailId`. So an agent reads the arc, picks the step that matters, and hands that one email to the design tool:

```
list_flows { slug: "zapier.com" }
  → steps[4].emailId = "pt1_k97hmahabyjrp1yfmga8m1rhah8e572q"

create_email_design {
  referenceEmailId: "pt1_k97hmah…",
  prompt: "day-5 activation email for our API product"
}
```

Study the arc, pull the specific email, build your version. No copy-paste in between.

## Two limits worth knowing

Capture keeps at most twelve emails per flow and cuts the tail, so `emailCount: 12` means twelve or more were sent, not exactly twelve. That is the 59 flows above.

Rendered email is bulky. Asking for HTML over MCP gets you the first step or two before the response fills up, and the rest arrive without it. The summary says how many were kept. The REST route has no such cap, so read the flow there when you want every body: `GET /v1/flows?slug=…&include=html`.

## Start here

Open [the gallery](https://brew.new/browse/flows) and read three sequences in your own category before you write anything. Then remix the one whose pacing you would defend to your own team, and change what does not fit.

If you are pointing an agent at this, `list_flows` with no arguments is the right first call. It returns cards with slugs, and the slug is the only thing you need for everything else. The full field list is in the [API reference](https://docs.brew.new/api-reference/public-v1/templates/list-flows).

## Frequently asked questions

### What counts as a flow?

Every email one brand sent after a single signup or newsletter subscribe, in order, with the day each one landed relative to that trigger. One flow per brand, and the flow's slug is the brand's domain.

### Does remixing copy the original emails?

No. Brew copies the structure, meaning the step count, the order and the gaps, reproduced to the nearest hour. Every email is then rebuilt against your brand using the source design as a reference, so the output carries your colors, fonts and voice.

### Do I need an API key to read flows?

Yes for the REST and MCP reads, which use the same `templates.read` capability as `list_templates`. The gallery itself is public and needs no account.

### How many emails does one flow keep?

Up to twelve. Capture keeps the first twelve and cuts the tail, so a flow reporting twelve emails may have run longer. 59 of the 151 published flows sit at that ceiling.

### Can I get the rendered HTML of each email?

Yes, with `include=html` on a single-flow read. Over MCP only the first step or two fit inside one response and the summary tells you how many were kept. The REST route returns every body.