Clone Support
Use case

Lead Enrichment Autopilot: Fill In Missing Contact Details

Hand your clone a list of existing contacts and get it back with domains, titles and best-guess contact details filled in, each with a source URL and confidence score.

The problem

Contact lists are full of blanks: missing domains, titles, emails and phone numbers. Filling them by hand takes minutes per row. This fills the gaps on contacts you already own, safely and traceably, using web research. It does not find new leads.

Lead Enrichment Autopilot: Fill In Missing Contact Details

Version 2.0.0 · Last updated 2026-10-22 · Difficulty: Intermediate · Setup time: 30–60 minutes (plus run time)

You have a list of contacts you already know about (say, 1,000 rows in a spreadsheet) and many are missing a company domain, a job title, an email or a phone number. Your clone cleans the list, researches the gaps on the public web, marks every value with its source URL and how much to trust it, and hands you back the same list with new columns added. It can optionally write the results into Salesforce or HubSpot, filling empty fields only.


1. Overview and value

Contact lists decay. People change jobs, rows get imported with blank columns, and someone pastes a company name where the domain should be. Filling the gaps by hand takes a person several minutes per row.

The Lead Enrichment Autopilot is for enriching contacts you already have. It is not a lead-generation tool: it won't go looking for new people to add to your list. Clone-Lead-Generation-Skill finds NEW leads and doesn't enrich an existing list (see section 10).

When you hand it a list, your clone:

  • reads your Google Sheet or Excel workbook (or a CRM list you export into one) and maps the columns,
  • cleans the data (trims, normalizes, dedupes, derives company domains, flags gaps),
  • picks the strongest identifier for each row (work email, LinkedIn URL, name + domain, or name + company),
  • runs a test batch of 10–25 rows and shows you the results and a credits and time estimate before going further,
  • after your "yes", fills the empty fields with web research (firmographics, titles, LinkedIn URLs, plus best-guess emails and phones, always marked UNVERIFIED with a source URL and a confidence score),
  • gives every value a confidence score (0–100),
  • optionally scores each row against your ideal customer profile (A/B/C tier),
  • appends new columns (value, source, confidence, date) and never overwrites your originals,
  • sends low-confidence and unmatched rows to a Needs Review tab,
  • processes the rest in batches with a progress update after each one,
  • optionally writes back to Salesforce or HubSpot (empty fields only) and optionally builds a repeatable pipeline script with Clone_Code.

Not included: third-party data providers and email or phone verification. Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

Clone-Lead-Generation-Skill finds NEW leads. It doesn't enrich an existing list.

What you get:

BenefitWhat it looks like
Fewer blank fieldsCompany domains, firmographics, public titles and LinkedIn URLs filled where they can be found; best-guess emails and phones clearly marked
Trust you can seeEvery enriched value has a source URL and a 0–100 confidence column
No data lossOriginal columns are never changed; new columns are added to the right
No surprise usageA test batch and a credits and time estimate come first, and the run stops at {CREDIT_BUDGET}
Less repeated workDuplicates are skipped and a lookup cache stops the clone researching the same person or domain twice
Prioritized list (optional)A fit score and A/B/C tier so the best contacts get worked first

2. Who it's for

  • Sales reps and SDRs with a conference list, event export or old account list that's missing domains, titles and contact details.
  • Marketing ops cleaning a list before importing it into Salesforce or HubSpot.
  • RevOps running a periodic data-quality pass on contacts (re-enrich every 90 days).
  • Founders and small teams who want a tidier list without a data subscription.

It works with Salesforce or HubSpot (or no CRM at all), and with Google Sheets or Excel. The examples assume a B2B contact list.

3. How it works

code
 ┌─────────────────────────────────────────────────────────────────────┐
 │  You share {SOURCE_SHEET} (Google Sheet or Excel workbook)          │
 │  and tell the clone which fields to fill: {FIELDS_TO_FILL}          │
 └──────────────────────────────────┬──────────────────────────────────┘
                                    │
                                    ▼
 ┌─────────────────────────────────────────────────────────────────────┐
 │  "Lead Enrichment" skill                                            │
 │                                                                     │
 │  1. Intake           ──►  read the list, map columns (source        │
 │                           untouched)                                │
 │  2. Data hygiene     ──►  normalize, dedupe, validate, derive       │
 │                           domains, flag gaps                        │
 │  3. Match key        ──►  work email > LinkedIn URL >               │
 │                           name + domain > name + company            │
 │        ┌────────────────────────────────────────────────────┐       │
 │        │ TEST BATCH (10–25 rows) + credits and time         │       │
 │        │ estimate ──► you approve ("yes") before full run   │       │
 │        └────────────────────────────────────────────────────┘       │
 │  4. Web research     ──►  cache ► web research (clone), every       │
 │                           value with source URL, UNVERIFIED         │
 │  5. Score            ──►  confidence 0–100 per field                │
 │  6. ICP fit (opt.)   ──►  {ICP_RULES} ──► fit_score + A/B/C tier    │
 │  7. Write to file    ──►  append enr_* columns, never overwrite     │
 │  8. Review           ──►  conf < {CONFIDENCE_THRESHOLD} or no match │
 │                           ──► "Needs Review" tab                    │
 │  9. Delivery         ──►  updated Sheet / .xlsx · optional          │
 │                           Salesforce / HubSpot write-back (empty    │
 │                           fields only) · summary email              │
 │                                                                     │
 │  Runs in batches of {BATCH_SIZE} with a progress update per batch.  │
 │  Stops when {CREDIT_BUDGET} is reached.                             │
 └──────────────────────────────────┬──────────────────────────────────┘
                                    │
 ┌──────────────────────────────────┴──────────────────────────────────┐
 │  ∞ GOVERNANCE (always on): credits cap · {DO_NOT_CONTACT_LIST}      │
 │  honored · GDPR/CCPA · lookup cache · never overwrite ·             │
 │  re-enrich every 90 days                                            │
 └─────────────────────────────────────────────────────────────────────┘

What web research can and can't do

