ATT Sales Dashboard: An Agent-Ready Blueprint for LinkedIn-Led Revenue Workflows
An att sales dashboard should show activity, touchpoints, and transitions in a way that autonomous agents can act on safely. The agent handles the boring 80 percent, list parsing, contact creation, se...
ATT Sales Dashboard: An Agent-Ready Blueprint for LinkedIn-Led Revenue Workflows
Author: Fintalio
TL;DR
An att sales dashboard should show activity, touchpoints, and transitions in a way that autonomous agents can act on safely. The agent handles the boring 80 percent, list parsing, contact creation, sequence launch, status checks, and updates. Humans handle the judgment-heavy 20 percent, targeting, messaging strategy, exception review, and relationship decisions.
What Is an ATT Sales Dashboard?
An att sales dashboard is a revenue operations control layer that tracks three things:
- Activity: what the system or seller has done, such as contact creation, sequence launch, or sequence pause.
- Touchpoints: where prospects are in outreach flows, especially LinkedIn-led engagement through a hosted LinkedIn relay or first-party session.
- Transitions: when records move from one operational state to another, such as imported, validated, sequenced, paused, resumed, stopped, or updated.
For developers and AI engineers building autonomous agents, the dashboard should not be a decorative reporting screen. It should be an execution map. It should show what the agent can do, what it has done, what is blocked, and what requires human judgment.
The 80/20 rule is the right operating model. The agent should run the repetitive 80 percent: parse a CSV, create contacts, group contacts, launch a sequence, check account status, pause or resume a campaign, and update records. The human should own the meaningful 20 percent: qualification logic, offer design, account prioritization, tone, exceptions, and final review.
This distinction matters because an autonomous sales system without boundaries becomes brittle. A dashboard without execution primitives becomes vanity analytics. An att sales dashboard should sit between those two extremes.
Why ATT Matters for Agentic Sales Systems
Many sales dashboards were designed for managers looking backward. They summarize pipeline, activity volume, conversion, and rep performance. That is useful for a sales manager, but it is not enough for an autonomous agent.
An agent needs an operational dashboard that answers more immediate questions:
- Which contacts are eligible for the next step?
- Which sequence is active?
- Which contacts need updates?
- Which account status prevents execution?
- Which records failed parsing or import?
- Which sequence should be paused, resumed, or stopped?
- Which tasks require human approval?
In other words, the dashboard is not just a report. It is a state machine.
For AI engineers, this is the central design shift. Instead of asking, “What happened last week?”, the dashboard should ask, “What state is each revenue object in, and what safe action is available next?”
That is where MCP matters. The Model Context Protocol defines a way for AI applications to connect to tools and context through a common interface, as described in the official Model Context Protocol introduction. In a sales environment, MCP-style tooling gives an agent structured capabilities instead of uncontrolled browser behavior.
Fintalio exposes an MCP interface for sales automation at MCP, allowing developers to build agents around verified tool calls rather than improvised scraping or fragile UI automation.
The Core ATT Data Model
An att sales dashboard should start with a clean object model. The simplest version contains six entities:
+------------------+
| Account Status |
+------------------+
|
v
+------------------+ +------------------+
| Contact Groups | ----> | Contacts |
+------------------+ +------------------+
| |
v v
+------------------+ +------------------+
| Sequences | ----> | Sequence State |
+------------------+ +------------------+
|
v
+------------------+
| Templates |
+------------------+
Each entity should answer one operational question.
1. Account Status
Account status determines whether the agent can act. Before launching outreach, the agent should check whether the connected account is ready.
Relevant MCP tool:
GetAccountStatus
This is a gatekeeper. If the account is not in a valid state, the dashboard should show a blocked status rather than allowing the agent to attempt downstream actions.
2. Contacts
Contacts are the atomic unit of execution. The dashboard should show enough metadata for safe automation, but not so much that it becomes a mini-CRM.
Relevant MCP tools:
ListContactsGetContactCreateContactUpdateContact
The agent should handle the repetitive 80 percent: creating records, updating fields, and checking contact details. The human should review the 20 percent that affects positioning, fit, and risk.
3. Contact Groups
Groups are operational segments. They may represent imported lists, audience cohorts, territory batches, campaign groups, or qualification buckets.
Relevant MCP tools:
ListContactGroupsCreateContactGroup
A dashboard should show group size, import status, sequence assignment, and whether the group is ready for action.
4. Sequences
Sequences define the outreach flow. In a LinkedIn-led workflow, the sequence is the agent’s execution plan, not just a campaign label.
Relevant MCP tools:
ListSequencesGetSequenceLaunchSequencePauseSequenceResumeSequenceStopSequence
The dashboard should make sequence state visible and auditable. If a sequence is paused, the system should show why. If it is resumed, the system should show who or what resumed it.
5. Sequence Templates
Templates provide reusable structure. They help standardize outreach while leaving room for human judgment.
Relevant MCP tools:
ListSequenceTemplatesGetSequenceTemplateCreateSequenceTemplate
The agent can use templates to create repeatable workflows. Humans should still own the message strategy, relevance logic, and prospect-specific nuance.
6. Variables
Variables make templates dynamic. They allow personalization without requiring the agent to rewrite every message from scratch.
Relevant MCP tool:
ListVariables
Variables should be visible in the dashboard because missing variables often cause execution errors or poor personalization.
Where CSV Import Fits
Most sales teams still move data through spreadsheets. An honest RevOps architecture should accept that reality instead of pretending every workflow begins in a pristine data warehouse.
An att sales dashboard should support a CSV staging flow:
+-------------+ +-------------+ +--------------+ +-------------+
| CSV Upload | --> | ParseCsv | --> | Human Review | --> | CommitCsv |
+-------------+ +-------------+ +--------------+ +-------------+
| |
v v
Validation Errors Approved Records
Relevant MCP tools:
ParseCsvCommitCsv
The 80/20 split is especially important here.
The agent should handle:
- Column recognition
- Basic validation
- Duplicate detection logic where supported by the workflow
- Formatting checks
- Staging records for review
The human should handle:
- Whether the list should be used
- Whether the source is appropriate
- Whether the segment is strategically sound
- Whether messaging should change for this audience
- Whether risk or compliance considerations apply
The dashboard should not allow blind CSV-to-sequence automation without review gates. That might feel efficient in a demo, but it creates operational risk in real revenue workflows.
For adjacent use cases such as automotive outreach, the same principle applies to driven auto sales: automate repetitive list and follow-up operations, but keep humans responsible for judgment-heavy interactions.
Recommended Architecture for an ATT Sales Dashboard
A practical architecture has four layers:
- UI dashboard
- Agent orchestration layer
- MCP tool layer
- Platform LinkedIn infrastructure
+--------------------------------------------------+
| ATT Sales Dashboard UI |
| - State views |
| - Review queues |
| - Exceptions |
| - Human approvals |
+---------------------------+----------------------+
|
v
+--------------------------------------------------+
| Agent Orchestration Layer |
| - Policy checks |
| - Task planning |
| - Tool selection |
| - Retry logic |
| - Audit log |
+---------------------------+----------------------+
|
v
+--------------------------------------------------+
| MCP Tool Layer |
| ListContacts, GetContact, CreateContact |
| UpdateContact, ListSequences, LaunchSequence |
| PauseSequence, ResumeSequence, StopSequence |
| ParseCsv, CommitCsv, and related verified tools |
+---------------------------+----------------------+
|
v
+--------------------------------------------------+
| Platform LinkedIn Infrastructure |
| - Hosted LinkedIn relay |
| - First-party session |
| - Account status checks |
+--------------------------------------------------+
This architecture avoids a common mistake: putting too much intelligence in the UI. The dashboard should display state, allow review, and trigger approved actions. The orchestration layer should decide how to break work into safe steps. The MCP tool layer should enforce what the agent can actually do.
A good agent should not “figure out” how to interact with LinkedIn pages. It should use the platform’s LinkedIn infrastructure through structured capabilities. That makes the system easier to test, monitor, and constrain.
The 19 Verified MCP Tools for ATT Workflows
The dashboard should be designed around the actual tool surface. For this use case, the verified MCP tools are:
ListContactsGetContactListContactGroupsListSequencesGetSequenceListSequenceTemplatesGetSequenceTemplateListVariablesGetAccountStatusCreateContactGroupUpdateContactPauseSequenceResumeSequenceStopSequenceParseCsvCommitCsvCreateSequenceTemplateCreateContactLaunchSequence
The restriction is a strength. Agents perform better when their action space is explicit. Instead of giving an agent broad, ambiguous abilities, the dashboard should expose narrow, auditable actions.
A practical dashboard can group these tools into five work zones:
+----------------------+---------------------------------------------+
| Work Zone | MCP Tools |
+----------------------+---------------------------------------------+
| Read State | ListContacts, GetContact, ListSequences |
| Import Data | ParseCsv, CommitCsv |
| Manage Contacts | CreateContact, UpdateContact |
| Manage Templates | ListSequenceTemplates, CreateSequenceTemplate|
| Control Sequences | LaunchSequence, PauseSequence, ResumeSequence|
| | StopSequence |
+----------------------+---------------------------------------------+
The dashboard should never imply capabilities outside this tool surface. For example, if the tool layer does not provide a certain action, the UI should not pretend the agent can perform it.
Dashboard Views That Developers Should Build
An agent-ready att sales dashboard should include several operational views.
1. Account Readiness View
Purpose: show whether automation can run.
Key fields:
- Account status
- Last status check
- Blocking condition
- Recommended next step
- Human review flag
Primary tool:
GetAccountStatus
This view prevents silent failure. Before the agent parses lists or launches sequences, it should confirm account readiness.
2. Contact Operations View
Purpose: show contact state and eligibility.
Key fields:
- Contact identifier
- Group
- Sequence assignment
- Current state
- Required variables
- Last update
- Error state, if any
Primary tools:
ListContactsGetContactCreateContactUpdateContact
The agent can run the boring 80 percent here: load contacts, update fields, and keep records consistent. Humans should review edge cases, questionable fit, or high-value accounts.
3. Group Management View
Purpose: manage operational cohorts.
Key fields:
- Group name
- Group size
- Source
- Import date
- Sequence status
- Approval status
Primary tools:
ListContactGroupsCreateContactGroup
Groups help separate execution batches. That makes it easier to pause or adjust a specific segment without disrupting the whole operation.
4. Sequence Control View
Purpose: manage active outreach operations.
Key fields:
- Sequence name
- Template used
- Contacts enrolled
- State
- Launch date
- Pause reason
- Stop reason
- Human owner
Primary tools:
ListSequencesGetSequenceLaunchSequencePauseSequenceResumeSequenceStopSequence
This is where RevOps honesty matters. A dashboard should make it easy to stop automation when data quality, messaging, or strategy is wrong. Speed is useful only when the system can also slow down safely.
5. Template and Variable View
Purpose: make personalization inspectable.
Key fields:
- Template name
- Template status
- Variables required
- Variables available
- Missing variable warnings
- Approval status
Primary tools:
ListSequenceTemplatesGetSequenceTemplateCreateSequenceTemplateListVariables
Agents are good at filling structured fields. Humans are better at deciding whether a message is appropriate for the audience. The dashboard should support both.
State Machine Design for ATT
A robust dashboard should model states explicitly. A simple contact lifecycle may look like this:
[Imported]
|
v
[Parsed]
|
v
[Reviewed]
|
v
[Committed]
|
v
[Grouped]
|
v
[Ready for Sequence]
|
v
[Launched]
|
+--> [Paused]
| |
| v
| [Resumed]
|
+--> [Stopped]
Each transition should have:
- Trigger
- Actor, agent or human
- Timestamp
- Tool call, if applicable
- Result
- Error details
- Rollback or next action
For example:
Transition: Ready for Sequence -> Launched
Actor: Agent
Required check: Account status valid
Tool: LaunchSequence
Human gate: Required for high-risk groups
Result: Success or failure
This makes the dashboard auditable. It also makes the agent easier to test because each state transition can be validated independently.
Guardrails for Autonomous Sales Agents
An att sales dashboard should not let an agent optimize only for volume. The right guardrails make automation useful without making it reckless.
Recommended guardrails include:
Human Approval Gates
Use approval gates before:
- Committing a new CSV import
- Launching a sequence to a new group
- Resuming a paused sequence after an error
- Creating or changing templates
- Updating sensitive contact fields
Tool-Level Permissions
Not every agent should have access to every tool. A data-prep agent might use ParseCsv and ListVariables, while an execution agent might use LaunchSequence, PauseSequence, and ResumeSequence.
Audit Logs
Every action should be logged with:
- Tool name
- Input summary
- Output summary
- Actor
- Timestamp
- Related contact, group, sequence, or template
- Error message, if applicable
Stop Conditions
The system should pause or stop automation when:
- Account status changes
- Required variables are missing
- CSV validation fails
- Human approval is missing
- Sequence state conflicts with intended action
- Contact data appears incomplete
These controls keep the agent focused on the boring 80 percent while protecting the strategic 20 percent.
Metrics That Actually Help
A traditional sales dashboard might overemphasize activity counts. An ATT dashboard should measure operational health.
Useful metrics include:
Import Quality
- Parsed records
- Records requiring review
- Records committed
- Records rejected
- Missing required fields
Contact Readiness
- Contacts ready for sequence
- Contacts missing variables
- Contacts requiring human review
- Contacts updated by the agent
- Contacts blocked by data issues
Sequence Control
- Sequences launched
- Sequences paused
- Sequences resumed
- Sequences stopped
- Average time in paused state, expressed as a range where precision is not available
Agent Reliability
- Successful tool calls
- Failed tool calls
- Retried actions
- Human escalations
- Blocked actions due to policy
Human Workload
- Approval queue size
- Review time ranges
- Exceptions by type
- Strategic decisions pending
The point is not to make humans disappear. The point is to move humans away from mechanical updates and toward judgment.
Vendor Cost Comparison for ATT-Style Systems
Cost comparisons should use ranges because pricing varies by seat count, contract terms, CRM stack, implementation services, and data requirements.
A typical revenue automation stack may include:
+------------------------------+-----------------------------+
| Category | Common Monthly Cost Range |
+------------------------------+-----------------------------+
| CRM | €20 to €150+ per user |
| Sales engagement platform | €50 to €200+ per user |
| Data enrichment provider | €50 to €300+ per user |
| Workflow automation layer | €20 to €100+ per user |
| Custom agent infrastructure | €100s to €1,000s+ monthly |
| LinkedIn automation tooling | €50 to €250+ per user |
+------------------------------+-----------------------------+
Fintalio uses a single €69 per month plan. There is no free tier and no usage-based pricing tier. For teams building agents, that matters because predictable cost simplifies architecture decisions, testing, and deployment planning.
The lower price does not remove the need for responsible workflow design. It simply makes the execution layer easier to budget.
How to Build the First Version
A strong first version does not need to be complex. It should be narrow, observable, and safe.
Step 1: Define the Agent’s Allowed Work
Start with the 80 percent tasks:
- Check account status
- Parse CSV files
- Stage contacts
- Create contact groups
- Create contacts
- Update contacts
- List available templates
- Launch approved sequences
- Pause, resume, or stop sequences under policy
Do not start with full autonomy. Start with explicit state transitions.
Step 2: Build the Dashboard Around States
Use state labels that operators understand:
- Draft
- Parsed
- Needs Review
- Approved
- Committed
- Ready
- Launched
- Paused
- Resumed
- Stopped
- Error
Then map states to MCP tools.
Parsed + Human Approval -> CommitCsv
Ready + Valid Account -> LaunchSequence
Launched + Risk Signal -> PauseSequence
Paused + Human Approval -> ResumeSequence
Launched + Stop Policy -> StopSequence
Step 3: Separate Read Tools From Write Tools
Read tools are lower risk:
ListContactsGetContactListContactGroupsListSequencesGetSequenceListSequenceTemplatesGetSequenceTemplateListVariablesGetAccountStatus
Write or control tools need stronger governance:
CreateContactGroupUpdateContactPauseSequenceResumeSequenceStopSequenceParseCsvCommitCsvCreateSequenceTemplateCreateContactLaunchSequence
This separation makes policy enforcement easier.
Step 4: Add Human Review Queues
A human review queue should show:
- What the agent wants to do
- Why the agent recommends it
- Which tool will be called
- Which records will be affected
- What can go wrong
- What approval means
This is where the 20 percent belongs.
Step 5: Log Everything
The dashboard should show both business state and technical state. If a tool call fails, the operator should see what failed and why. If the agent stops a sequence, the dashboard should show the policy or condition that caused the stop.
Common Mistakes to Avoid
Mistake 1: Treating the Dashboard as Reporting Only
A reporting-only dashboard cannot guide an autonomous agent. ATT requires state, tools, transitions, and guardrails.
Mistake 2: Automating the Judgment Layer
The agent can update contacts. It should not independently decide the entire go-to-market strategy. Humans should own segmentation, offer logic, message quality, and risk tolerance.
Mistake 3: Hiding Failure States
If a sequence is paused or a CSV import fails, the dashboard should make that visible. Quiet failures create bad data and poor customer experiences.
Mistake 4: Letting Templates Drift
Templates should be inspected and approved. Variables should be checked before launch. Poor personalization at scale is still poor personalization.
Mistake 5: Ignoring Account Status
Before action, the agent should check account readiness. This is basic operational hygiene for workflows using a first-party session and the platform’s LinkedIn infrastructure.
Practical ATT Dashboard Checklist
A production-ready first version should include:
- Account status panel
- Contact list with state filters
- Contact group management
- CSV parse and commit workflow
- Sequence list and detail view
- Pause, resume, stop controls
- Template list and variable visibility
- Human approval queue
- Audit log
- Error state dashboard
- Policy rules for write actions
- Clear split between agent work and human work
The dashboard should make one thing obvious at all times: what the agent is allowed to do next.
FAQ
1. What does “att sales dashboard” mean in this context?
In this article, an att sales dashboard means an activity, touchpoint, and transition dashboard for agentic sales workflows. It tracks operational state across contacts, groups, templates, sequences, imports, and account readiness.
2. Is an ATT dashboard the same as a CRM dashboard?
No. A CRM dashboard usually summarizes pipeline and sales activity. An ATT dashboard is more operational. It shows what an autonomous agent can safely do next and where human review is required.
3. Should the agent launch sequences without human approval?
For low-risk, preapproved workflows, the agent can launch sequences under policy. For new audiences, new templates, sensitive accounts, or uncertain data, human approval should remain in the loop.
4. What MCP tools are needed for the first version?
A practical first version can start with GetAccountStatus, ParseCsv, CommitCsv, CreateContactGroup, CreateContact, UpdateContact, ListSequenceTemplates, ListVariables, and LaunchSequence, then add sequence control with PauseSequence, ResumeSequence, and StopSequence.
5. How much does Fintalio cost?
Fintalio has a single €69 per month plan. There is no free tier and no usage-based pricing tier.
Call to Action
Developers and AI engineers building autonomous sales agents can use Fintalio to connect structured MCP workflows with LinkedIn-led execution through a hosted LinkedIn relay and first-party session model. Visit Fintalio and explore the MCP interface to start designing an ATT sales dashboard that lets agents handle the boring 80 percent while humans own the judgment-heavy 20 percent.
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