Paid introductions · SalesBuilder

What you get

2 paid introductions, as Referral records
paid[] · Each referred account whose first payment cleared 30 days: the referrer, the call and the plan it took.
open[] · Introductions still in a trial or before their call; none is billed yet.
bill · Accepted introductions times the price.

Connect once: Stripe, Gmail, Google Calendar. How long: Weekly asks; each introduction bills 30 days after its first payment.

Trigger

It runs when you call it, or on any Trigger you set.

TypeScript

await $.Workflow.create({
  verb: 'Referral.deliver',
  trigger: { schedule: 'weekly' }
})

Steps

Your agent does these steps, one row per step; each step’s check is part of its row and its price.

Step	Verb	Returns	Price	Approval
1. Ask five happy customers a week for one introduction	`Referral.ask`	Each ask names the outcome the customer got; a reply with a name becomes a Referral	About 9.8¢	Runs on its own
2. Route each introduced person	`Lead.route`	Who they are, where they work and whether they fit, with the referrer recorded	About 2.8¢	Runs on its own
3. Write to each one within 5 minutes	`Lead.respond`	A first note that names the referrer and offers a call	About 7.4¢	Runs on its own
4. Book the call	`Meeting.book`	A first call at a time both calendars hold free	Free	Runs on its own
5. Brief you before each call	`Deal.brief`	Why they might buy, and what the referrer already told them	About 37¢	Runs on its own
6. Read the first payment past the refund window	`Collection.query`	Each referred account `paid` when its first payment cleared and no refund followed in 30 days	Free	Runs on its own

Calls: Referral.ask, then Lead.route, then Lead.respond, then Meeting.book, then Deal.brief, then Collection.query.

About 57¢ per 2 paid introductions, each time it runs, capped at $2.00. Its own steps cost nothing; the compositions it orders add 57¢.

How it runs	What it says
Ask only customers past their first outcome	An ask names the outcome the customer got. A customer with no outcome yet, or an open issue, is never asked.
Price it against what a customer is worth	A $149-a-month customer is worth the $795 CAC that plan can afford. $200 is 25% of that, billed only after the first payment clears 30 days.
A name is not an introduction that pays	Introductions, calls and trials bill nothing. Only a first payment that clears the refund window does.

Example: give it a goal

Get introductions from my customers this month, $200 for each one that pays and stays 30 days, and show me the plan first.

The plan it shows runs 6 steps, priced before it spends anything; Run it above shows the result it returns.

When something fails

Each failure, and what happens next

When	Then
A customer has an open support conversation	They are not asked that week; the ask goes to the next customer on the list.
An introduction asks not to be contacted	The person is suppressed at once, and the referrer is thanked without a follow-up.
A referred account refunds inside 30 days	Nothing bills, and the reason is written to the Referral.

Each step retries three times, then falls through to the next route; one item's failure lands in skipped with its reason, never failing the call. Before a step would cross maxCost it stops and returns what it has, with a resume link. Each step's idempotency key is the call's key plus the step and the item: leaseline-referral-deliver-1-<step>-<item>.

What it promises

Term	This Service
Done	An account a customer introduced pays its first invoice, and no refund follows in 30 days.
Counted by	`Referral.delivered`
Billed	$200 a paid introduction, on acceptance
Target	Every introduction the month’s asks bring.
Accepted when	The first payment clearing 30 days with no refund accepts it.
Credited	A referred account that refunds or disputes its first payment inside 30 days.
Remedy	An introduction that never pays bills nothing; the referrer still gets a thank-you note.
Evaluator	Code reads the Referral’s referrer and the referred account’s first invoice and any refund from Stripe.
Window	The calendar month for the asks; each introduction counts when its first payment clears 30 days.
Assurance	`measured`
Oversight	`none`: agents and code do every step

You pay $200 for each paid introduction you accept. Behind it, the agents spend about 57¢ in calls for 2 paid introductions, never more than $2, shown beside your bill. That spend is inside the $200: you are billed for accepted units only, never for the calls.

March: 20 Leaseline customers asked, 5 a week.

Count	What happened
7	Ordered
7	Introductions, each routed and answered within 5 minutes.
4	First calls held; 3 introductions were not a fit or went quiet.
2	Paid, and cleared the 30-day refund window.
1	Still in a trial: it bills in April if it pays.
2	Accepted and billed: 2 × $200 = $400

Change it

Ask	Compiles to
Offer a month free for each introduction that pays.	`Referral.ask`
Ask ten customers a week instead of five.	`Referral.deliver`
Brief me two hours before each referred call.	`Deal.brief`

TypeScript

import { $, Service } from 'startup-builder'

