← Back to blog
· 14 min

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:

  1. Contact completeness
  2. Account or role fit
  3. group membership
  4. CSV import quality
  5. variable readiness
  6. sequence selection
  7. account status
  8. opt-out or suppression handling
  9. launch eligibility
  10. 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:

  • ListContacts
  • GetContact
  • CreateContact
  • UpdateContact
  • ParseCsv
  • CommitCsv

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:

  • ListContactGroups
  • CreateContactGroup

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:

  • ListSequences
  • GetSequence
  • ListSequenceTemplates
  • GetSequenceTemplate
  • CreateSequenceTemplate
  • PauseSequence
  • ResumeSequence
  • StopSequence

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:

  • ParseCsv
  • CommitCsv

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:

  • PauseSequence
  • ResumeSequence
  • StopSequence

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 ParseCsv before committing records.
  • Validate required columns.
  • Separate clean rows from error rows.
  • Ask for approval before CommitCsv when the source is new.

Contact handling

  • Use ListContacts to detect existing records.
  • Use GetContact for record-level checks.
  • Use CreateContact for new approved records.
  • Use UpdateContact only when data is verified.

Group handling

  • Use ListContactGroups to find target groups.
  • Use CreateContactGroup only when group creation is allowed by policy.
  • Avoid uncontrolled group sprawl by enforcing naming rules.

Sequence handling

  • Use ListSequences to identify available sequences.
  • Use GetSequence to inspect the selected sequence.
  • Use ListSequenceTemplates and GetSequenceTemplate to verify approved templates.
  • Use CreateSequenceTemplate only within an approved content workflow.
  • Use LaunchSequence only after scoring and approval gates pass.

Variable handling

  • Use ListVariables before launch.
  • Block launch when required variables are missing.
  • Route generated or uncertain personalization to human review.

Account status

  • Use GetAccountStatus before launch.
  • Pause execution when status is unhealthy.
  • Avoid aggressive retry behavior.

Sequence control

  • Use PauseSequence for temporary operational issues.
  • Use ResumeSequence after the issue is cleared.
  • Use StopSequence when 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