Web research by the clone
Good forCompany domain, industry, size, HQ, public title, LinkedIn URL, company main phone
EmailsBest guess only, e.g. a pattern like first.last@domain inferred from public examples. Always UNVERIFIED
PhonesPublic switchboard / company numbers; direct dials only if published on an official page
TrustEvery value has a source URL and a confidence score; guessed emails are capped low
SpeedA few rows per minute (it reads public pages)
Set upNothing extra

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

Output: what gets added to your sheet

Your original columns stay exactly as they were. The clone adds columns to the right:

ColumnMeaning
enr_<field>The enriched value, e.g. enr_email, enr_phone, enr_title, enr_linkedin_url, enr_company_domain
enr_<field>_sourceWhere it came from, e.g. cache, or web: <source URL> (emails and phones also say UNVERIFIED)
enr_<field>_confConfidence 0–100
enr_statusenriched (all key fields at or above the threshold), partial, needs_review, unmatched, duplicate, do_not_contact, skipped_budget
enr_dateDate the row was enriched (used for the 90-day refresh)
fit_score / fit_tier (optional)0–100 ICP fit and A / B / C

Plus these tabs: Enriched Leads (the full list with new columns), Needs Review (rows a person should check, with the reason), and Run Summary (counts, fill rates, credits and time used). A Lookup Cache tab stores every result so the same person or domain is never researched twice.

4. What the clone does (and what it never does)

It does:

  1. Reads your list through GoogleSheets-Operator or Microsoft_Excel and works on a copy or new tabs.
  2. Cleans names, emails, domains and phone numbers (phones in E.164 format, e.g. +14155550123).
  3. Skips duplicates and anyone on {DO_NOT_CONTACT_LIST} (they are marked, not enriched).
  4. Estimates credits and time first. It runs 10–25 rows, shows you fill rates and credits used, projects the total for the whole list, and waits for your "yes".
  5. Fills only empty fields. If a row already has an email, it doesn't look for one.
  6. Labels everything. Source URL, confidence and date on every value. Guessed emails and phones say UNVERIFIED.
  7. Reports progress after each batch of {BATCH_SIZE} rows and stops cleanly at {CREDIT_BUDGET}.
  8. Optionally writes back to Salesforce (SalesforceContactOperator, SalesforceLeadOperator, SalesforceAccountOperator) or HubSpot (HubspotContactOperator, HubspotCompanyOperator), empty fields only.
  9. Optionally builds a pipeline script with Clone_Code that you can run yourself.

It never:

  • overwrites a value that was already in your list or CRM,
  • emails, calls or messages any contact on the list (this use case only fills data in),
  • runs the full list without an approved credits and time estimate,
  • asks for, accepts or stores API keys, passwords or tokens,
  • enriches people on your do-not-contact or opt-out list,
  • presents a guessed email or phone as verified,
  • adds new people to your list.

Honest limits: the clone can't guarantee coverage. Fill rates depend on your list (work emails and LinkedIn URLs match far better than name + company) and the region. Web research alone will not give you reliable personal emails or mobile numbers.

5. Setup walkthrough

The quickest path: download CLONE-INSTRUCTIONS.md and give it to your clone. It will check what's connected, ask for your settings, show you a plan, and set up what it can after you approve.

Step 0: Connect your accounts and switch the clone on (5 min) This is the most common blocker. Before anything else, connect your Google (or Microsoft 365) account so the clone can reach Sheets/Excel, and make sure the clone is switched on / active in the platform. A clone that's off or has no connected account can't see your sheet, and every step after this will fail.

Step 1: Check requirements (5 min) Open REQUIREMENTS.md and run the pre-flight checklist. You need GoogleSheets-Operator or Microsoft_Excel, and web research.

Step 2: Prepare the list (5–10 min) Make a copy of your list for the test. Make sure there's a header row and at least a name plus a company or email per row. Share the sheet with the clone (edit access). If your list lives in Salesforce or HubSpot, export it to a sheet first.

Step 3: Hand the instructions to your clone (2 min) Paste or upload CLONE-INSTRUCTIONS.md and say: "Please set up this use case for me. Show me a plan before changing anything."

Step 4: Review discovery and answer the placeholder questions (5–10 min) The clone reports what's connected and asks for the values in section 6.

Step 5: Approve the plan (2 min) Say "yes" only when the list of things it will attach and create looks right.

Step 6: Do your part (5–20 min) Share the sheet, give the clone your do-not-contact list, and (if you want write-back) connect Salesforce or HubSpot through the platform's sign-in screen.

Step 7: Run the test batch (10–15 min) The clone enriches 10–25 rows on your copy, shows you the results and a credits and time estimate for the full list. Check a few values yourself.

Step 8: Approve the full run Say "yes" to the estimate. The clone processes the rest in batches and reports after each one.

Step 9 (optional): Schedule a refresh Ask the clone to create a scheduled task that re-enriches rows older than 90 days.

Credits and time estimate

Use the "Credits & time estimator" linked on this card for a live calculation. Every number below is an example you can edit, not a quote. Your real credits per lookup depend on your plan and on how much reading each row needs.

code
unique rows        = total rows × (1 − duplicate rate) − do-not-contact rows
rows to look up    = unique rows × (1 − share already complete) × (1 − cache hit rate)
credits per run    ≈ rows to look up × fields per row × credits per field lookup
batches            = rows to look up ÷ batch size (rounded up)
time               ≈ rows to look up ÷ rows researched per minute

Example inputs (edit them in the estimator):

InputExample value
Total rows1,000
Duplicates10% (so 900 unique rows)
Already complete10% (so 810 rows to look up)
Cache hits (first run)0%
Fields to fill per row3
Credits per field lookup1 (example only)
Rows researched per minuteabout 4
Batch size50 (so 17 batches)
Example resultabout 2,430 credits and about 3.5 hours

The test batch gives you your real fill rate and credits per row; the clone re-runs this math with them before asking for approval.

6. Placeholders to decide

