Provenance · engineering writeup

Copy that drives action, gated by what you can prove.

How a research swarm on persuasive outreach became a wired, tested Gate — without ever letting the product break its own promise: can’t say what it can’t prove. This page documents the whole loop, from the question to the code that now runs on every line and every message.

✓ full suite: 144 passed 15-agent research swarm 2 Gate axes · 3 validators wired live: /graph · /policies

Step 1 — the research

A 15-agent swarm, then an adversarial fact-check

The question: how do you write personalized copy that drives a customer to act? Rather than answer from memory, a workflow fanned out 7 researchers — one per dimension of action-driving copy — each running real web searches, then pipelined each into an adversarial verifier that downgraded inflated single-vendor stats, then a synthesizer merged the verified findings into a playbook.

7 researchers

personalization · psychology · frameworks · cold-email data · CTA · voice/multichannel · anti-patterns

Adversarial verify

each dimension’s load-bearing claims fact-checked; round-number vendor stats downgraded

Synthesize

one ranked playbook — directions kept, magnitudes flagged illustrative

The robust, cross-source spine

Relevance gates every other lever — a signal you can’t verify reads as spam, and nothing else fires.
One provable trigger, not a merge tag; frame the cost of inaction, not just the upside.
Matched-peer proof with a sharp number; one soft CTA; don’t pitch first; follow up; never sound like a bot.

Honest about the numbers (Constitution Art. I): the principles are cross-source robust; the reply/booking magnitudes are illustrative external benchmarks, not Provenance’s own metrics. The fact-check dropped the inflated “5.2× signal lift” and “287% multichannel” figures as cross-stitched or untraceable.

Step 2 — the insight

The research’s #1 finding is the product thesis

“Relevance you can’t verify reads as spam” is the same sentence as “can’t say what it can’t prove.” So the decision tree runs as two passes on one spine — permission, then action — and the Gate disposes on both.

Axis 1 — Permission · “what may I say?”

Provable identity → personalization Tier 0·1·2·3, governed by say / allude / hold. Deterministic, cheap, itself provable. already wired

Axis 2 — Action · “what makes them act?”

One trigger → loss-frame → matched-peer proof → one soft CTA — the play each tier earns, with the bot-fingerprint stripped. wired this work

The practical fallback you asked for is the spine of both passes: can’t resolve the company → don’t guess a sector; step down the identity ladder to the individual (role/seniority you can prove), then to an honest neutral default. Identity degrades gracefully; it never fabricates upward.

▸ The live decision tree (visualized) ▸ Standalone full tree

Step 3 — the implementation

What got wired into the Gate

The permission router (Pass 1) and the Gate’s provability checks (Axis A) already existed. This work added the action layer (Pass 2) and the persuasion-hygiene axis (Axis B) — at the line, the message, and the sequence scale — and enforced them where outbound copy actually flows.

What	Where (code)	What it does	Status
Loss-frame angle	`creative.ANGLES`	A `loss` cost-of-inaction angle that frames the status quo without inventing a number — provable by construction.	wired
Gate · Axis A	`creative.verify_copy`	Per-line provability: blocks superlatives, comparatives, recited competitors, ungrounded numbers, reciting the company under `allude`.	existing
Gate · Axis B (line)	`creative.verify_copy`	Per-line hygiene: blocks AI-tell phrases/words (delve, leverage, “hope this finds you well”…) and >1 em-dash.	added
Message Gate	`creative.verify_message`	One CTA · ≤125 words (cold) · no cold calendar link · ≤1 link · no spam-promise wording · every line clean. Numbers stay claim-gated, not checked here.	added
Sequence Gate	`creative.verify_sequence`	Never single-touch; no follow-up repeats a prior step verbatim.	added
Action-pool enforcement	`variants.build_action_pool`	A variant now enters the optimizer’s pool only if `claims_cleared AND message_ok`. Provable-but-spammy never ships.	wired
Policy surface	`/policies` · Anti-slop	The message rules publish as a locked, platform-standard card set (grounded in the real thresholds), alongside the AI-tell defaults.	live

The truth boundary held (Art. II). The message Gate is a uniform structural filter on every variant — not a hand-coded exclusion. The planted-lie variant is independently blocked by the claim Gate, and the unconstrained twin still admits it, so the “the bandit would pick the lie if allowed” proof is intact.

Step 4 — verification

Run, not just compiled

Every layer was exercised, and the behavior locked by added tests (existing tests untouched — Art. VII). The message Gate clears all honest variants (the cold meeting-ask is a warning, not a veto) and vetoes the spammy ones:

verify_message() — a spammy cold message

"We're the #1, best-in-class platform — guaranteed.
 Grab time: https://calendly.com/me →   Also reply here →"

✗ blocked  2 CTAs — a message gets exactly one ask
✗ blocked  a calendar link in a cold first touch
✗ blocked  spam-promise wording (“guaranteed”)
✗ blocked  line fails the Gate (unprovable superlative)

an honest variant — ships, with an advisory (not a veto)

"Hi {name}, … A verified cut in total cost of ownership.
 Worth a 20-minute look for {company}? Book a demo →"

✓ ok  words: 26 · one CTA · clean lines
⚑ advisory  cold touch leads with a meeting ask — a soft
            interest question lifts reply  (warns, doesn't block)

Full suite: 144 passed, 0 failed — including the optimizer/drift truth-boundary tests, unchanged.
New, additive tests cover the loss angle, the line/message/sequence Gate, and the locked policy rows.

Step 5 — honest edges (Art. VIII)

Wired vs. policy-on-top

wired Pass-1 permission router · Gate Axis A (provability) · Gate Axis B at line + message + sequence scale · the loss angle · pool enforcement · the /policies anti-slop standard.
policy-on-top the staged CTA escalation (soft → time-ask by lead temperature) and the per-tier play orchestration are a framing layer, not a single wired selector. What’s enforced is the no-cold-calendar veto and the never-single-touch rule; the escalation is the lead-temperature policy above them.

Numbers are deliberately not checked by the message Gate — in outbound copy they’re claim-backed and gated by the NLI claim Gate, so a real “30 EHR systems” ships while a fabricated stat is blocked one layer down.