GTM Automation Agent.
Grades, enriches, plans and runs outbound on small models — daily, inside our own stack, on our own bills.
Salesforce · Clay · Lemlist · Hitbox
We sell small-model automation, so we run it on ourselves first. Our own outbound — the pipeline that finds Crit Studio's clients — runs on this agent. The system on this page grades, enriches, sequences and works every lead that reaches our CRM. When we publish a number here, it comes from our own operations, not a slide.
The stack is the one most B2B teams already own: Salesforce as the system of record, Clay for data, our own orchestration code, Lemlist for sending. The agent doesn't replace the stack. It replaces the human hours and the per-row AI spend inside it.
None of these steps is hard. All of them are constant.
GTM automation has a quiet cost structure. Every “AI research” step on a credit-based platform burns credits per row. Every grading or personalization call to a frontier model burns tokens priced for hard reasoning — on work that is mostly classification. And the steps in between still need a person: someone to normalize job titles, dedupe accounts, decide which cadence a lead belongs in, and push the buttons.
At a few thousand rows a month you feel it in hours; at tens of thousands you feel it in the bill. The absurdity: paying frontier-model prices — or analyst salaries — for work a well-trained 7B model does with equal accuracy and a full audit trail.
An agent built from small models, each doing one narrow job, with a router deciding when a job is too hard for a small model. Four functions:
Grade. A fine-tuned small classifier scores every inbound and sourced lead: grade, reason codes, confidence. Distilled from a frontier-labeled training set, so it grades like the big model at a fraction of the price — and gives the same answer twice, which frontier models often don't.
Enrich. Deterministic code first — regex, lookups, Clay waterfalls. The SLM only touches what code can't: messy titles, company-name variants, free-text fields. No model call where a rule will do.
Plan. A planning step assigns each graded lead to a cadence and segment. This is the one place a larger model earns its price: low volume, higher stakes, a few hundred calls a month instead of tens of thousands.
Operate. Orchestration code executes: Salesforce writes, Lemlist sequencing, task creation. The SLM drafts first-line personalization; templates and claims pass human approval before anything sends. Execution is code, not vibes.
| Step | What runs | Why this model class |
|---|---|---|
| Intake & normalization | Code + fine-tuned ~3B SLM | Code first; the SLM handles only what rules can't |
| Lead grading | Fine-tuned ~7B classifier | Distilled from frontier labels; consistent, cheap, auditable |
| Hitbox router | Eval harness + confidence gate | Low-confidence rows escalate to a frontier model — by design, the exception |
| Cadence planning | Frontier-class model, low volume | Few calls, real judgment — the 20% that earns frontier pricing |
| Execution | Orchestration → Salesforce, Lemlist | Deterministic; SLM drafts, humans approve copy |
Hitbox — our eval-and-routing stack — sits between the classifier and the frontier model. Every graded row carries a confidence score; rows below threshold escalate. The design target is under 10% escalation: the small model earns its keep on the routine 90%, and the frontier model handles only the rows that deserve it.
Our cost model, assembled from public list prices, August 2026: frontier-class API at $3 / $15 per million tokens in and out; hosted 8B-class SLM at roughly $0.10 / $0.30. Token counts are our actual prompt sizes.
| Step (per 1,000 rows) | Frontier-only | SLM | SLM + Hitbox escalation |
|---|---|---|---|
| Lead grading | ~$4.50 | ~$0.13 | ~$0.48 at 8% escalation |
| Enrichment normalization | ~$2.70 | ~$0.08 | — |
| First-line personalization (per 1,000 emails) | ~$6.60 | ~$0.18 | — |
The honest version: at typical mid-market volume, raw token spend isn't the biggest line — credits and seats are. Credit-based platforms price AI research steps per row, per step; AI-SDR tools price per seat, per month. The SLM stack removes per-row AI burn from every step that doesn't need frontier reasoning — which is most of them. Volume can grow 10× without the bill following, and your CRM data stays in your own infrastructure instead of transiting a third-party agent tool.
We publish measured metrics from our own operations as eval cycles complete.
We started with a model twice the size we needed for grading — the 7B matched it after fine-tuning, and the first week of eval data would have told us that if we'd built the eval set first. We now build the eval set first, always.
Two steps we originally framed as “agent decisions” are plain code today. If a step's logic fits in an if-statement, it's an if-statement. The model count went down and reliability went up.
And our label taxonomy churned three times before it stabilized. Reason codes need designing with the person who reads them, not for them.
Built private. Run private.
- Runs in our own perimeter
- No client data in demos
- Synthetic corpora where it counts
- Audit logs always on
Your pipeline runs on the same stack.
If your team pays frontier prices — or analyst hours — for grading, enrichment and sequencing, The Crit tells you exactly what a small-model agent saves. Two weeks, a roadmap and a number.