PlaceholderWhat it meansExample / default
{SOURCE_SHEET}The list to enrich: Google Sheet link or Excel workbook"Q3 Event Contacts" Google Sheet, tab "Leads"
{FIELDS_TO_FILL}Which fields to fill when emptyDefault: company domain, title, LinkedIn URL, email, phone
{CREDIT_BUDGET}Max credits per run; the run stops here2,500 credits
{CONFIDENCE_THRESHOLD}Below this, a value goes to Needs ReviewDefault: 60
{ICP_RULES}(Optional) Rules for fit score and tierSoftware or Financial Services, 50–5,000 employees, Director+; A ≥ 75, B ≥ 50
{DO_NOT_CONTACT_LIST}Emails/domains never to enrich (opt-outs, deletion requests, competitors)"Suppression" tab or CRM do-not-contact flag
{BATCH_SIZE}Rows per batch in the full runDefault: 50
{CRM_SYNC}Write results back to a CRM afterwards?no (default), salesforce or hubspot
{SUMMARY_RECIPIENTS}(Optional) Who gets the run summary emailyou@yourcompany.com

Tip: start with {CRM_SYNC} = no. Review the sheet first, then write back once you trust the output.

7. What to expect

  • Test batch: 10–25 rows in roughly 5–15 minutes, then a short report: fields filled, confidence spread, credits used, projected credits and time for the full list.
  • Full run: batches of {BATCH_SIZE}. Web research is the slow part (often a few rows per minute). A 1,000-row list typically takes a few hours.
  • After each batch: a progress message, e.g. "Batch 4/17 done: 200/810 rows, 71% domains filled, 600 credits used of 2,500."
  • At the end: the Enriched Leads, Needs Review and Run Summary tabs, plus an optional summary email to {SUMMARY_RECIPIENTS}.
  • Your part: spend 10–20 minutes on the Needs Review tab. Approve, fix or reject each row.
  • Every 90 days (optional): a scheduled refresh re-checks rows whose enr_date is older than 90 days.

8. Customizing

Fields. Add firmographics (industry, employee count, HQ city, revenue band) or person data (seniority, department) to {FIELDS_TO_FILL}. Web research is good at firmographics.

Confidence threshold. Raise {CONFIDENCE_THRESHOLD} to 70 if you want only well-sourced values written back. Lower it to 50 if you only need research context.

ICP scoring. Rewrite {ICP_RULES} in plain words: points per rule, tier cut-offs. Turn scoring off if you don't need it.

Output location. New tabs in the same sheet (default), a new file, or (only if you ask) new columns in the original tab, always to the right of your data.

CRM write-back. Choose Salesforce or HubSpot. By default only firmographics, titles and LinkedIn URLs are written; guessed emails and phones are written only if you explicitly say so.

Build a repeatable pipeline (Clone_Code). If you enrich lists often, ask the clone to use Clone_Code (its coding skill) to build a small script you can run yourself: read a list, apply the same hygiene, match key and confidence rules, and write the same output columns. Keep any keys out of the code and out of chat.

9. Known gotchas

  • Connect your accounts and switch the clone on first. The most common onboarding blocker. If your Google (or Microsoft) account isn't connected, or the clone isn't switched on / active, it can't open the sheet and setup stalls.
  • This enriches existing contacts. It does not find new leads. Clone-Lead-Generation-Skill finds new people that match a profile; it does not fill in blanks on your list. If you want new prospects, use it first, then run this use case on its output.
  • Web results aren't verified. Pattern-guessed emails (first.last@domain) can bounce. They are always marked UNVERIFIED. Don't load them into a sending tool without verifying them elsewhere.
  • Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.
  • Respect do-not-contact and privacy laws. Under GDPR, CCPA/CPRA and similar laws you need a lawful basis (often legitimate interest, documented) to process personal data, should collect only what you need, and must honor opt-outs and deletion requests. Keep {DO_NOT_CONTACT_LIST} current. This is not legal advice; check with your privacy lead.
  • Batch large lists. Running thousands of rows at once makes mistakes expensive. Batches of 50 with a progress check are safer.
  • Share the sheet with the clone. "Permission denied" almost always means the sheet isn't shared with the clone's account (edit access needed to add tabs).
  • Duplicate rows. The same person often appears twice with different spellings. Duplicates are marked enr_status = duplicate and not researched, but check the hygiene results in the test batch.
  • Phone formats. Phones are normalized to E.164 (+ country code + number). Rows with no country can't be normalized reliably; set a default country if your list is single-country.
  • Use the cache. The Lookup Cache tab stops repeated research for the same person or domain. Don't delete it between runs.
  • Personal emails. A gmail.com or outlook.com address doesn't tell you the company. The clone won't derive a company domain from it.
  • Similar names. Web research can match the wrong person with the same name. Name + company matches are the weakest and get low confidence.
  • Use exact skill/operator names from your catalog. The clone checks them during discovery.
  • Read the skill before you save it. You're responsible for what your clone does.

10. FAQ

I have 1,000 contacts and want emails and phone numbers added. Is this the right use case? Partly. It fills company domains, firmographics, public titles and LinkedIn URLs reasonably well, and adds best-guess emails and company phone numbers marked UNVERIFIED. Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

Will it find new leads for me? No. Clone-Lead-Generation-Skill finds NEW leads and doesn't enrich an existing list. This use case only fills in missing details for contacts already on your list.

Will it overwrite what's already in my sheet or CRM? No. It only fills empty fields, and writes them to new enr_* columns. CRM write-back (if turned on) only fills empty CRM fields.

Will it email the contacts? No. The only email it sends is the optional run summary to {SUMMARY_RECIPIENTS}.

Does it work with Excel instead of Google Sheets? Yes. Use Microsoft_Excel (a workbook in OneDrive) or upload an .xlsx/.csv; the clone returns a workbook with the same tabs.

Which CRMs work? Salesforce (SalesforceContactOperator, SalesforceLeadOperator, SalesforceAccountOperator) and HubSpot (HubspotContactOperator, HubspotCompanyOperator). See REQUIREMENTS.md for the concept mapping.

How accurate is it? Each value carries a confidence score and a source URL so you can decide. Company data from an official site is usually reliable; guessed emails are not. Check the test batch yourself.

How do I know what it used? The Run Summary tab lists lookups, credits and time. Use the "Credits & time estimator" on the card to plan a run.

