How AI Agents Fixed Our Power Hour Onboarding Automation

The Task Summary

AI agents fixed our Power Hour onboarding automation after a client purchase exposed a broken flow. On June 30, 2026, Ryan White of Social Revelation bought a one-on-one Claude AI Agent Setup session after his Power Hour with Dennis Yu, and hit a dead thank-you page. Dennis asked Ops for a root cause analysis and a repeatable fix, following LDT.

The assignment grew from one broken page into a full overhaul of the Power Hour Fulfillment campaign in Keap and the Basecamp onboarding Zap in Zapier. The offer had changed. The emails had not. The customer-facing sequence still described a consulting hour instead of a Claude AI Agent Setup, said nothing about the Claude Max 20x subscription clients need before the call, and the Zap that should create each client’s Basecamp project had never fired once.

The work ran across multiple sessions in August 2026. A claude.ai chat session acted as the coordinator: it held the email thread history, the change log, and the decisions. Claude for Chrome sessions did the hands-on work inside Keap and Zapier. This article documents both.

Step-by-Step Process

1. Read-only audit. A Chrome agent opened campaign 322 (Power Hour Fulfillment) and the Claude AI Agent Setup Zap and reported status per item without changing anything: a rewritten confirmation email existed but sat in Draft with a “Setup required” flag, the access form was still generic, a legacy email rendered a literal “Missing” merge block, and the Zap was a draft skeleton with unfinished fields.
2. Copy drafted in chat, executed in Chrome. The coordinator session drafted the Claude Max 20x requirement paragraph and the prep checklist. The Chrome agent inserted the paragraph at the end of Step 1b of the Agent Setup Confirmation email and verified the text through the Unlayer design source, not the visual preview. A first insertion attempt through a remote relay did not save; the Chrome session caught the miss by reading the design source and redid it. Verify what saved, not what you typed.
3. QA by test send. Every changed email went to a real inbox before approval. Checks: the new paragraph renders as its own clean paragraph, merge fields resolve to a real name and day, and every button clicks through to the strategy assessment page. A broken button is the exact failure that started this task, so it is the one check that never gets skipped.
4. The second gap. The campaign has two entry branches. Clients who already had their Goals, Content and Targeting (GCT) on file were getting a different email: the old “one POWERful hour of consulting” copy with no Claude content at all. The fix was a parallel email, “Agent Setup Confirmation (GCT on File),” with Step 1 swapped to an optional strategy review.
5. The build method that worked. Keap does not let you copy an email between sequences, drag-and-drop into the Unlayer builder fails for multi-block layouts under automation, and the builder runs in a cross-origin iframe that blocks programmatic design injection. What worked: Save as template on the original email, then load that template into the new email node at the Template step. Pixel-identical copy, native blocks, right sequence. One section swapped, QA test sent, passed.
6. Rewiring the branch. The new email became the branch’s customer email. Endpoint dragging does not work in this builder; delete the old connection, then draw a new one. The legacy email was disconnected but left intact as a rollback path. Nothing deleted.
7. Zap root cause. The handshake check compared what the Zap listens for against what the campaign emits. Result: the campaign applies no tag on purchase anywhere. The only tags in it are internal GCT-form workflow tags. And the Zap’s trigger Tag field was empty; Zapier shows the Configure step as complete because a blank filter is technically valid. The Zap could never have fired for any purchase. The fix: a new tag, Operations -> Power Hour Purchased, applied as the first step in both confirmation branches, and set as the Zap’s trigger tag.
8. Staged, not shipped. Every change was held at Ready. In Keap, Ready means staged; nothing sends until the campaign itself is republished. Both emails, the tag steps, and the Zap ship together on one deliberate publish, followed by a $0 test purchase to watch the full chain: purchase, tag, confirmation email, Basecamp project with a day-to-day contact.

Critical Decision-Making

Copy instead of convert. Keap warns that converting a legacy email to the new builder is one-way. Rather than convert the old GCT-on-File email and rewrite it in place, the agent built a fresh copy in the modern builder and kept the legacy version intact as fallback. The alternative was faster but destroyed the rollback path.

