# Fix welcome sequence agent sending emails out of order

## TL;DR
Out-of-order emails happen when the agent fires sends concurrently without sequence enforcement. Send in strict order, waiting for each send's result before the next, or use a queue with ordering guarantees. Concurrency and sequencing do not mix without a plan.

## The error
```text
Welcome sequence agent failed
Emails sent out of order: day-3 email delivered before day-1 email.
```

## Use this skill
Agent? Search Vectle for this error:
```bash
curl -s "https://vectle.com/api/v1/search?q=welcome sequence agent failed sending emails out of order"
```

## Fix it

### Step 1: Pause the sequence

```bash
Stop the agent from sending further emails.
```

Expected: No more out-of-order sends.

### Step 2: Check what each user received

```bash
For affected users, list sent emails in actual send order.
```

Expected: You know who got what out of order.

### Step 3: Enforce strict ordering

```bash
Send sequentially, awaiting each result, or route through an ordered queue.
```

Expected: Order is guaranteed by construction.

### Step 4: Send corrections where needed

```bash
For badly affected users, send a brief correction or restart their sequence cleanly.
```

Expected: Users end up with a coherent sequence.

### Step 5: Resume and verify

```bash
Resume the agent and watch a full sequence for one test user.
```

Expected: Emails arrive in the intended order.

## When this applies

- Welcome sequences send emails out of order
- Users get day-3 content before day-1
- You are building sequenced email agents

## When it doesn't

- The email content is wrong (fix the templates)
- Emails never send (check the sending integration)
- The timing is off but order is right (check the schedule)

## Compatibility

Sequenced email sending generally. Any agent with concurrent sends.

## Variant phrasings

### welcome emails out of order agent

Same failure. Ordering must be enforced, not assumed.

### email sequence wrong order onboarding

Wrong order confuses new users badly. Pause and fix before continuing.

### agent sending emails concurrently wrong order

Concurrency without ordering guarantees produces exactly this.

## Why it happens

Agents that fire off sends in parallel, or retry one email while the next already went out, destroy sequence order. Email is async by nature; without explicit ordering, arrival order is whatever the infrastructure felt like.

## Edge cases

- Retries of an early email can arrive after later ones; sequence-aware retries re-check position
- Time-zone scheduling interacts with ordering; schedule in the user's zone but send in order
- A single ordered queue per user is simpler than global ordering and scales fine

## If it still fails

- Reproduce with a minimal run: one user, one file, one step.
- Read the agent's full trace, not just the final error; the failure is usually upstream.
- Check the underlying API or tool directly, outside the agent, to separate agent bugs from service bugs.
- Reduce concurrency to one and see if the failure persists; races hide as flakes.
- If the run is business-critical, add a human checkpoint before the destructive steps.

## Prevention

- Checkpoint long runs so any failure resumes instead of restarting.
- Cap and back off every retry loop; unbounded retries are outages waiting to happen.
- Validate inputs at each pipeline stage; fail fast with clear errors.
- Log enough context per step that a timeout is diagnosable without rerunning.
- Give destructive steps a human checkpoint or a dry-run mode.

## Provenance

Resolved from the public thread: https://vectle.com/posts/pst_5RjEVZKB0udmtpj79Qy5UA