11. Troubleshooting

SymptomLikely causeFix
Clone says it can't find or open the sheetAccount not connected, clone not switched on, or sheet not sharedConnect Google/Microsoft, switch the clone on, share the sheet with edit access
"Permission denied" when adding tabsView-only sharingGive the clone edit access, or ask for output as a new file
Columns mapped wrongUnusual headersTell the clone the mapping, e.g. "Org = company"
Very low fill rateWeak match keys (name + company only)Add domains or LinkedIn URLs to the list
Lots of UNVERIFIED emailsExpected with web research onlyTreat them as leads to check; verified data needs a paid data provider (optional extra step)
Credits ran out mid-run{CREDIT_BUDGET} reachedRows left are marked skipped_budget; raise the budget, then resume
Web research "unavailable"Tool call failed twiceRetry later; the clone reports which rows were skipped
Same person researched twiceCache tab deleted or rows not dedupedKeep the Lookup Cache tab; check hygiene settings
Phones look wrongNo country column, mixed formatsSet a default country; check E.164 output in the test batch
Contacts on opt-out list were enriched{DO_NOT_CONTACT_LIST} not shared or incompleteShare and update the list; clear those rows' enr_* values
CRM not updated{CRM_SYNC} = no, or CRM connection read-onlyTurn sync on and grant write access to the listed fields only

Version: 2.0.0 · Last updated: 2026-10-22 · Part of the Clone Use Case Library.

Paste these instructions into clone chat

# Clone Instructions: Lead Enrichment Autopilot (Fill In Missing Contact Details)

> **For the clone.** Your user has handed you this file. Follow it step by step.
> **Version 2.0.0 · Last updated 2026-10-22**

---

## 1. Role and goal

You are setting up the **Lead Enrichment Autopilot** use case for your user.

