AI Lead Scoring: Score Your Whole Database with a Claude Agent

Write the model as a rubric, with three components and explicit weights

A lead score is a claim about who will buy, so start by writing the claim down in words before anyone touches a prompt. Three components cover nearly every B2B motion. Fit is whether the account and person look like your best customers: industry, size, region, title, tech stack. Intent is whether there is a reason to believe they are in-market now: a demo request, a pricing-page visit, a competitor evaluation, a hiring signal. Engagement is whether they are responding to you: opens, replies, event attendance, repeat visits, with a decay so a click from March stops counting in June.

Weight them for your motion. A product with a tight ICP and long cycles should weight fit at half or more, because a perfect-fit account with no intent is still worth a rep's attention. A high-velocity motion can lean on intent, because timing matters more than shape. Write the weights down as percentages that sum to 100, and write the tier cut-offs next to them. The model template below is the one I start from.

Pull your last 40 closed-won deals and check the model against them by hand before you automate anything. If a meaningful share of your actual customers would have scored C-tier under the rubric, the rubric is wrong, and you found out for free. This is the step the 2021 points system skipped.

Expose the fields the agent scores on, and the three it writes

Connect the CRM to Claude over the HubSpot MCP connector (or Salesforce) and list, by exact property name, every field the model reads: industry, employee count, job title, lifecycle stage, last activity date, page views on high-intent pages, form submissions, email engagement. Custom properties are invisible until you name them, so the agent will score on the standard ones and miss your setup if you skip this.

Create three new properties for the agent to write: lead_score (number), lead_tier (A/B/C/D), and lead_score_reason (single-line text). Keep the existing HubSpot score alive alongside for a month so you can compare. Do not let the agent write anything else. The whole play is safe because its write surface is three fields, and every one of them is reversible.

Decide the population. Scoring every record in a 200,000-contact database nightly is wasteful and slow. Score everything once as a backfill, then nightly re-score only leads with any activity or property change in the last 30 days, plus anyone currently in A or B tier so decay applies. That keeps the run to hundreds or low thousands of records for most teams.

• Fit inputs: industry, employee count, region, job title, seniority, tech stack
• Intent inputs: demo/pricing form, pricing-page visits, competitor page visits, hiring or funding signals
• Engagement inputs: last email reply, opens in the last 14 days, event attendance, repeat site visits
• Context inputs: lifecycle stage, existing customer or open deal, owner
• Outputs (the only writes): lead_score, lead_tier, lead_score_reason

Give the agent the scoring brief

The scoring prompt is the rubric from step one, translated into instructions the agent applies identically to every record. It must return the three sub-scores, the combined score, the tier, and a one-sentence reason that cites the specific facts, in strict JSON, because the orchestrator writes those fields programmatically and free text cannot be written to a number property.

Two rules carry most of the weight. First, use only the data on the record; if a field is blank, treat it as neutral and say so in the reason, rather than guessing a company size from the name. Second, an existing customer or an open deal short-circuits the whole thing: the lead gets flagged, routed to the account owner, and excluded from new-business tiers. Cold-pitching a customer because a scoring model got excited is the one failure that costs more trust than every mis-scored lead combined.

Run the brief on 50 leads you already know well before you point it at the database. Read every reason line. When a reason is wrong, the fix is almost always a missing rule in the rubric, and it is far cheaper to find it in 50 records than in 50,000.

Score this lead using ONLY the fields provided. Do not infer missing values.

Lead: {{FULL_NAME}}, {{TITLE}} at {{COMPANY}}
Fit fields: industry={{INDUSTRY}}, employees={{EMPLOYEES}}, region={{REGION}}, tech={{TECH_STACK}}
Intent fields: demo_or_pricing_form={{FORM}}, pricing_visits_30d={{PRICING_VISITS}}, competitor_visits_30d={{COMP_VISITS}}, hiring_signal={{HIRING}}
Engagement fields: last_reply={{LAST_REPLY}}, opens_14d={{OPENS}}, events_90d={{EVENTS}}, site_visits_30d={{VISITS}}
Context: lifecycle={{LIFECYCLE}}, existing_customer_or_open_deal={{EXISTING}}

