Account scoring

Tier every company in your TAM A / B / C / disqualified with a deployed agent that reads your ICP and tiering rubric from the workspace context, web-searches only to settle a doubt, and writes the tier, a two-sentence reason and its evidence back onto the row, then keeps new companies tiered as they land.

Installation

Set up the account-scoring cookbook in this project.

1. If the Cargo CLI is not installed yet, follow every step in https://api.getcargo.io/INSTALL.md
2. From the Cargo project, run: cargo-ai cdk add cookbook/account-scoring
3. Then follow .claude/skills/account-scoring/SKILL.md. Stop for my approval before any paid call, and stop at "cargo-ai project plan" before deploying anything.

Paste it into Claude Code, Cursor, Codex, Gemini CLI, Devin or Replicas.

Say this to your agent

Tier every company in our TAM against the ICP and the rubric in our context repo, and keep new ones tiered as they land.

Illustrative output #

Fictional records, to show the shape of what comes back.

Company (domain)	tier	tier_reason	tier_evidence_url
Northwind (northwind.example)	A	Fits the firmographics: 240-person B2B software company in the US. Has a GTM engineer on staff, which the rubric ranks as the strongest sign.	https://northwind.example/careers/gtm-eng
Fabrikam (fabrikam.example)	C	Fits industry, size and country. No technical revenue role and no public automation practice was found, so nothing lifts it above C.
Tailspin (tailspin.example)	disqualified	Services-only consultancy with no software product, which the ICP lists as a disqualifier. The sourced industry label was misleading.	https://tailspin.example/about

Every row also gets tiered_at and lands in tier_a_accounts, tier_b_accounts, tier_c_accounts or disqualified_accounts. The report closes on the tier distribution and one recommended next step.

What you will be asked #

Input		Why
icp	Looked up	The rubric decides against it. A tier that cannot name the ICP line it came from is a guess, and the evaluator fails it
tier_rubric	Asked	It is the one input that is genuinely a decision about the business: what “work it now” means here
model	Looked up	The workflow interpolates these columns into the prompt. A renamed one hands the agent an undefined
languageModel	Looked up	Judgment quality and the cost per company both live here
restale	Looked up	How often a tiered company is judged again. Shorter re-bills the whole book more often

Done when #

the ICP and the tiering rubric are in the workspace context, and the rubric was approved
the pilot tiered ten rows, and one A, one C and one disqualified were checked against the rubric by hand
every row in the model carries a tier the rubric defines, a rationale naming the deciding lines, and a tiered_at stamp, and no row carries one without the others
the four segments resolve, and their counts sum to the tiered row count
the agent’s evaluator pass rate is at or above its threshold
editing the rubric in the context repo changes the next tier with no deploy
the report gave the tier distribution, actual credits against the pilot’s estimate, and one recommended next step
node --import tsx evals/contract.mjs passes against the adapted resources

What it costs #

Tiering is one agent run per company, billed as LLM tokens through the bound connector, plus the web searches the agent decides to make. maxSteps is the per-company ceiling, and the rubric’s one-question-one-search rule is what keeps a normal row far below it. The pilot is how you learn the real number: read actual credits for the ten rows, then multiply by the untiered row count before approving the backfill.

After the backfill, the play only tiers what arrives (changeKinds: ["added"]) and what goes stale after six months, so the steady-state cost follows how many companies tam-building lands, not how often the cron fires.

Tier every company in your TAM A, B, C or disqualified, with the reason and the evidence written on the row. An agent reads your ICP and tiering rubric from the workspace context; a play writes its judgment back and keeps new companies tiered as they land.

What it does #

Judges against your own rubric. The ICP and tiering-rubric.md live in the context repo. Edit the rubric and the next tier changes, with no deploy.
Looks up only what the row does not hold. Firmographics were settled by tam-building’s filter. The agent searches once, to settle the doubt that would change the tier, and records the page.
Writes a reason a rep can argue with. Every tier carries two sentences naming the rubric lines that decided it, the evidence URL, and a stamp.
Hands downstream work four segments. tier_a_accounts is what contact sourcing and engagement run on; disqualified_accounts is what they suppress.
Needs no CRM. It tiers tam_companies in Cargo. Writing the tier to a CRM as well is a variation.

How it works #

flowchart TD
    tam["tam_companies<br/>from tam-building"]
    play["tier_accounts play<br/>untiered or stale rows · hourly · added only"]
    agent["account_tier_analyst<br/>reads ICP + rubric from context · webSearch"]
    write["write tier · rationale · evidence · tiered_at<br/>onto the row"]
    segments["tier_a / tier_b / tier_c / disqualified segments"]

    tam --> play --> agent --> write --> segments

File	Resource	Role
`infra/models/tam-companies.ts`	`defineModel`	a copy of tam-building’s model, plus the four tier columns
`infra/agents/tier-analyst.ts`	`defineAgent`	the judgment: context and webSearch, no write access
`infra/plays/tier-accounts.ts`	`definePlay`	the only write, and the eligibility filter on `tiered_at`
`infra/segments/tiers.ts`	`defineSegment` ×4	one per tier the agent can emit
`infra/connectors/anthropic.ts`	`defineConnector`	the LLM, bound
`infra/connectors/ai-ark.ts`	`defineConnector`	the model copy’s source; dropped when tam-building is present
`infra/folders/index.ts`	`defineFolder` ×3	models, agents and plays, named after the skill
this skill’s `context/tiering-rubric.md`	(not a resource)	example rubric to copy into the project’s `context/`

Placeholders (edit before deploy) #

The rubric: copy context/tiering-rubric.md into the project’s context/ beside the ICP, and rewrite every tier for your business.
The model: when tam-building is installed, move the four additionalColumns onto its tam_companies and delete this copy.
languageModel in infra/agents/tier-analyst.ts.

Cost #

One agent run per company, in LLM tokens plus any web searches, capped by maxSteps. The pilot measures it on ten rows before the backfill is approved. After that the play only tiers what arrives and what goes stale.

Verification #

shellscript

node --import tsx evals/contract.mjs   # the graph boundaries, from the compiled registry
cargo-ai cdk types && cargo-ai cdk check && cargo-ai cdk plan

evals/acceptance.md is the line-by-line acceptance test.

Composes into #

contact-sourcing on tier A, agentic-engagement, new-hire-detection. Works best after tam-building.