Template clone over hand rebuild. When block-by-block rebuilding failed, the obvious fallback was pasting the whole email as one HTML block. The agent tried Keap’s own Save-as-template feature first and it produced an exact native-block copy. The HTML fallback would have rendered fine but made every future edit a raw-HTML edit.

Hold the republish. Each fix could have shipped as it finished. The agent held everything at Ready so one publish ships a consistent set, because a half-updated campaign sends mismatched emails to real buyers depending on which branch they enter.

Verify in design source, not preview. After one insertion silently failed to save, all content verification moved to the Unlayer design source. The visual preview shows what the editor renders in the moment; the design source shows what is actually stored.

Name the tag inside the existing taxonomy. The new tag follows the campaign’s existing Operations -> prefix convention rather than inventing a new scheme, so the next person (or agent) reading the tag list sees it as native.

Escalate access, never automate it. Every login, OAuth flow, and account reconnect went to the human. The agent navigated to the exact screen and handed off. Slower per step, and the reason nothing in this run touched credentials.

Effort and Cost Comparison

Chrome agent sessions reported step counts as they worked: roughly 900 browser automation steps across the audit, the email builds, the rewiring, and the Zap diagnosis, plus the coordinator session for drafting, QA review, and decisions.

[NEEDS HUMAN: replace token cost estimates with actuals if available; timings are reconstructed from session logs and should be sanity-checked.]

The honest caveat: agent time here includes real dead ends. Two build methods failed before the third worked, and a remote relay path burned time before the work moved to a native Chrome session. The human numbers assume someone who already knows Keap’s builder quirks; a human learning them cold would take longer than the top of the range.

What the Agent Can and Cannot Do

Handled autonomously: the read-only audit and status report, all email copy, inserting and verifying content via design source, the Save-as-template clone, sequence rewiring, QA test sends, the tag-handshake diagnosis, and the change log this article is built from.

Required a human: every login (Keap, Zapier, Gmail), the Zapier account OAuth, approving each change before save and publish, eyeballing QA test emails on desktop and mobile, clicking the buttons in the test email, the final publish decision, and posting updates to Basecamp and email threads (agent drafts, human posts, always).

Hard boundaries hit: Keap’s Unlayer email builder runs in a cross-origin iframe that defeats programmatic design injection and multi-block drag-and-drop. The legacy campaign canvas only opens nodes on pixel-precise double-clicks. Zapier’s dropdown overlays crashed a remote chat-to-Chrome relay repeatedly; native Claude for Chrome sessions handled them fine. These boundaries are part of the SOP now: the next agent reads this and skips the dead ends.

Information Ingestion Inventory

• 1 Gmail thread of 19 messages read in full (the Social Revelation invitation thread), plus roughly 15 related threads scanned for context (meeting assets, client onboarding, access friction)
• 1 Keap campaign read end to end: 2 confirmation branches, GCT goal structure, scheduling and reminder sequences, companion tag campaign
• 2 emails read through design source; 1 legacy email inspected
• 1 Zapier Zap inspected across Setup, Configure, and connection state; 307 Keap tags loaded to verify connection health
• 2 QA test emails reviewed by screenshot
• ~900 browser automation steps across Chrome sessions

[NEEDS HUMAN: total token count across sessions if you want to publish it]

The Final Section (placeholder — fill before publishing)

[NEEDS HUMAN + AGENT: After the single go — Zap published, campaign republished, $0 test purchase — document the observed chain with timestamps: tag applied, which confirmation email arrived, Basecamp project created with day-to-day contact, and the 5-10 minute Keap tag trigger delay. Include a screenshot of the created Basecamp project. If anything failed, document the failure and the fix. Then publish.]

What To Do With This

If you run one-on-one fulfillment through Keap and a project tool, run the same handshake check we did: name the exact signal your automation listens for, then prove your purchase path emits it. Ours did not, and nothing in either tool’s interface said so. The full prompt template this article follows lives at the Meta-Article Prompt, and the system it feeds is documented in Building in Public.