BO7 Sales: A Practical 7-Step Outbound System for AI Agents
By Fintalio BO7 sales is best treated as a seven-step, agent-friendly outbound framework: define ICP, prepare contacts, enrich context, build sequences, launch controlled outreach, monitor status, and...
BO7 Sales: A Practical 7-Step Outbound System for AI Agents
By Fintalio
TL;DR
BO7 sales is best treated as a seven-step, agent-friendly outbound framework: define ICP, prepare contacts, enrich context, build sequences, launch controlled outreach, monitor status, and hand off judgment-heavy work to humans. For developers and AI engineers, the goal is not full sales replacement. The goal is an 80/20 system where agents run repetitive LinkedIn sales operations and humans handle strategy, exceptions, and relationship decisions.
What “BO7 sales” means in practice
“BO7 sales” is often used as shorthand for a compact, seven-part sales operating model. In an AI outbound context, it can be interpreted as a 7-step sales workflow that turns raw contact data into controlled, measurable LinkedIn outreach.
For developers and AI engineers building autonomous agents, the useful version of BO7 sales is not motivational sales theory. It is an execution model:
- Identify the account and contact universe
- Segment contacts into usable groups
- Normalize and validate sales data
- Create reusable sequence templates
- Launch outreach through compliant infrastructure
- Monitor sequence and account state
- Escalate the important 20% to humans
That framing matters because most outbound work is repetitive. Contact creation, CSV parsing, sequence selection, template retrieval, status checks, and pause or resume actions are all operational. They are ideal for agentic workflows.
The remaining 20% requires judgment: account prioritization, nuanced objections, legal edge cases, tone calibration, partnership opportunities, and strategic account expansion. BO7 sales works best when AI agents do the boring 80%, while the human sales team owns the 20% where context and judgment drive outcomes.
Why developers should care about BO7 sales
Sales automation used to mean simple scheduled emails, brittle browser automation, or disconnected CRM tasks. AI agents changed the design problem.
Instead of asking, “Can a tool send more messages?”, developers now ask:
- Can an agent understand the current state of a prospect?
- Can it choose the correct sequence template?
- Can it parse a contact import safely?
- Can it pause outreach when a human needs to intervene?
- Can it launch outbound from a first-party session without inventing unsupported actions?
- Can it keep humans in control of strategy and exceptions?
BO7 sales provides a simple operating model for these questions. It keeps the agent focused on bounded actions and leaves high-risk decisions to a human.
For teams still defining the commercial motion, this can complement a broader lead generation services guide or a human SDR operating model such as the sales development representative guide. The key difference is that BO7 sales for agents is implementation-first. It translates sales operations into callable tools, state transitions, and human approval gates.
The BO7 sales architecture for AI agents
A practical BO7 sales architecture has four layers:
- Data layer, where contacts, groups, CSV files, variables, and templates live
- Agent reasoning layer, where policies decide what should happen next
- MCP tool layer, where the agent performs approved sales operations
- Human review layer, where judgment-heavy work is approved, revised, or rejected
A simple architecture looks like this:
+---------------------+
| Human Sales Owner |
| strategy, approvals|
+----------+----------+
|
v
+---------------------+
| Agent Policy Layer |
| ICP rules, scoring |
| safety constraints |
+----------+----------+
|
v
+-------------------------------+
| MCP Tool Layer |
| contacts, groups, sequences |
| templates, CSV, status |
+----------+--------------------+
|
v
+-------------------------------+
| LinkedIn Outreach Runtime |
| hosted LinkedIn relay |
| first-party session |
+-------------------------------+
The agent should not be treated as a black box. It should operate inside explicit boundaries. For BO7 sales, that means every action maps to a real available tool, and every ambiguous decision routes to a person.
Fintalio exposes MCP capabilities through the site’s MCP interface, allowing builders to connect agent workflows to LinkedIn sales operations without relying on unsupported scraping or invented inbox actions.
The only MCP tools a BO7 sales agent should use
A safe BO7 sales implementation depends on a constrained tool surface. The following 19 MCP tools are the verified set for this workflow:
ListContactsGetContactListContactGroupsListSequencesGetSequenceListSequenceTemplatesGetSequenceTemplateListVariablesGetAccountStatusCreateContactGroupUpdateContactPauseSequenceResumeSequenceStopSequenceParseCsvCommitCsvCreateSequenceTemplateCreateContactLaunchSequence
This constraint is important. A robust sales agent should not assume that unsupported capabilities exist. It should not design workflows around profile search, inbox reading, post publishing, feed reading, profile scraping, advanced search, message sending as a standalone tool, or webhook subscription if those tools are not available.
Instead, the agent should build its BO7 sales workflow around contacts, groups, sequences, templates, variables, account status, CSV operations, and lifecycle controls.
Step 1: Define the ICP and contact universe
The first BO7 step is defining who should enter the system.
For AI engineers, this should be modeled as policy rather than prose. The agent needs machine-readable rules, such as:
ICP rules:
- Company size: 50 to 500 employees
- Geography: selected markets only
- Role: VP Sales, Head of Growth, Founder, Revenue Operations
- Exclusions: existing customers, active opportunities, competitors
- Required fields: first name, last name, LinkedIn profile, company
The agent’s job is not to invent the ICP. A human should define it. The agent can then enforce it when processing contacts.
In this stage, tools such as ListContacts, GetContact, and ListContactGroups help the agent understand what already exists. If the team needs a new segment, CreateContactGroup can create a group for a specific campaign or market.
Example flow:
Human defines ICP
|
v
Agent lists existing groups
|
v
Agent checks whether target group exists
|
+--> If not, CreateContactGroup
|
v
Contacts are assigned or prepared for import
This is the first expression of the 80/20 rule. The human defines the market. The agent handles the operational work of checking, grouping, and preparing records.
Step 2: Parse and clean contact data
Most outbound operations fail because data quality is treated as an afterthought. In BO7 sales, contact data must be normalized before outreach begins.
The MCP tools ParseCsv and CommitCsv are central here. The agent can parse imported CSV files, inspect columns, detect missing required values, and prepare records for commitment.
A practical CSV validation policy may include:
- Required fields must be present
- Names should be separated into first and last name
- Company names should not be empty
- LinkedIn profile references should match expected formatting
- Duplicate contacts should be flagged before commitment
- Contacts missing key fields should be routed to a review queue
The architecture is straightforward:
CSV upload
|
v
ParseCsv
|
v
Agent validates required fields
|
+--> Clean enough: CommitCsv
|
+--> Ambiguous: human review
This stage is boring, repetitive, and extremely valuable. It is exactly where an agent should spend time. Humans should not be manually scanning rows unless the agent finds a judgment-heavy exception.
Step 3: Enrich context using existing contact and variable data
BO7 sales does not require the agent to scrape or search profiles. It can use available contact data and defined variables to personalize within safe limits.
The tools GetContact and ListVariables allow the agent to understand what information exists and what can be inserted into templates. For example, variables may support controlled personalization such as first name, company, role, segment, or campaign-specific fields.
A strong agent should distinguish between:
- Verified contact data, safe to use
- Missing data, should not be guessed
- Ambiguous data, should be routed for review
- Personalization variables, allowed in templates
- Strategic claims, should require human approval
This prevents one of the most common AI sales problems: confident fabrication. A BO7 sales agent should never invent a business trigger, pretend to know a pain point, or create unsupported personalization.
Useful agent policy:
If field exists and is verified:
use it in template variables
If field is missing:
fall back to generic approved copy
If field is ambiguous:
flag for human review
If claim affects credibility:
require approval
The best sales agents are not the most creative. They are the most reliable under constraints.
Step 4: Create and manage sequence templates
Sequence templates are the reusable operating system of BO7 sales. They define the messaging structure before outreach starts.
The relevant tools are:
ListSequenceTemplatesGetSequenceTemplateCreateSequenceTemplateListVariables
An AI agent can list existing templates, inspect their structure, compare them against campaign requirements, and create a new template when appropriate. However, the human should approve any net-new messaging that could affect brand, compliance, or positioning.
A useful workflow:
Campaign brief
|
v
Agent checks existing templates
|
+--> Matching template exists: GetSequenceTemplate
|
+--> No match: draft template structure
|
v
Human approval
|
v
CreateSequenceTemplate
In BO7 sales, templates should be modular. A sequence template might include:
- A short connection-oriented opening
- A value proposition tied to the segment
- A low-friction call to action
- A follow-up that references the prior touch
- A final close-out message
The agent can retrieve templates and match them to contact groups. The human handles message-market fit.
This is another 80/20 boundary. Agents can manage structure and consistency. Humans should own positioning, nuance, and final approval.
Step 5: Launch controlled LinkedIn sequences
Once contacts, groups, variables, and templates are ready, the agent can use LaunchSequence to start outreach.
This is where architecture discipline matters. The sequence should run through the platform’s LinkedIn infrastructure, using a hosted LinkedIn relay or first-party session model. The agent should not attempt to improvise unsupported actions.
A controlled launch flow:
Contact group ready
|
v
Template selected
|
v
Variables checked
|
v
Account status checked
|
v
Human approval gate, if required
|
v
LaunchSequence
Before launch, the agent should call GetAccountStatus. If the account state indicates a problem, the launch should not proceed. The agent should pause and escalate.
A launch policy might say:
Before LaunchSequence:
- Confirm group exists
- Confirm template exists
- Confirm required variables are available
- Confirm account status is acceptable
- Confirm campaign has approval
BO7 sales is not “send as much as possible.” It is controlled outbound. The goal is predictable execution without creating operational risk.
Step 6: Monitor sequence state and intervene safely
After launch, the agent’s work becomes operational monitoring.
Relevant tools include:
ListSequencesGetSequencePauseSequenceResumeSequenceStopSequenceGetAccountStatus
The agent can check active sequences, inspect their state, and decide whether a sequence should continue. It can pause sequences when there is uncertainty, resume them when a human approves, or stop them when a campaign is no longer valid.
Common reasons to pause or stop include:
- ICP definition changed
- Contact group contains questionable records
- Account status needs attention
- Campaign messaging is being revised
- Human sales team wants to prioritize a different segment
- Compliance or brand review is required
Monitoring architecture:
Scheduled agent check
|
v
ListSequences
|
v
GetSequence for active campaigns
|
v
Evaluate policy
|
+--> Healthy: continue
|
+--> Needs review: PauseSequence
|
+--> Invalid campaign: StopSequence
|
+--> Approved recovery: ResumeSequence
This is where an AI agent creates real RevOps leverage. It does not need to close deals. It simply needs to keep the sales machine clean, current, and controlled.
Step 7: Hand off the judgment-heavy 20%
The final BO7 sales step is escalation. The agent should not try to resolve every situation.
Human review is required when:
- A strategic account enters the campaign
- The prospect context is ambiguous
- Messaging requires legal or compliance review
- A campaign underperforms and needs repositioning
- A senior buyer needs a tailored approach
- The agent detects conflicting data
- A sequence should be stopped for business reasons
The handoff should include concise context:
Escalation package:
- Contact or group affected
- Sequence name
- Template used
- Reason for escalation
- Recommended next action
- Risk level
This keeps humans focused on high-value decisions rather than administrative cleanup.
In practical terms, the BO7 sales split looks like this:
Agent-owned 80%:
- Contact listing
- Group creation
- CSV parsing
- CSV committing
- Template retrieval
- Variable checks
- Sequence launch
- Sequence monitoring
- Pause, resume, stop controls
Human-owned 20%:
- ICP strategy
- Messaging approval
- Exception handling
- Relationship judgment
- Compliance decisions
- Account prioritization
That division is healthier than pretending AI can replace the entire sales function. It also gives developers a clearer implementation target.
Example BO7 sales workflow using MCP tools
A complete agent workflow could look like this:
1. ListContactGroups
2. CreateContactGroup, if campaign group does not exist
3. ParseCsv
4. Validate parsed rows against ICP rules
5. CommitCsv, if validation passes
6. ListSequenceTemplates
7. GetSequenceTemplate
8. ListVariables
9. GetAccountStatus
10. LaunchSequence
11. ListSequences
12. GetSequence
13. PauseSequence, ResumeSequence, or StopSequence based on policy
A more detailed policy version:
IF campaign_group_missing:
CreateContactGroup
IF csv_uploaded:
ParseCsv
IF required_fields_valid:
CommitCsv
ELSE:
escalate_to_human
IF template_needed:
ListSequenceTemplates
IF matching_template_found:
GetSequenceTemplate
ELSE:
request_human_approval
CreateSequenceTemplate
BEFORE launch:
ListVariables
GetAccountStatus
IF account_ok AND approval_ok:
LaunchSequence
ELSE:
escalate_to_human
AFTER launch:
ListSequences
GetSequence
IF risk_detected:
PauseSequence
IF campaign_invalid:
StopSequence
IF human_approves_recovery:
ResumeSequence
This type of deterministic tool choreography is usually more valuable than a highly autonomous but unpredictable agent.
BO7 sales cost model for AI outbound teams
Cost planning should be honest. BO7 sales is not free to implement, even when the product pricing is simple.
Fintalio uses a single €69 per month plan. There is no free tier and no usage-based pricing tier. That makes the platform layer easier to forecast.
However, total cost depends on the broader stack. A realistic comparison should use ranges, not false precision:
| Category | Typical monthly range | Notes |
|---|---|---|
| Fintalio platform plan | €69 | Single plan, no free tier, no usage-based tiers |
| Generic LinkedIn automation tools | €50 to €250 per seat | Often focused on UI workflows rather than agent orchestration |
| CRM plus sales engagement stack | €100 to €600 per user | Depends heavily on vendor bundle and seats |
| Custom internal automation | €500 to €5,000+ in engineering time equivalent | Varies by maintenance burden, infrastructure, and compliance controls |
| Data providers | €50 to €1,000+ | Depends on geography, volume, and enrichment needs |
The main economic advantage of BO7 sales is not just software cost. It is operational compression. An agent can run repetitive sales operations continuously, while humans spend time on judgment-heavy work.
For a small technical team, the most important question is not “Which tool sends the most?” It is “Which system lets an agent safely execute the boring 80% without creating cleanup work?”
Common implementation mistakes
Mistake 1: Designing around tools that do not exist
Developers sometimes sketch an idealized agent with profile search, inbox reading, feed scraping, or posting capabilities. That creates brittle designs.
A better approach is to start from the verified tool list and design the workflow around actual operations: contacts, groups, templates, variables, CSV, account status, and sequence lifecycle.
Mistake 2: Letting the agent invent personalization
Personalization should be based on available, verified fields. If the agent does not have a fact, it should not manufacture one.
Safe personalization beats fake relevance.
Mistake 3: Skipping account status checks
GetAccountStatus should be part of the pre-launch and monitoring workflow. If account state is not acceptable, the agent should pause and escalate.
Mistake 4: Treating BO7 sales as full autonomy
A good BO7 implementation is semi-autonomous. The agent runs the process, but humans approve sensitive decisions.
Mistake 5: No pause or stop logic
A sales agent without PauseSequence, ResumeSequence, and StopSequence policies is incomplete. Safe intervention is part of the system, not an afterthought.
Security, compliance, and operational boundaries
BO7 sales should be designed with clear boundaries from the beginning.
Important controls include:
- Explicit approval gates for new templates
- Audit-friendly sequence lifecycle decisions
- Human review for ambiguous contacts
- Conservative variable usage
- Account status checks before launch
- Controlled use of hosted LinkedIn relay infrastructure
- No unsupported scraping assumptions
- No fabricated prospect insights
The safest agent is not the one with the most freedom. It is the one with the clearest operating envelope.
A practical control model:
Low-risk operations:
- ListContacts
- GetContact
- ListVariables
- ListSequenceTemplates
- GetSequenceTemplate
Medium-risk operations:
- CreateContact
- UpdateContact
- CreateContactGroup
- CommitCsv
High-impact operations:
- CreateSequenceTemplate
- LaunchSequence
- PauseSequence
- ResumeSequence
- StopSequence
High-impact operations should have stricter policy checks. Some teams may require human approval before every launch. Others may allow launches only for pre-approved templates and contact groups. The right model depends on risk tolerance and sales maturity.
How BO7 sales fits into RevOps
RevOps teams care about repeatability, visibility, and control. BO7 sales supports all three.
Repeatability comes from sequence templates, contact groups, variables, and defined workflows.
Visibility comes from listing contacts, groups, sequences, templates, and account status.
Control comes from pause, resume, stop, and human approval gates.
The result is not a magic pipeline machine. It is a cleaner operating layer for outbound sales. That is often more valuable than aggressive automation because it reduces inconsistency and rework.
For developers, the best implementation is one that RevOps can understand. The workflow should be explainable in plain language:
The agent imports contacts, checks data quality, assigns them to groups,
selects approved templates, confirms account status, launches sequences,
monitors campaign state, and escalates exceptions.
If the RevOps owner cannot audit the workflow, the agent is too opaque.
FAQ
1. What is BO7 sales?
BO7 sales is a practical seven-step outbound framework for running structured sales operations. In an AI agent context, it covers ICP definition, contact grouping, CSV processing, template management, sequence launch, monitoring, and human escalation.
2. Can an AI agent fully automate BO7 sales?
It can automate much of the operational 80%, such as contact processing, sequence setup, and monitoring. The judgment-heavy 20%, including strategy, messaging approval, compliance decisions, and important account handling, should remain human-owned.
3. Which MCP tools are available for BO7 sales workflows?
The verified tools are ListContacts, GetContact, ListContactGroups, ListSequences, GetSequence, ListSequenceTemplates, GetSequenceTemplate, ListVariables, GetAccountStatus, CreateContactGroup, UpdateContact, PauseSequence, ResumeSequence, StopSequence, ParseCsv, CommitCsv, CreateSequenceTemplate, CreateContact, and LaunchSequence.
4. How much does Fintalio cost?
Fintalio has a single €69 per month plan. There is no free tier and no usage-based pricing tier.
5. What is the safest way to launch BO7 sales sequences?
The safest approach is to validate contact data, use approved sequence templates, check variables, confirm account status, require human approval where needed, then launch with LaunchSequence. After launch, the agent should monitor campaigns and use pause, resume, or stop controls when policy requires it.
Build BO7 sales agents with Fintalio
BO7 sales works best when autonomous agents are given clear tools, strict boundaries, and a human-in-the-loop model. Fintalio gives developers and AI engineers a practical way to connect agents to LinkedIn sales operations through the platform’s MCP interface, using a predictable €69 per month plan.
To explore the MCP capabilities and start designing controlled outbound workflows, visit Fintalio and review the MCP interface.
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