130 Point Sales: A Practical AI-Agent Framework for LinkedIn-Driven RevOps
“130 point sales” is best treated as a scoring and execution framework: 100 points for fit, timing, data quality, and sequence readiness, plus 30 points for human judgment. AI agents can run the repet...
130 Point Sales: A Practical AI-Agent Framework for LinkedIn-Driven RevOps
Author: Fintalio
TL;DR
“130 point sales” is best treated as a scoring and execution framework: 100 points for fit, timing, data quality, and sequence readiness, plus 30 points for human judgment. AI agents can run the repetitive 80%, such as contact organization, CSV parsing, sequence preparation, and status checks. Humans should own the 20% involving positioning, exceptions, compliance, and deal judgment.
What “130 point sales” means in an AI-agent workflow
“130 point sales” is not a standard sales certification or a universal SaaS metric. For RevOps teams, developers, and AI engineers building autonomous agents, it is more useful as a practical operating model: a 130-point scoring system that determines when a prospect, contact list, or outbound motion is ready for execution.
The core idea is simple:
- 100 points measure whether the agent has enough structured information to safely run the boring, repeatable 80%.
- 30 points measure whether a human has reviewed the high-judgment 20%.
That distinction matters. Autonomous sales agents should not be designed as fully unsupervised closers. They should be designed as reliable operators that prepare, organize, validate, and launch repeatable workflows while routing uncertain decisions to a person.
For LinkedIn-driven outbound, a practical 130 point sales workflow can evaluate:
- Contact completeness
- Account or role fit
- group membership
- CSV import quality
- variable readiness
- sequence selection
- account status
- opt-out or suppression handling
- launch eligibility
- human approval for edge cases
This article explains how to turn that into an agent architecture using a hosted LinkedIn relay, first-party session controls, and the verified MCP tool surface available to the platform.
Why developers should think in points, not prompts
Many AI sales projects start with prompt design. That is usually the wrong abstraction.
Prompts are flexible, but sales operations need state, thresholds, validations, and clear stop conditions. A “130 point sales” model gives the agent an execution contract:
- If score is high enough, proceed.
- If data is missing, enrich or route.
- If risk is ambiguous, stop.
- If the account session is unhealthy, pause.
- If the sequence is not approved, do not launch.
This makes the agent auditable. It also prevents a common automation failure: letting a language model make business decisions without enough context.
A useful agent should not decide that a VP of Engineering is “probably a good fit” and immediately trigger outreach. It should check contacts, groups, sequence templates, variables, import status, and account health first. Only then should it ask for human judgment where judgment is actually needed.
That is the 80/20 pattern:
AI agent, boring 80%:
- Parse CSV files
- Create or update contacts
- Assign groups
- Read sequences and templates
- Check variables
- Validate account status
- Launch approved sequences
- Pause, resume, or stop sequences
Human, judgment-heavy 20%:
- Define ICP and exclusions
- Approve messaging strategy
- Review ambiguous accounts
- Handle enterprise exceptions
- Decide when to personalize deeply
- Interpret replies and deal context
For a broader service-level view of how sales execution fits into pipeline generation, readers can also compare this framework with the lead generation services guide.
The 130 point sales scorecard
A practical scorecard should be strict enough to prevent bad launches, but not so complex that it blocks execution. The following model gives developers a clear structure.
1. Contact data quality, 25 points
This section measures whether the contact record is usable.
| Criterion | Points |
|---|---|
| Required identity fields are present | 6 |
| Company or account context exists | 5 |
| Role or title is usable | 5 |
| LinkedIn-related contact field is mapped where available | 4 |
| Duplicate handling is completed | 3 |
| Contact can be updated safely | 2 |
Relevant MCP tools:
ListContactsGetContactCreateContactUpdateContactParseCsvCommitCsv
A contact with missing company context may still be useful, but the agent should avoid launching a sequence until a human or upstream system confirms the fit. Bad contact data creates downstream waste: poor personalization, incorrect segmentation, and sequence errors.
2. Segmentation and group readiness, 15 points
Groups let the agent organize outbound execution without hardcoding business logic into prompts.
| Criterion | Points |
|---|---|
| Target group exists | 4 |
| Contact belongs to the correct group | 4 |
| Group naming convention is valid | 3 |
| Suppression or exclusion groups are checked | 3 |
| New group creation is approved when needed | 1 |
Relevant MCP tools:
ListContactGroupsCreateContactGroup
The agent should avoid inventing segments at runtime unless the workflow explicitly permits group creation. A good naming pattern might be:
region_persona_stage_source
emea_cto_seriesA_webinar
na_revops_director_partnerlist
Simple conventions reduce ambiguity and make automation safer.
3. Sequence and template readiness, 20 points
A sequence should not launch just because a contact exists. The agent needs to confirm that the correct sequence and template are available.
| Criterion | Points |
|---|---|
| Candidate sequences are listed | 3 |
| Selected sequence matches campaign goal | 5 |
| Sequence template exists | 4 |
| Template has required variables | 4 |
| Template version is approved | 2 |
| Stop, pause, and resume paths are defined | 2 |
Relevant MCP tools:
ListSequencesGetSequenceListSequenceTemplatesGetSequenceTemplateCreateSequenceTemplatePauseSequenceResumeSequenceStopSequence
For AI engineers, this is where workflow determinism matters. The agent should not improvise a sequence. It should retrieve approved assets, check fields, and proceed only if the selected sequence matches the target group and campaign intent.
4. Variable completeness, 10 points
Variables are often where outbound quality breaks. If the template expects first_name, company_name, pain_point, and proof_point, the agent must verify availability before launch.
| Criterion | Points |
|---|---|
| Variables are listed | 2 |
| Required variables are mapped | 4 |
| Empty values are detected | 2 |
| Risky generated values are routed to review | 2 |
Relevant MCP tool:
ListVariables
Variable checks should be mechanical. If a required value is absent, the agent should not “creatively” fill it in. The correct behavior is to stop, update the contact if verified data exists, or route the case to a human.
5. Account and session status, 10 points
No sales agent should launch outreach without checking whether the connected account is in a valid state. This is especially important when working through the platform’s LinkedIn infrastructure and first-party session model.
| Criterion | Points |
|---|---|
| Account status is available | 3 |
| Session is healthy | 3 |
| Launch is permitted | 2 |
| Agent can pause on unhealthy status | 2 |
Relevant MCP tool:
GetAccountStatus
This is a guardrail layer. It protects deliverability, operational continuity, and account integrity. If account status is not healthy, the agent should pause execution rather than retry aggressively.
6. Import and commit control, 10 points
For CSV-driven workflows, the distinction between parsing and committing is important. Parsing is reversible. Committing changes the system state.
| Criterion | Points |
|---|---|
| CSV parses successfully | 3 |
| Field mapping is valid | 3 |
| Error rows are isolated | 2 |
| Commit is approved | 2 |
Relevant MCP tools:
ParseCsvCommitCsv
This is a classic 80/20 boundary. The agent can parse, validate, and summarize the import. A human should approve commits for new sources, high-value accounts, or unusual mappings.
7. Launch readiness, 10 points
Launch readiness combines the prior checks into a final operational gate.
| Criterion | Points |
|---|---|
| Contact is valid | 2 |
| Group is correct | 2 |
| Sequence is selected | 2 |
| Variables are complete | 2 |
| Account status is healthy | 2 |
Relevant MCP tool:
LaunchSequence
The launch step should be the smallest part of the workflow. Most of the work happens before it: validation, segmentation, status checking, and approval.
8. Human judgment reserve, 30 points
The final 30 points are intentionally human-owned.
| Criterion | Points |
|---|---|
| ICP fit is strategically approved | 6 |
| Messaging is appropriate for the segment | 6 |
| Compliance or sensitivity concerns are reviewed | 5 |
| Enterprise or named-account exceptions are handled | 5 |
| Personalization depth is decided | 4 |
| Final launch approval is recorded | 4 |
This is where the agent should not pretend to be a sales leader. A model can summarize and recommend, but it should not decide strategic positioning, legal risk, or account sensitivity on its own.
Reference architecture for a 130 point sales agent
A clean architecture separates reasoning, tool execution, state, and human review.
+----------------------+
| Human RevOps Owner |
| 20% judgment layer |
+----------+-----------+
^
|
v
+-------------+ +--------+--------+ +----------------------+
| Source Data | ---> | Agent Orchestr. | ---> | MCP Tool Executor |
| CSV, CRM, | | scoring, plans, | | verified operations |
| manual list | | thresholds | +----------+-----------+
+-------------+ +--------+--------+ |
| |
v v
+----------+-----------+ +----------------------+
| Scorecard State | | Hosted LinkedIn |
| 130-point readiness | | relay, first-party |
| audit trail | | session |
+----------------------+ +----------------------+
The orchestrator should not directly assume that data is ready. It should build a score from tool results.
Example control loop:
1. Parse incoming CSV
2. Validate mapped fields
3. List contact groups
4. Create missing approved group if allowed
5. Create or update contacts
6. List sequences and templates
7. Check variables
8. Check account status
9. Calculate 100-point operational score
10. Request human approval for 30-point judgment layer
11. Launch sequence only if threshold is met
12. Pause, resume, or stop sequence when instructed
A typical threshold policy might be:
0-69: Do not launch, repair data
70-99: Ready for operations review
100-119: Ready for human judgment review
120-130: Eligible for launch
These thresholds are not universal. A high-volume SMB motion may accept a lower review threshold than an enterprise named-account motion. The important part is that the policy is explicit.
MCP tool map for implementation
The platform exposes a focused MCP surface for contact, group, sequence, template, variable, account status, CSV, and launch operations. For agent builders, the constraint is useful: fewer tools mean clearer workflows and lower risk.
The verified tools are:
ListContacts
GetContact
ListContactGroups
ListSequences
GetSequence
ListSequenceTemplates
GetSequenceTemplate
ListVariables
GetAccountStatus
CreateContactGroup
UpdateContact
PauseSequence
ResumeSequence
StopSequence
ParseCsv
CommitCsv
CreateSequenceTemplate
CreateContact
LaunchSequence
A developer-facing implementation can group them by responsibility:
| Responsibility | Tools |
|---|---|
| Contact discovery and updates | ListContacts, GetContact, CreateContact, UpdateContact |
| Groups | ListContactGroups, CreateContactGroup |
| Sequences | ListSequences, GetSequence, PauseSequence, ResumeSequence, StopSequence, LaunchSequence |
| Templates | ListSequenceTemplates, GetSequenceTemplate, CreateSequenceTemplate |
| Variables | ListVariables |
| Account status | GetAccountStatus |
| CSV import | ParseCsv, CommitCsv |
For details on the site’s MCP entry point, developers can start from MCP.
Example: agent flow for CSV-to-sequence execution
The following example shows how a 130 point sales workflow might run when a RevOps team uploads a prospect CSV.
CSV upload
|
v
ParseCsv
|
+--> errors? -------- yes --------+
| |
no v
| human fixes file
v
ListContactGroups
|
v
CreateContactGroup, if approved and missing
|
v
CommitCsv
|
v
CreateContact or UpdateContact
|
v
ListSequences, GetSequence
|
v
ListSequenceTemplates, GetSequenceTemplate
|
v
ListVariables
|
v
GetAccountStatus
|
v
score >= threshold?
|
+--> no: route to human
|
yes
|
v
LaunchSequence
The key design choice is that ParseCsv and CommitCsv are separated. The agent can perform the dull validation work, but committing new records can require approval depending on source trust and campaign risk.
130 point sales and the SDR workflow
The 130 point sales model does not remove the SDR role. It changes where human effort goes.
An SDR should not spend large blocks of time cleaning CSV files, checking whether a sequence template exists, or confirming that a contact belongs to the correct group. Those tasks are deterministic enough for an agent.
The SDR should focus on:
- evaluating account context
- improving messaging
- deciding which high-value prospects need custom handling
- interpreting replies
- escalating qualified opportunities
- giving feedback to RevOps on targeting quality
That is why 130 point sales works well as an SDR support model. The agent handles the boring 80%, while the SDR handles the judgment-heavy 20%. For readers mapping this into role design, the sales development representative guide gives broader context on SDR responsibilities.
Vendor comparison: build, buy, or hybrid
Teams building autonomous sales agents usually face three options: build the entire workflow internally, use a broad automation platform, or use a focused hosted LinkedIn relay with MCP tools.
Cost varies by team size, data volume, compliance requirements, and engineering scope. The ranges below are directional, not exact point estimates.
| Option | Typical monthly cost range | Engineering effort | Best fit |
|---|---|---|---|
| Internal custom build | €3,000-€25,000+ in engineering time and infrastructure | High | Teams needing deep proprietary workflows |
| General automation stack | €200-€2,000+ across tools and seats | Medium | Teams with mixed CRM, email, and ops automation |
| Sales engagement platform | €100-€300+ per seat, often with annual terms | Low to medium | Teams wanting packaged workflows |
| Focused hosted LinkedIn relay with MCP | €69/mo single plan | Low to medium | Developers building LinkedIn-oriented agents |
The platform’s pricing is intentionally simple: one €69/mo plan, no free tier, and no usage-based tiers. That clarity matters for agent builders because unpredictable usage pricing can make autonomous workflows harder to budget.
A hybrid approach is often the most practical. The team keeps CRM and warehouse logic where it already lives, then uses the platform’s LinkedIn infrastructure and MCP tools for execution around contacts, groups, templates, variables, account status, CSV processing, and sequence launch.
Guardrails for safe autonomous execution
A 130 point sales agent should be conservative by default. The following controls help prevent automation from creating RevOps debt.
1. Require explicit launch thresholds
The agent should calculate readiness, not simply “feel confident.” A launch should require a score threshold and a known sequence.
if operational_score < 100:
do not launch
if human_score < 20:
request review
if account_status != healthy:
pause execution
The exact implementation depends on the orchestrator, but the policy should be clear.
2. Keep human approval for high-risk cases
High-risk cases include:
- enterprise named accounts
- regulated industries
- sensitive job functions
- incomplete data
- newly created templates
- unfamiliar CSV sources
- unusual group creation requests
These should consume the 30-point judgment reserve.
3. Treat missing data as a stop condition
If a required variable is missing, the agent should not invent a value. It should update the contact only when verified data is available or route the case to review.
4. Use pause and stop operations deliberately
Sequence control is not just about launching. A practical agent must also know when to pause, resume, or stop.
Relevant tools:
PauseSequenceResumeSequenceStopSequence
For example, if account status changes or a campaign owner flags a targeting issue, the agent should pause execution rather than continuing blindly.
5. Log scoring decisions
Every launch should have a trace:
contact_id: 123
group: na_vp_engineering_seriesb
sequence: infra_leaders_q1
operational_score: 96
human_score: 26
decision: blocked
reason: operational score below 100, missing proof_point
This gives RevOps a way to debug workflows without reading model transcripts.
Technical implementation checklist
A hands-on implementation can follow this checklist.
Data intake
- Use
ParseCsvbefore committing records. - Validate required columns.
- Separate clean rows from error rows.
- Ask for approval before
CommitCsvwhen the source is new.
Contact handling
- Use
ListContactsto detect existing records. - Use
GetContactfor record-level checks. - Use
CreateContactfor new approved records. - Use
UpdateContactonly when data is verified.
Group handling
- Use
ListContactGroupsto find target groups. - Use
CreateContactGrouponly when group creation is allowed by policy. - Avoid uncontrolled group sprawl by enforcing naming rules.
Sequence handling
- Use
ListSequencesto identify available sequences. - Use
GetSequenceto inspect the selected sequence. - Use
ListSequenceTemplatesandGetSequenceTemplateto verify approved templates. - Use
CreateSequenceTemplateonly within an approved content workflow. - Use
LaunchSequenceonly after scoring and approval gates pass.
Variable handling
- Use
ListVariablesbefore launch. - Block launch when required variables are missing.
- Route generated or uncertain personalization to human review.
Account status
- Use
GetAccountStatusbefore launch. - Pause execution when status is unhealthy.
- Avoid aggressive retry behavior.
Sequence control
- Use
PauseSequencefor temporary operational issues. - Use
ResumeSequenceafter the issue is cleared. - Use
StopSequencewhen the campaign or contact should no longer continue.
Common anti-patterns
Anti-pattern 1: letting the model choose everything
If the agent chooses the audience, message, template, and launch timing without constraints, it is not a RevOps system. It is a risk generator. The scorecard should constrain the model’s freedom.
Anti-pattern 2: skipping account status checks
Account status should be checked before launch and during sensitive operations. A hosted LinkedIn relay still needs operational guardrails around first-party session health.
Anti-pattern 3: treating CSV import as harmless
CSV import can create duplicate records, bad variables, wrong groups, and broken sequences. Parsing is low risk. Committing is state-changing.
Anti-pattern 4: over-personalizing with unverifiable claims
Generated personalization can sound convincing while being wrong. A good 130 point sales system reserves judgment-heavy personalization for human review.
Anti-pattern 5: optimizing for full autonomy instead of controlled autonomy
The goal is not to remove humans from sales. The goal is to remove repetitive work from humans so they can spend more time on judgment, positioning, and relationship-building.
FAQ
1. What is 130 point sales?
130 point sales is a practical scoring framework for deciding when an AI-assisted sales workflow is ready to execute. It uses 100 points for operational readiness and 30 points for human judgment.
2. Is the agent supposed to replace SDRs?
No. The agent should handle the boring 80%, such as imports, contact updates, group checks, template validation, and launch preparation. SDRs should handle the 20% that requires judgment.
3. Which MCP tools are available for this workflow?
The verified MCP tools cover contacts, groups, sequences, templates, variables, account status, CSV import, and sequence launch. They include tools such as ParseCsv, CommitCsv, GetAccountStatus, ListVariables, and LaunchSequence.
4. How much does the platform cost?
The platform has a single €69/mo plan. There is no free tier and no usage-based pricing.
5. Should every contact need 130 points before launch?
Not always. Teams can define thresholds by campaign risk. However, high-value, sensitive, or enterprise-oriented outreach should usually require both strong operational readiness and human approval.
Build the boring 80% into the agent
A 130 point sales system gives AI sales agents a practical operating contract: validate the data, check the workflow, confirm account status, prepare the sequence, and route judgment calls to humans.
Developers and AI engineers can explore the site’s MCP entry point, review the available workflow surface, and start building safer LinkedIn-oriented sales agents with a simple €69/mo plan.
Visit Fintalio to start building with the platform’s LinkedIn infrastructure and MCP tools.
Plug LinkedIn into your AI agent
Fintalio is the MCP server for LinkedIn. Connect Claude, Cursor, or your custom agent and ship outreach workflows in minutes — with audit logs and rate-limit awareness baked in.
Get started