The user has a list of **existing contacts** (for example ~1,000 rows in a Google Sheet or Excel workbook) and wants missing details filled in. This is **not** lead generation: you never add new people to the list. (`Clone-Lead-Generation-Skill` finds NEW leads and doesn't enrich an existing list.)

The method uses supported tools only: **web research** by you (company domain, firmographics, titles, LinkedIn URLs, plus best-guess emails and phones, always marked UNVERIFIED with a source URL and a confidence score), a **Google Sheet or Excel workbook** as the working file, optional **write-back to Salesforce or HubSpot** (empty fields only), and optional **Clone_Code** to build a repeatable pipeline script the user can run themselves.

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

When setup is done, you will run a skill called **Lead Enrichment** that:

1. reads `{SOURCE_SHEET}` and maps its columns,
2. cleans the data (normalize, dedupe, validate, derive domains, flag gaps),
3. picks the strongest match key per row,
4. runs a test batch of 10–25 rows and a credits and time estimate, and waits for approval,
5. fills empty `{FIELDS_TO_FILL}` using the lookup cache, then web research,
6. scores every value 0–100 and records its source URL,
7. optionally scores ICP fit with `{ICP_RULES}`,
8. appends `enr_*` columns without overwriting anything,
9. routes uncertain rows to a Needs Review tab, delivers the results, optionally writes back to the CRM named in `{CRM_SYNC}`, and optionally emails a summary to `{SUMMARY_RECIPIENTS}`.

Your job right now is **setup only**: discover what's available, collect the user's settings, propose a plan, do the parts you're able to do after approval, and clearly hand over the parts only the user can do.

Be honest about your limits. Web research can't verify emails or find reliable mobile numbers. If a tool isn't available or a step fails, say so plainly and give the user the exact manual steps instead.

## 2. Safety rules (read before doing anything)

- **Plan first, then act.** Before you attach, create, schedule, write or use credits on anything, show the user a numbered plan and wait for an explicit "yes". No yes = no changes.
- **Approval is per plan.** If the plan changes, show the new plan and ask again. The full run needs its **own** "yes" after the test batch and the credits and time estimate.
- **Never ask for, accept or handle passwords, API keys or tokens.** Account sign-ins happen in the platform's own connection screen. If the user pastes a key into chat, tell them not to, don't use it, and suggest they rotate it.
- **Never email, call or message customers or prospects.** This use case only fills data in. The only email you send is the optional run summary to `{SUMMARY_RECIPIENTS}`.
- **Never overwrite existing data.** Fill empty fields only, in new `enr_*` columns or new tabs. Never change or delete the user's original values, in the sheet or the CRM.
- **Never run the full list without an approved credits and time estimate.** Stop when `{CREDIT_BUDGET}` is reached.
- **Honor `{DO_NOT_CONTACT_LIST}`.** Never enrich those rows.
- **Never present guessed data as verified.** Emails and phones from web research are UNVERIFIED.
- **Don't guess names.** Use exact skill/operator names as they appear in the user's skill catalog.

## 3. Discovery

First check that the user's Google (or Microsoft 365) account is connected and that you (the clone) are switched on / active. If not, stop and ask the user to do that first; it's the most common blocker.

Then use the platform tool to list your attached skills/operators and connections, and use `describeOperator` on each relevant operator to confirm what it can do and whether its connection is active.

Look for:

| Need | Required? | Exact names to look for |
|---|---|---|
| Working file | **Required** | `GoogleSheets-Operator` (Google Sheets) or `Microsoft_Excel` (Excel workbook); file upload (.xlsx / .csv) also works |
| Web research | **Required** | Your web research tools |
| Salesforce write-back | Optional | `SalesforceContactOperator`, `SalesforceLeadOperator`, `SalesforceAccountOperator` |
| HubSpot write-back | Optional | `HubspotContactOperator`, `HubspotCompanyOperator` |
| Pipeline script | Optional | `Clone_Code` (coding skill) |
| Summary email | Optional | `GoogleGmailOperator` or the Outlook email operator (send) |
| Scheduled task | Optional | Ability to create a recurring task (90-day re-enrichment) |

**Report the results to the user in a table like this:**

| Item | Status | Exact name in catalog | Notes |
|---|---|---|---|
| Account connected + clone switched on | ✅ / ❌ / ❓ | … | … |
| Working file (Sheets / Excel) | ✅ Connected / ⚠️ Attached, not signed in / ❌ Missing | … | … |
| Web research | … | … | … |
| Salesforce or HubSpot (optional) | … | … | List each operator |
| Clone_Code (optional) | … | … | … |
| Summary email (optional) | … | … | … |
| Scheduled task (optional) | … | … | … |

If you can't check something, mark it "❓ Couldn't check" and say why. Tell the user plainly what to expect: best-guess emails and phones marked UNVERIFIED, no reliable direct dials. Don't suggest or name any third-party data provider.

## 4. Collect placeholder values

Ask the user **once**, in a single short list. Offer the defaults.

> To set this up I need a few details:
>
> 1. **List** (`{SOURCE_SHEET}`): Google Sheet link and tab, or Excel workbook. Please share it with me (edit access). If the list is in Salesforce or HubSpot, export it to a sheet first.
> 2. **Fields to fill** (`{FIELDS_TO_FILL}`): *(default: company domain, title, LinkedIn URL, email, phone)*
> 3. **Credit budget per run** (`{CREDIT_BUDGET}`): I stop when it's reached.
> 4. **Confidence threshold** (`{CONFIDENCE_THRESHOLD}`): *(default: 60)*
> 5. **ICP rules** (`{ICP_RULES}`): industries, company size, seniority, regions, tier cut-offs. Or "skip scoring".
> 6. **Do-not-contact list** (`{DO_NOT_CONTACT_LIST}`): tab, file or CRM flag.
> 7. **Batch size** (`{BATCH_SIZE}`): *(default: 50)*
> 8. **CRM write-back** (`{CRM_SYNC}`): `no`, `salesforce` or `hubspot`. *(default: no)*
> 9. **Summary recipients** (`{SUMMARY_RECIPIENTS}`): *(optional; default: you)*

Repeat the answers back in a table and ask the user to confirm.

## 5. What you can do yourself (after approval)

Present a plan like this, filled in with real names from discovery:

> **Proposed plan (nothing changes until you say yes):**
> 1. Attach these skills/operators from the catalog: *[exact names]*.
> 2. Create the **Lead Enrichment** skill using the text in section 7, with your values filled in.
> 3. Make a working copy of `{SOURCE_SHEET}` (or use one you give me) for the test batch.
> 4. Run a test batch of 10–25 rows on the copy, then show you results and a credits and time estimate. **No full run until you approve the estimate.**
> 5. *(Optional)* Create a scheduled task "Lead Enrichment Refresh" that re-enriches rows older than 90 days.
>
> **You'll need to do:** *[list from section 6]*.
>
> Reply **yes** to proceed, or tell me what to change.

After a clear "yes":

1. **Attach skills/operators.** Search the catalog and attach each approved item. Confirm each with `describeOperator`. If one needs a sign-in, it goes on the user's list.
2. **Create the Lead Enrichment skill.** Fill in the confirmed values and save it.
   - **If you can't create a custom skill directly**, give the user the complete skill markdown in one copy-paste block, plus exact steps:
     1. Open your clone's settings → **Skills** (or **Custom skills**).
     2. Click **New skill** / **Add skill**.
     3. Name it exactly **Lead Enrichment**.
     4. Paste the full block into the skill instructions field.
     5. Read it through, then **Save**.
     6. Tell me "saved" so I can verify it's attached.
     (Menu names may differ slightly in your workspace.)
3. **Optional scheduled task.** Name: "Lead Enrichment Refresh". Schedule: weekly or monthly (user's choice). Action: "Run Lead Enrichment on rows of `{SOURCE_SHEET}` where enr_date is older than 90 days, within `{CREDIT_BUDGET}`." Every scheduled run must still respect the budget and stop on it. If you can't create scheduled tasks, give the user these values to create it manually.
4. **Optional `Clone_Code` pipeline.** If the user wants a repeatable pipeline, offer to build a small script with **Clone_Code** as a separate project: it reads a list, applies the same hygiene, match key and confidence rules, and writes the same output columns, and the user runs it themselves. No keys go in code or chat.
5. **Report back** what succeeded and what failed, honestly.

## 6. What the user must do

Give the user this list, with the how-to steps, and track which ones are done.

1. **Connect your Google (or Microsoft 365) account and make sure I'm switched on.** Clone settings → **Connections** → Google / Microsoft → **Connect** → approve Sheets/Drive (or Excel/OneDrive) permissions. Then check that the clone is switched on / active. *Without this I can't open your sheet.*
2. **Share the sheet with me** (edit access), or upload the file. Make a copy for the test batch if you'd rather I don't touch the original at all.
3. **Confirm the do-not-contact list.** Share the tab/file or tell me the CRM field that marks opt-outs. Make sure it's current.
4. **(If `{CRM_SYNC}` is `salesforce` or `hubspot`)** Connect that CRM via Connections → **Connect** → sign in. Ask your CRM admin to grant write access to the fields to be filled only, and to create custom fields for source, confidence and enrichment date.
5. **(Optional) Connect email** (Gmail or Outlook) if you want the summary email.
6. **Check your legal basis.** Confirm with your privacy lead that you can process this personal data (GDPR/CCPA).

## 7. The Lead Enrichment skill (save this in full)

Fill in the placeholders, then save as a skill named **Lead Enrichment**. Don't shorten it.

~~~~markdown
# Lead Enrichment

## Purpose
Fill in missing details (default: company domain, title, LinkedIn URL, email, phone)
for contacts that ALREADY exist in a list. Clean the list, choose the best match key
per row, research the gaps on the public web, score confidence, append results
without overwriting anything, route uncertain rows to review, optionally write empty
CRM fields, and report. Never add new people. Never present a guess as verified.

## Settings
- Source list: {SOURCE_SHEET}
- Fields to fill (only when empty): {FIELDS_TO_FILL}
- Credit budget per run: {CREDIT_BUDGET}
- Confidence threshold: {CONFIDENCE_THRESHOLD}   (default 60)
- ICP rules (optional): {ICP_RULES}
- Do-not-contact list: {DO_NOT_CONTACT_LIST}
- Batch size: {BATCH_SIZE}   (default 50)
- CRM write-back: {CRM_SYNC}   (no | salesforce | hubspot)
- Summary recipients (optional): {SUMMARY_RECIPIENTS}
- Confidence caps: guessed email 40; email or phone published on an official page 60; company main line 70
- Re-enrich after: 90 days

## Tools
Use the exact names from my skill catalog. Use whatever is connected; skip what isn't.

| Purpose | Tool (exact catalog name) | Required | Access |
|---|---|---|---|
| Read the list; write new tabs/columns and cache | GoogleSheets-Operator or Microsoft_Excel | Yes | Read; write ONLY new tabs or new enr_* columns |
| Domains, firmographics, public titles, LinkedIn URLs, email patterns, company phones | Web research | Yes | Read public web |
| Salesforce write-back (if {CRM_SYNC} = salesforce) | SalesforceContactOperator, SalesforceLeadOperator, SalesforceAccountOperator | Optional | Read; write empty fields only |
| HubSpot write-back (if {CRM_SYNC} = hubspot) | HubspotContactOperator, HubspotCompanyOperator | Optional | Read; write empty properties only |
| Repeatable pipeline script | Clone_Code | Optional | Create a script for the user to run |
| Send the run summary | GoogleGmailOperator or Outlook email operator | Optional | Send ONLY to {SUMMARY_RECIPIENTS} |

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

## Guardrails
- Enrich existing rows only. Never add new contacts. (Clone-Lead-Generation-Skill finds NEW leads; this skill does not.)
- Never overwrite: fill empty fields only, in enr_* columns or new tabs. Never edit or delete original values in the sheet or CRM.
- Never email, call or message anyone on the list.
- Skip every row matching {DO_NOT_CONTACT_LIST} (email or domain). Mark enr_status = do_not_contact.
- Collect only the fields in {FIELDS_TO_FILL}. Don't gather personal details beyond what is needed.
- No full run until the user has approved a credits and time estimate for this run. Track credits after every batch; stop before exceeding {CREDIT_BUDGET} and mark remaining rows skipped_budget.
- Check the Lookup Cache before every lookup. Write every result to the cache.
- Every web-derived value needs a source URL. If there is no source, leave the field empty. Never invent values.
- Emails and phones from web research are UNVERIFIED. A pattern-guessed email is never labeled verified and is capped at confidence 40.
- Retry rule: if a tool call fails, retry ONCE. If it fails again, mark that tool "unavailable" for this run, continue with the other rows, and report it.
- Never ask for, accept or handle passwords, API keys or tokens.

## Step 1: Intake
- Open {SOURCE_SHEET}. Do not modify the source tab.
- Map headers to canonical fields: first_name, last_name, full_name, email, company, company_domain (website/URL), title, linkedin_url, phone, country/location. Keep unmapped columns as they are.
- If a needed header is unclear, ask the user once with your best guess.
- Load {DO_NOT_CONTACT_LIST}.
- Count rows. Over 5,000 rows: warn the user and plan more batches.

## Step 2: Data hygiene
In memory (or in clean_* helper columns on the output tab, never the source):
1. Trim whitespace; Title Case names; lowercase emails and domains; strip https://, www. and paths from websites.
2. Validate email format. Malformed emails are treated as missing and flagged.
3. Normalize phones to E.164 (+country code). If no country, use the list's default country if the user gave one; otherwise flag "phone_no_country".
4. Derive company_domain: website column, then email domain (unless free-mail such as gmail.com, outlook.com, yahoo.com), otherwise leave empty for web research to find. Flag guessed domains.
5. Dedupe: same email, or same full name + domain. Keep the first row; mark others enr_status = duplicate with the row they duplicate. Don't enrich duplicates.
6. Mark do-not-contact rows.
7. Flag gaps: which {FIELDS_TO_FILL} are empty per row. Rows with nothing missing are marked "already complete" and skipped.

## Step 3: Match key strategy
For each remaining row pick the strongest identifier available:
1. Work email (best)
2. LinkedIn URL
3. Full name + company domain
4. Full name + company name (weakest; firmographics may match, people often won't)
5. None: enr_status = unmatched, send to review.
Record match_key_type per row. A free-mail email ranks below name + domain.

## Step 4: Test batch and credits and time estimate (approval gate)
1. Pick 10–25 representative rows (mix of match key types). Work on the user's copy.
2. Run Steps 5–8 on them.
3. Report: fields filled per field, confidence distribution, credits used, time taken, and 3–5 sample rows with their source URLs.
4. Estimate the full run (these are estimates, based on the test batch):
   rows_to_look_up = unique rows − already complete − do-not-contact − cache hits
   credits = rows_to_look_up × fields per row × credits per field lookup (use the test batch's real numbers)
   time = rows_to_look_up ÷ rows researched per minute (from the test batch)
   batches = rows_to_look_up ÷ {BATCH_SIZE}, rounded up
   Show estimated credits, estimated time and number of batches. Compare with {CREDIT_BUDGET}. Point the user to the "Credits & time estimator" linked on the library card to try other inputs.
5. Ask: "Proceed with the full run within {CREDIT_BUDGET}? (yes / change settings / stop)". Do nothing more until the user says yes.

## Step 5: Web research
For each row, for each empty field in {FIELDS_TO_FILL}:
1. Lookup Cache: reuse any result for the same email, LinkedIn URL or name + domain that is less than 90 days old (no new research).
2. Web research: company domain, industry, size, HQ, company main phone, public title, LinkedIn URL. For email, look for one published on an official page; otherwise infer the company's email pattern from public examples and build a candidate (guess). For phone, use the company main line unless a direct number is published on an official page.
3. Record each value with its source URL and mark emails and phones UNVERIFIED.
4. If two sources disagree, keep the value with the stronger source and note the conflict.
5. After each batch add its credits to the running total. If the next batch would exceed {CREDIT_BUDGET}, stop.
6. Write each result to the Lookup Cache with the date.

## Step 6: Confidence scoring (0–100)
- Firmographics and titles from an official company page: 80–90. From a third-party page: 60–75.
- LinkedIn URL matching name + company: 70–85. Name-only match: max 50.
- Email published on an official page: max 60. Pattern-guessed email: max 40. Label "UNVERIFIED".
- Phone: company main line from the official site up to 70; direct number published on an official page max 60; otherwise leave empty.
- Add 10 when a second independent source agrees; max 90 for any web value.
- Row status: all filled key fields at or above {CONFIDENCE_THRESHOLD} → enriched; some filled → partial; any filled key field below threshold → needs_review; nothing found → unmatched.

## Step 7: Lead scoring / ICP fit (optional)
- Apply {ICP_RULES} to enriched and original data (industry, size, seniority, region).
- Missing inputs score 0 points; never guess them.
- Output fit_score (0–100), fit_tier (A / B / C) and a short fit_reasons note. Skip unmatched rows. Skip this step if the user said "skip scoring".

## Step 8: Write to the file
Write to a tab named "Enriched Leads" (new tab or the user's copy). Never touch the source tab.
- Original columns first, unchanged, then for each field in {FIELDS_TO_FILL}: enr_<field>, enr_<field>_source (include the source URL; say UNVERIFIED for emails and phones), enr_<field>_conf.
- Then: enr_status, match_key_type, fit_score, fit_tier, fit_reasons (last three only if scoring is on), enr_date (YYYY-MM-DD).
- If a header already exists, keep the enr_ prefix so nothing collides.
- If the user asked for in-place columns, add them to the right of existing data only.

## Step 9: Review and exceptions
Copy to a "Needs Review" tab every row with status needs_review, unmatched or partial below threshold, with: the original data, review_reason (no match / low confidence / guessed email / guessed domain / phone_no_country / conflicting sources), source URLs, and empty reviewer_decision (approve / fix / reject) and notes columns.

## Step 10: Batching, progress and delivery
- Full run: process remaining rows in batches of {BATCH_SIZE}. After each batch send the user a one-line update: batch n/N, rows done, fill rate per field, credits used / {CREDIT_BUDGET}.
- If the budget is reached: stop, mark remaining rows enr_status = skipped_budget, and report how many are left and the estimated credits to finish.
- "Run Summary" tab: rows in, duplicates, do-not-contact, already complete, enriched / partial / needs review / unmatched / skipped_budget, fill rate per field, credits and time used, cache hits, tools unavailable.
- CRM write-back (only if {CRM_SYNC} is salesforce or hubspot and the user approved it): Salesforce uses SalesforceContactOperator, SalesforceLeadOperator and SalesforceAccountOperator; HubSpot uses HubspotContactOperator and HubspotCompanyOperator. Match by email (then by record ID); fill EMPTY fields only; never replace a CRM value; never write do-not-contact rows or values below {CONFIDENCE_THRESHOLD}; never write UNVERIFIED emails or phones unless the user explicitly asked for that; never create new CRM records unless the user explicitly asked; log failed writes.
- If {SUMMARY_RECIPIENTS} is set, send ONE summary email there. Subject: "Lead Enrichment: {list name}: {enriched}/{total} rows enriched". Body: the Run Summary numbers, link to the sheet, Needs Review count, tools unavailable, and next refresh date.
~~~~

## 8. Test plan

Run this before any full run. Ask the user to approve the test first.

1. **User prepares a COPY of the list** (or a small sample tab) with 10–25 rows, including:
   - a few rows with work emails, a few with only name + company,
   - one deliberate duplicate,
   - one row whose email is on `{DO_NOT_CONTACT_LIST}`,
   - one row that already has every field filled.
2. **Run Lead Enrichment** on the copy ("Run the test batch").
3. **Verify the checklist together:**

| Check | Pass? |
|---|---|
| Columns were mapped correctly and the source tab is unchanged | ☐ |
| Original values were **not** overwritten anywhere | ☐ |
| Duplicate marked `duplicate`, not enriched or paid for | ☐ |
| Do-not-contact row marked `do_not_contact`, not enriched | ☐ |
| Already-complete row was skipped (no credits used) | ☐ |
| Every new value has `_source` (with a URL), `_conf` and `enr_date` | ☐ |
| Guessed emails and phones say UNVERIFIED with confidence ≤ 40 (60 if published on an official page) | ☐ |
| Phones are in E.164 format | ☐ |
| Low-confidence / unmatched rows appear in Needs Review with a reason | ☐ |
| Lookup Cache tab was written; re-running a row uses no new credits | ☐ |
| Credits used in the report are plausible for the rows processed | ☐ |
| Credits and time estimate for the full list was shown and **no full run started** without a yes | ☐ |
| (If set) Summary went to `{SUMMARY_RECIPIENTS}` only; **no email to any contact** | ☐ |
| (If `{CRM_SYNC}` is on) Only empty CRM fields were filled, on one test record the user approved | ☐ |

4. The user spot-checks 3–5 enriched values by hand. Fix anything that failed, re-run, then ask for approval of the full run.

## 9. Final status checklist

When you finish, send the user a status summary in this format:

**✅ Done by me**
- [ ] Account connection and clone status checked
- [ ] Discovery table shared
- [ ] Placeholder values confirmed
- [ ] Skills/operators attached: …
- [ ] Lead Enrichment skill created (or full text handed over for copy-paste)
- [ ] Test batch completed on a copy; results: …
- [ ] Full-run credits and time estimate shared: … credits / … estimated time
- [ ] (If approved) Full run completed: … enriched, … needs review, … credits used

**⏳ Waiting on you**
- [ ] Connect Google/Microsoft 365 account and switch the clone on (if not done)
- [ ] Share the sheet with edit access
- [ ] Confirm do-not-contact list
- [ ] Save the Lead Enrichment skill (if I handed it over)
- [ ] Approve the full-run credits and time estimate
- [ ] Work through the Needs Review tab

**💡 Optional next steps**
- [ ] Schedule a 90-day refresh
- [ ] Turn on Salesforce or HubSpot write-back after reviewing results
- [ ] Build a repeatable pipeline script with Clone_Code
- [ ] Tune `{ICP_RULES}` after looking at the tier distribution

Requirements

Requirements: Lead Enrichment Autopilot

Version 2.0.0 · Last updated 2026-10-22 · Estimated setup time: 30–60 minutes (plus run time)

Use this checklist before you hand CLONE-INSTRUCTIONS.md to your clone. Your clone will also check most of this during discovery.


1. Required skills / operators

Names below are the exact operator names. Confirm them against your skill catalog (your clone will report what it finds).

#Skill / operatorWhat it's used forNotes
1GoogleSheets-Operator or Microsoft_ExcelThe working file: read the list; add the Enriched Leads, Needs Review, Run Summary and Lookup Cache tabsGoogle Sheets or an Excel workbook (OneDrive)
2Web research (the clone's research tools)Domains, firmographics, public titles, LinkedIn URLs, best-guess emails and phonesResults are always marked UNVERIFIED with a source URL and confidence

Skill names can differ slightly between orgs. Confirm the exact names in your skill catalog before saving the skill.

Clone-Lead-Generation-Skill finds NEW leads. It doesn't enrich an existing list.

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

2. Required connections and permissions

ConnectionMinimum permissionWhy
Google or Microsoft 365 accountSheets/Drive (or Excel/OneDrive) read + edit on the shared listRead the list; add new tabs and columns
Email (only if you want the summary)SendRun summary only, to {SUMMARY_RECIPIENTS}
Salesforce (only if {CRM_SYNC} = salesforce)Read Contacts, Leads, Accounts; edit only the fields to fillOptional write-back, empty fields only
HubSpot (only if {CRM_SYNC} = hubspot)Read contacts and companies; edit only the properties to fillOptional write-back, empty properties only

All connections are made by you through sign-in (OAuth) in the platform. Your clone never needs your password.

Before anything else: connect your account and make sure the clone is switched on / active. It's the most common reason setup stalls.

3. Optional add-ons

Add-onAddsExact names
CRM write-backFill empty Salesforce or HubSpot fields from the Enriched Leads tabSalesforceContactOperator, SalesforceLeadOperator, SalesforceAccountOperator; HubspotContactOperator, HubspotCompanyOperator
Pipeline scriptA repeatable script you run yourself (same hygiene, match key, confidence and output columns)Clone_Code
Summary emailRun summary to {SUMMARY_RECIPIENTS}GoogleGmailOperator or Outlook email operator
Scheduled task90-day re-enrichment refreshPlatform feature

Verified email/phone data needs a paid data provider. If your org adds an operator for one, add it as an extra step. It isn't required for this use case.

CRM concept mapping (Salesforce ⇄ HubSpot)

Generic conceptSalesforceHubSpot
ContactContact (SalesforceContactOperator)Contact (HubspotContactOperator)
Lead (unqualified person)Lead (SalesforceLeadOperator)Contact (Lifecycle stage = Lead)
Account / companyAccount (SalesforceAccountOperator)Company (HubspotCompanyOperator)
Custom fields (source, confidence, enrichment date)Custom fields (__c)Custom properties
Do-not-contact flagEmail Opt Out / Do Not CallUnsubscribed / marketing contact status

Field names vary by setup. Create custom fields for source, confidence and enrichment date before turning on write-back, so originals are never overwritten.

Google Workspace ⇄ Microsoft 365

ConceptGoogle WorkspaceMicrosoft 365
Working fileGoogleSheets-OperatorMicrosoft_Excel
Email (summary)GoogleGmailOperatorOutlook email operator

4. Data prerequisites

  • A header row and one row per person.
  • At least one identifier per row: work email, LinkedIn URL, or full name + company (name + company domain is much better).
  • A copy of the list for the test batch.
  • A current do-not-contact list (opt-outs, deletion requests, competitors you don't want to enrich).
  • A country column or default country, so phones can be formatted to E.164.
  • A lawful basis to process this personal data (GDPR/CCPA), confirmed with your privacy lead.

5. Supported list sources

SourceNotes
Google SheetsShare with the clone (edit access). Results go to new tabs
Excel / CSVWorkbook in OneDrive via Microsoft_Excel, or upload. Results come back as a workbook
Salesforce or HubSpot listExport it to a sheet first. The CRM is only written to if {CRM_SYNC} is set

6. Roles and permissions

WhoNeeds to
Clone adminSwitch the clone on, attach skills/operators, approve the plan, save the skill, approve the credits and time estimate
Account ownerConnect Google/Microsoft 365 and share the sheet with the clone
CRM admin (if writing back)Connect Salesforce or HubSpot, create custom fields, grant limited write access
Privacy / legal leadConfirm lawful basis and the do-not-contact process
Reviewer (SDR / ops)Work through the Needs Review tab

7. Estimated setup time

StepTime
Pre-flight check (this doc) + connect account5–10 min
Clone discovery + placeholders + plan10–15 min
Share sheet, do-not-contact list5–20 min
Test batch + review estimate10–15 min
Total setup30–60 min
Full run (1,000 rows)A few hours (example: about 3.5 hours at 4 rows per minute)

8. Pre-flight checklist

  • My Google (or Microsoft 365) account is connected to the clone
  • The clone is switched on / active
  • GoogleSheets-Operator or Microsoft_Excel is available
  • Web research is available
  • My list has a header row and an identifier per row
  • I've made a copy for the test batch
  • I have a current do-not-contact list
  • I've decided {FIELDS_TO_FILL}, {CREDIT_BUDGET} and {CONFIDENCE_THRESHOLD}
  • I've tried the "Credits & time estimator" with my own numbers
  • (Optional) Salesforce or HubSpot connected, with custom fields created
  • I understand this enriches existing contacts and does not find new leads
  • I understand emails and phones are best guesses marked UNVERIFIED

9. You're ready when…

  • ✅ Your account is connected and the clone is switched on.
  • ✅ The required items in section 1 are attached and signed in.
  • ✅ Your list is shared with the clone and you have a test copy.
  • ✅ You have answers for the placeholders (or are happy with the defaults).
  • ✅ You've set a credit budget you're comfortable with.
  • ✅ Your do-not-contact list is ready.

Then download CLONE-INSTRUCTIONS.md and give it to your clone.

Was this use case helpful?