# Set up Wannalead

Wannalead gives your AI agent live LinkedIn capabilities — find who to contact,
understand why now, and send the message — from the user's own LinkedIn account,
over a workspace-scoped HTTPS API. Do this setup yourself; do not ask the user to
run terminal commands.

## 0. First, identify where you run

The setups differ, and the wrong one cannot work.

- **Hosted assistant without code execution** (claude.ai, Claude Desktop chat, ChatGPT):
  install nothing, and do not use an API key, even if the user pasted one: a
  hosted connector signs in with OAuth. Tell the user, in three steps:
  1. Open Settings, then Connectors, then add a custom connector.
  2. Paste the URL `https://wannalead.co/mcp` and approve the Wannalead sign-in.
  3. Start a new chat and ask for the task again.
  Then stop. In that new chat, the connector gives you the Wannalead tools and
  `wannalead_get_skill` serves the skills.
- **Local coding agent** (Claude Code, Codex, Cursor, opencode on the user's
  machine): the user has authorized the whole flow. Continue with step 1.
- **Sandboxed agent** (claude.ai or Claude Desktop with code execution, Cowork,
  a cloud container with restricted network): try step 1 once. If
  `wannalead.co` is blocked (proxy 403, DNS failure, timeout), do not retry and
  do not try other hosts. Offer the user two ways past it:
  1. Allow the domain: add `wannalead.co` to the allowed domains of code
     execution (claude.ai: Settings, then Capabilities; on a Team or Enterprise
     plan, an admin does it). Then retry step 1 in a new chat. The install
     lasts for that session only, so it runs again in each new one, with the
     same key.
  2. Install the MCP connector, which persists across chats and needs no key:
     open Settings, then Connectors, add a custom connector with the URL
     `https://wannalead.co/mcp`, approve the Wannalead sign-in, then start a
     new chat and ask for the task again.

## 1. Install the CLI, agent skills and MCP

With the API key the user gave you (it starts with `wlk_`):

    curl -fsSL https://wannalead.co/launch.sh | bash -s -- --agent --token wlk_...

This installs the `wannalead` CLI to `~/.local/bin`, saves the key, copies the
Wannalead skills into every detected agent (Claude Code, Codex, Cursor, GitHub
Copilot, opencode) and registers the MCP server `https://wannalead.co/mcp` with
Claude Code, Codex, Cursor and opencode. If `~/.local/bin` is not on your PATH,
add it. Never print the key, put it in a URL, or commit it to a repository.

No key yet? Send the user to https://wannalead.co/sign-in to create a workspace and
connect LinkedIn, then come back with the key shown at the end of onboarding.

Agents load a new MCP server on their next start. Until then, use the CLI in
this session.

## 2. Load the skills

Invoke the core `wannalead` skill, then the `wannalead-onboarding` skill
(Claude Code: the Skill tool or `/wannalead-onboarding`; Codex:
`$wannalead-onboarding`). Onboarding identifies the account and loads the saved
commercial context. It never blocks the user's task: incomplete context is
built up progressively.

If those skills are not visible in this session (they were installed just
now), fetch them and follow them as if they were installed:

    wannalead skills get wannalead --full

This prints the core skill together with `wannalead-onboarding` and
`endpoints`. Before a task, load its skill the same way, for example
`wannalead skills get campaign-automation`.

## 3. Run onboarding

The first authenticated call must be:

    wannalead me

Then follow `wannalead-onboarding`: load the workspace context it names for
the returned LinkedIn identifier and continue with the user's request, even if
that context is incomplete. Before any business call, inspect the endpoint
catalogue and the exact OpenAPI contract for the endpoint you plan to use.

## 4. Show a result, not an install log

Tell the user in one line which LinkedIn account and Wannalead workspace are
connected. When the user has not named a task, offer the six use cases (the
`wannalead-use-cases` skill carries the menu and the skill to load for each)
and propose to run one on their own data:

1. Lookalikes with signals: describe the ICP, get every lookalike profile with
   the signals that matter (tools in use, posts, job changes).
2. Campaigns: from the user's context and writing style, draft the messages and
   run sends and follow-ups.
3. Dormant conversations: revisit LinkedIn threads left without a reply and
   follow up on leads that went quiet.
4. Dormant network: surface first-degree connections never contacted and
   propose an approach.
5. Saved post to ICP: the user saves a post whose engagers look like the
   target; pull them and keep those matching the ICP.
6. Messy list to contacts: reconcile a rough CSV of companies with LinkedIn and
   list the people to contact in each.

## Reference

- Core skill: https://wannalead.co/.well-known/skills/wannalead/SKILL.md
- Onboarding skill: https://wannalead.co/.well-known/skills/wannalead-onboarding/SKILL.md
- Endpoints skill: https://wannalead.co/.well-known/skills/endpoints/SKILL.md
- Skills index: https://wannalead.co/.well-known/skills/index.json
- Endpoint catalogue: https://wannalead.co/v1/endpoints
- OpenAPI contract: https://wannalead.co/openapi.json
- Machine index: https://wannalead.co/llms.txt

## Safety

Every LinkedIn write runs on the user's own account and is hard-capped well under
LinkedIn's own thresholds. Never send invitations or messages without the user's
explicit approval. Before a loop of writes or a paid call, tell the user how many
actions or how much it costs.