Scoring model:
- fit (0-100): {{ICP_RULES}}. Fit sets the ceiling: a lead with fit < 40 cannot be tier A or B.
- intent (0-100): {{INTENT_RULES}}. Cap any single signal at 40 points.
- engagement (0-100): {{ENGAGEMENT_RULES}}. Decay: nothing older than 30 days counts.
- score = 0.5*fit + 0.3*intent + 0.2*engagement, rounded.
- tier: A >= 75, B 55-74, C 35-54, D < 35.

Rules:
- If existing_customer_or_open_deal is true: set route_to_owner true, tier "X", and stop scoring.
- Blank fields are neutral. Never penalize a blank; note it in the reason.
- Students, job seekers, competitors, and agencies scoring on your behalf: tier D, say why.

Return JSON only:
{"fit": n, "intent": n, "engagement": n, "score": n, "tier": "A|B|C|D|X", "route_to_owner": bool, "reason": "<one sentence citing the specific fields that drove the score>"}

Schedule the pass and write back in batches

Put the run on a nightly Claude Routine, or a scheduled Claude Code job if you want it in your own repo with your own logging. Either way the shape is the same: page through the changed-in-30-days population in batches of 50 to 100, score each record, write the three properties back over MCP, and log every write with the old and new tier so you can audit a week later. Batching with a pause between pages keeps you well inside CRM API limits; a loop that hammers 20,000 records in one burst is how you meet the rate limiter at 2am.

Treat tier changes as the interesting event, not the score itself. A lead moving from C to A overnight is news. A lead sitting at 71 for the fourth week is furniture. Have the run collect the movers into a short list and hand that to the routing step, and let everything else quietly update in the background.

Keep a kill switch. The Routine should read a single flag before writing anything, so a bad rubric change can be halted with one property flip rather than a frantic revert at 7am when the reps log in.

Route by tier, with the boring guardrails first

Routing is a set of rules that run off lead_tier, and the first rule is always the existing-customer branch: route_to_owner true goes to the account owner or CS and never to new business. Only after that do the tiers apply. A-tier goes to a named rep by territory or round-robin with a Slack alert and a 24-hour SLA. B-tier enters a sequence owned by an SDR. C-tier gets nurture. D-tier is left alone.

Give every branch a fallback owner. The leads that match no rule, a personal email at a huge company, a title the rubric has never seen, a region you do not sell to but that keeps requesting demos, are exactly the unusual ones that turn out to matter. A real human owns the fallback bucket and works it weekly. Build this before you build anything clever.

Post the overnight A-tier movers to each owner in Slack, with the reason line and a link to the record. That message is the product. A rep who opens Slack at 8am to 'six leads crossed into A overnight, here is why' starts the day on the right names instead of sorting a list view.

Audit the model monthly against what actually closed

The reason the 2021 score died was nobody had a reason to look at it again. Build the reason in. Once a month, pull every deal created in the last 90 days and check the tier each lead carried the day the deal was created. If closed-won deals are coming out of C-tier, the fit rubric is too narrow. If A-tier is full of leads that never took a meeting, intent is over-weighted or a single signal is leaking through the cap.

Compare the agent's tier to the legacy HubSpot score for the first month and to rep behavior after that: which tiers did reps actually work, and what converted. Adjust weights in the rubric, re-run the 50-lead test set, and let the nightly Routine roll the change across the database. A model you can change in one file and re-score overnight is a model that stays honest.

Audit the D-tier, too. A mis-scored A-tier lead generates a complaint. A real buyer parked in D generates silence, because you never hear about the deal you did not get. Sample D-tier monthly for anyone who later became a customer or an opportunity. That number is the cost of the model, and it is the one nobody measures.