export default Service({
  name: 'referral-deliver',
  verb: 'Referral.deliver',
  input: { take: 'integer', offer: 'string', calendar: 'string' },
  maxCost: 2,
  // each one's cost rolls up into this call
  orders: ['Referral.ask', 'Lead.route', 'Lead.respond', 'Deal.brief'],
  oversight: { posture: 'none' },
  contract: {
    done: 'Referral.delivered', accept: {
      after: 'first-payment',
      window: '30d',
      refund: 'none'
    }, assurance: 'measured',
    bills: { usd: 200, per: 'paid introduction' }, credits: ['refund-within-30d'], remedy: 'never-bill-unpaid',
  },
  execute: async (ctx, { take = 5, offer }) => {
    await ctx.every('1w', ($) => $.Referral.ask({ take, offer }))
    on.Referral.created(async (referral, $) => {
      const lead = await $.Lead.route({
        lead: referral.lead,
        source: referral.$id
      })
      await $.Lead.respond({ lead: lead.$id, within: '5m' })
    })
  },
})

Extend it with extends: 'Referral.deliver' and base(), or compose your own from these steps.

Works with

Plays that order it: customer referrals.

Orders	Kind	Runs, each at its own price	Rolls up
Referral ask	Agent task	4 × About 2.4¢ per 5 asks	About 9.8¢
Inbound routing	Workflow	7 × About 0.4¢ an inbound	About 2.8¢
Answer every inbound	Agent task	7 × About 1.1¢ an inbound	About 7.4¢
Account brief	Agent task	4 × About 9.3¢ a brief	About 37¢

It serves Keep and grow customers. It deepens Retention.

For agents

For agents: the guide, its approvals, retries and lookups

Fact	Value
Guide	`Referral.deliver`
Guide approval	None.
Goal	Get introductions from my customers this month, $200 for each one that pays and stays 30 days, and show me the plan first. It may change counts, the order of steps, soft filters and the route a read takes, and it stops early when the goal is met. It never relaxes your words, raises its own budget, answers its own approval, calls a Play or acts outside your standing approval.
Retry	Three times with backoff, then the next route; the same idempotency key never charges, sends or posts twice
Idempotency key	`leaseline-referral-deliver-1`
Lookups	A `find:` input asks unless exactly one record fits

Nothing here waits for you: every step reads, or writes only your own records, up to the $2 cap.

Who does each step, and how it is checked

Step	Function	Doer	Checker	Assurance	Inputs
1. Ask five happy customers a week for one introduction, by Referral ask	`agentic`	The CSM agent	A second model checks each ask: the outcome is theirs and true, and the reward matches the Policy	`graded`	`$0.take, $0.offer`
2. Route each introduced person, by Inbound routing	`code`	Code	A `Lead.routed` read-back carrying the fit and the referrer	`measured`	`$1.referrals`
3. Write to each one within 5 minutes, by Answer every inbound	`agentic`	The AE agent	A second model checks each answer against your approved pages; code times it from the introduction	`graded`	`$2.leads`
4. Book the call	`code`	Code	A `Meeting.booked` read-back from both calendars	`measured`	`$3.accepted, $0.calendar`
5. Brief you before each call, by Account brief	`agentic`	The AE agent	A second model checks each fact in the brief against its source	`graded`	`$4.meetings`
6. Read the first payment past the refund window	`code`	Code	Code reads the first invoice and any refund from Stripe at day 30	`measured`	`$5.deals`

The CSM agent does step 1; Code does steps 2, 4 and 6; and the AE agent does steps 3 and 5. A second model checks the 3 graded steps, never the one that wrote it, so the whole call is graded.

Under the hood

Under the hood: the Systems, Nouns and Events it touches

Kind	What it touches
Systems	Scheduling
Nouns	Referral, Lead, Meeting, Deal, Collection
Events	`Meeting.booked`, `Collection.queried`

Reference

Inputs, outputs, its Event and its errors

Name	Type	Default	Meaning
`take`	`integer`	`5`	Customers asked for one introduction a week.
`offer`	`string`	Required	What the referrer gets, from your referral Policy, if anything.
`calendar`	`Calendar`	`your connected calendar`	Where the first calls are booked, in the hours you set.

Emits one Event named for its Verb. Refuses with max-cost before it spends, and with the Data calls and Accounts groups (refusals).

What you getCopy Anchor Link

TriggerCopy Anchor Link

StepsCopy Anchor Link

Example: give it a goalCopy Anchor Link

When something failsCopy Anchor Link

What it promisesCopy Anchor Link

Change itCopy Anchor Link

Works withCopy Anchor Link

For agentsCopy Anchor Link

Under the hoodCopy Anchor Link

ReferenceCopy Anchor Link

Contents