---
name: linkedin-outbound-first-touch
description: >-
  Tool-agnostic methodology for the first outbound touch on LinkedIn: defining an
  ICP, segmenting a target list, personalizing at the right depth, writing the
  first connection note or message, sequencing a polite follow-up cadence, and
  knowing when to stop. Use when planning or running first-contact outreach to
  people you are not yet connected with, when someone asks how to structure an
  outbound sequence, cold connect notes, opener messages, or follow-ups, or when
  turning a raw list of prospects into a staged, limit-aware first-touch workflow.
  Not an API reference — for tool arguments and contracts, defer to the Linbox
  messaging, connections, tags, and enrichment topic skills.
contract_version: "3.0"
---

# LinkedIn Outbound: First Touch

The method for making a **first contact** with people you are not connected with:
qualify who is worth reaching, personalize the opener, send a connect request or
first message, follow up a bounded number of times, and stop cleanly. This is a
**methodology** playbook — it decides *what* to do and *when*. For *how* to call a
tool, defer to the Linbox topic skills (see [Tools](#tools) and
[Related skills](#related-skills)).

## When to use

- Starting outreach to people you are **not yet connected with** (1st touch).
- Turning a raw list of prospects into a staged connect → message → follow-up flow.
- Deciding whether to lead with a connection request or a direct message.
- Writing a first connect note or opener, and planning the follow-up cadence.
- Deciding when to stop chasing a non-responder.

Do **not** use this for replying inside an existing conversation, re-engaging an old
thread, or a single one-off action — go straight to
[Messaging](../../linbox/messaging/SKILL.md).

## Prerequisites

- The [root Linbox skill](../../linbox/SKILL.md) contract applies: an MCP token
  scoped to one LinkedIn `account_id` and a connected client.
- A defined **offer** and **target audience** — you cannot personalize without knowing
  who you serve and the value you bring.
- A source of targets (profile URLs or an already-synced list of personas).

## Tools

This playbook owns no tools. It composes Linbox capabilities through the topic skills.
Resolve tool names, arguments, and edge cases there — never restate them here.

| Step needs | Topic skill |
|---|---|
| Enrich a profile/company before writing | [Enrichment](../../linbox/enrichment/SKILL.md) |
| Send / accept / withdraw a connection invite | [Connections](../../linbox/connections/SKILL.md) |
| Send the first message, read/search threads | [Messaging](../../linbox/messaging/SKILL.md) |
| Tag targets by segment and track state | [Tags](../../linbox/tags/SKILL.md) |

## Workflow

Copy this checklist and track progress:

```
First-touch progress:
- [ ] 1. Define the ICP
- [ ] 2. Segment the target list
- [ ] 3. Enrich each target
- [ ] 4. Choose the entry path (connect vs message)
- [ ] 5. Personalize the opener
- [ ] 6. Send the first touch
- [ ] 7. Follow up on cadence
- [ ] 8. Stop and record outcome
```

### 1. Define the ICP

Write the Ideal Customer Profile before touching anyone. Keep it to a few concrete
filters you can actually check on a profile:

- **Firmographics**: company size, industry, region, growth stage.
- **Role**: title / seniority / function that owns the problem you solve.
- **Trigger / fit signal**: a reason *now* (hiring, new role, funding, tech in use,
  recent post). A trigger is what makes a cold touch feel relevant.
- **Disqualifiers**: who to skip (competitors, wrong region, students, already customers).

If a target does not match the ICP, drop it — do not "stretch" the message to fit.

### 2. Segment the target list

Group targets so each group gets one message angle. Segment by role, industry, or
trigger — whatever changes the value proposition. Attach a segment tag to each target
via [Tags](../../linbox/tags/SKILL.md) so you can search, batch, and report by segment
later. One angle per segment; do not mix segments into one generic blast.

### 3. Enrich each target

Before writing, pull enough context to personalize truthfully. Use
[Enrichment](../../linbox/enrichment/SKILL.md) to scrape the profile (and company page
when the angle is firm-level). Capture: name, current role/company, a recent
signal, and connection degree. If the target is already 1st-degree, skip the connect
step and go straight to a message.

### 4. Choose the entry path

| Situation | Entry path |
|---|---|
| Not connected, want a durable relationship | Connection request, note **optional** |
| Not connected, message is genuinely specific | Connect request **with** a short note |
| Already 1st-degree connection | Direct first message, no invite |

Prefer a **note-less** or **very short** connect request when the note would just be
filler — a bloated note lowers acceptance. Save the real pitch for after they accept.
The connect note has a hard length cap; treat it as one sentence, not a paragraph.

### 5. Personalize the opener

Match personalization depth to the segment's value. Every opener should pass:

- **Relevance**: one specific, verifiable detail about *them* (role, post, company move).
- **Reason**: why you are reaching *them* specifically, now.
- **Respect**: no fake flattery, no "quick question", no immediate ask for their time.
- **Brevity**: short enough to read on a phone without expanding.

Tier the effort: high-value targets get 1:1 research; mid-value get a per-segment
template with a personalized first line; never send a fully generic message.

### 6. Send the first touch

Send via the topic skill for the chosen path
([Connections](../../linbox/connections/SKILL.md) for invites,
[Messaging](../../linbox/messaging/SKILL.md) for messages). Capture the returned
`task_id` / `batch_id` and poll to a terminal state. **Queued or deferred is normal**,
not an error — limits and work-hours can defer a send. Tag the target as `touched` /
its segment so the list stays auditable.

### 7. Follow up on cadence

If there is no reply, follow up a **bounded** number of times, spaced out, each adding
new value — never "just bumping this". A sane default cadence:

| Touch | Timing | Content |
|---|---|---|
| 1 | Day 0 | Opener (connect note or first message) |
| 2 | +3–4 days after accept / no reply | New angle or a concrete useful resource |
| 3 | +7 days | Short, low-pressure final check-in |

Cap at **3 total touches**. Space follow-ups by days, not hours. If they accepted a
connect but never replied, the follow-up runs in the resulting thread via
[Messaging](../../linbox/messaging/SKILL.md).

### 8. Stop and record outcome

Stop and tag the outcome at any of these **stop conditions**:

- **Replied** → hand off to the conversation; leave this playbook.
- **Connected but silent after 3 touches** → stop; tag `no-reply`.
- **Invite ignored / still pending** after the cadence window → optionally withdraw via
  [Connections](../../linbox/connections/SKILL.md); tag `no-response`.
- **Explicit "no" / not interested** → stop immediately; tag `disqualified`.
- **`already_connected`** on a connect attempt → skip invite, go to message step.
- **Task fails** → read `guidance`, fix, and retry once; do not loop.

Always record the terminal state as a tag so a target is never touched twice by mistake.

## Rules

- **ICP first.** No message goes out to a target that fails the ICP. Drop, don't stretch.
- **One angle per segment.** Personalize per person, but keep one value proposition per
  segment.
- **Lead with value, not an ask.** The first touch earns attention; it does not book a
  meeting. No calendar links in touch 1.
- **Bounded follow-ups.** Max 3 touches, spaced by days, each adding something new.
- **Respect limits.** Deferred / queued sends are expected — never retry-spam to force a
  send; let the worker honor per-account limits.
- **Keep connect notes short or empty.** Do not pad them to hit the character cap.
- **Tag every state transition** so the list is idempotent and reportable.
- **Compose, don't duplicate.** This playbook never restates tool signatures, `meta`
  shapes, or pagination — link to the topic skill.
- **English-only tool names**: use the exact `linbox_*` names defined in the topic skills.

## Examples

**Batch first touch to a not-connected list**

```
Request: "Reach out to these 25 heads of sales we're not connected with."
1. ICP check: keep seniority=head/VP, function=sales, drop wrong-region → 21 remain.
2. Segment: split by industry (SaaS vs services); tag each.
3. Enrich each profile; note a recent hire/post per person.
4. Entry path: not connected → connection request, note-less for most.
5. After accepts, first message per segment with a personalized first line.
6. Follow up twice (day +3, day +7), then stop.
```

**Already connected**

```
Target is 1st-degree (already_connected).
→ Skip the invite. Go straight to a personalized first message via Messaging.
```

**Short connect note (good vs bad)**

```
Good: "Hi Dana — saw you're scaling the SDR team at Acme; would value trading notes."
Bad:  "Hi, I'd love to connect and explore synergies and see how we can add value to
       your business with our platform and book 15 minutes on your calendar..."
```

**Follow-up that adds value**

```
No reply after connect.
Bad:  "Just bumping this to the top of your inbox!"
Good: "Shared a 2-min teardown of how a similar team cut SDR ramp time — useful?"
```

## Related skills

- [Playbooks index](../SKILL.md) — how playbooks relate and how to pick one.
- [Linbox (root)](../../linbox/SKILL.md) — global contract; read this first.
- [Enrichment](../../linbox/enrichment/SKILL.md) — profile/company scraping for personalization.
- [Connections](../../linbox/connections/SKILL.md) — send/accept/withdraw invites.
- [Messaging](../../linbox/messaging/SKILL.md) — first message, threads, search, follow-ups.
- [Tags](../../linbox/tags/SKILL.md) — segment tags and outcome tracking.