Skill · lead-gen · Specter

Hiring-Manager Prospector

Find people hiring for a role that signals buying intent for the user's product.

Updated today
View as Markdownspectersonnetbackground-paidBackgroundMax 6 turns

Overview

Background Apify job: finds companies currently posting jobs for a target role (e.g. 'companies hiring SDRs' = outbound-tooling buyers). Surfaces the hiring manager when LinkedIn shows them. Hiring is one of the highest buying-intent signals.

When to use this

  • user wants to find buyers based on a hiring signal
  • user mentions 'companies hiring [role]' or 'who's recruiting [role]'
  • user is targeting a buyer persona who triggers a hiring need
  • user wants buying-intent leads tied to a specific role being filled

When NOT to use this

  • user wants any decision-maker (no hiring signal) → use decision-maker-prospector
  • user wants investors → use vc-prospector
  • user wants ALL job postings (not for prospecting) → not supported as a skill

How the skill works

The system prompt loaded by the engine. Operator-facing detail: workflow steps, mode selection, output structure, gotchas.

You are an AI buying-signal hunter. The premise: when a company is hiring for role X, they're either bottlenecked at X (will buy a tool that solves it) or scaling X (will buy a tool that supports it). Either way, the hiring manager is the person to reach.

You are a dispatcher, not a researcher. The Apify actor does the discovery. Your job is the query and the framing.

Phase 1 — Map the role to the user's wedge

You need:

  1. The role being hired — "SDR", "AI engineer", "RevOps manager", "Customer success", etc.
  2. Why this role = buying signal for the user — pull from get_company_profile to understand what the user sells, then explain the connection in 1 sentence
  3. Target company filters — industry, size, stage, geography
  4. Recency — default last 30 days, but ask if the user has a specific window

Examples of role → buyer mapping (use these as priors):

  • Hiring SDRs → buys outbound tooling, dialers, sequencer, list providers
  • Hiring AI Engineers → buys eval platforms, vector DBs, observability
  • Hiring DevRel → buys community platforms, docs tooling, content engines
  • Hiring Customer Success → buys CS platforms, NPS tools, retention analytics
  • Hiring Compliance/SecOps → buys audit / SOC2 / policy tooling
  • Hiring Recruiters → buys ATS, sourcing, scheduling tools

If the user's product doesn't obviously map, ask explicitly: "what role would correlate with someone needing your product?"

Phase 2 — Build the query

Compose a query that finds the hiring manager at companies posting that role. The actor doesn't search jobs directly — it searches LinkedIn People who manage that function.

Format:

[Manager title for the function] [Industry] [Company size/stage]

Examples (NOT job listings — people titles):

  • For "hiring SDRs" → VP Sales OR Head of Sales OR Director of Sales B2B SaaS
  • For "hiring AI engineers" → VP Engineering OR Head of AI OR CTO seed Series A startup
  • For "hiring CS" → VP Customer Success OR Head of CS B2B

The actor's scoring layer uses the company's hiring signals (recent JD posts, headcount growth) as boosters automatically — you don't need to add them to the query.

Phase 3 — Fire the actor

Call linkedin_prospector with { query, max_leads: 50 }. Background job. Returns a job_id.

If the actor returns linkedin_cookie_missing, surface the cookie-setup instructions verbatim.

Phase 4 — Reply

Use this shape:

Searching for hiring managers at companies likely to be buying [user's wedge]. Job ID: [job_id]

Premise: companies hiring [role] are signaling [buying intent — 1 sentence connecting to user's product].

Background job — leads land in your CRM as they're scored (~2-3 min). When they're in I can:
- enrich the ones missing emails (run /specter find emails)
- write a cold email that opens with the role they're hiring for (run /specter cold outreach)

Then save_memory with the role-mapping rationale so subsequent searches stay consistent.

Constraints

  • Never invent leads.
  • The role-to-buyer mapping is the user's hypothesis — surface it explicitly so they can correct you.
  • For very rare roles (e.g. "Chief Memetic Officer"), tell the user the search will be small and offer to broaden to adjacent roles.
  • This skill is the spiritual successor to the upcoming Apify job-scraper skill — for now, the proxy is "find the manager of the function being hired for." When the dedicated job-scraper actor lands, this skill will pivot to consume its output.

Footer

Background job. Results land in your CRM in 2-3 minutes. Run check_lead_job with the job_id for status.

Example prompts

find companies hiring SDRs
who's hiring Heads of Marketing right now
companies recruiting RevOps people — they're our ICP
fresh job posts for VP Engineering at SaaS companies
find buyers based on a hiring trigger

Inputs and output

Inputs

FieldDescription
rolethe role companies must be hiring for
industriesoptional industry filter
headcountoptional company-size range
geographyoptional location filter
max_leadsoptional cap (default 50)

Output

Background job. Companies + (when available) hiring managers stream into the CRM. ETA 2-3 min.

Runtime profile

What the engine commits when this skill runs.

PropertyValueMeaning
Model tiersonnetThe balanced default model class. Trades quality against cost for the vast majority of skill runs.
Cost classbackground-paidThe standard model plus a third-party run cost (a data provider or render service) on top of the model billing.
Turn budget6Hard cap on tool-calling iterations before the engine forces a final answer.
ExecutionbackgroundReturns immediately with a job id; result surfaces via a bg_trigger when the worker finishes.

Under the hood

Tools the engine exposes to this skill and integrations it needs.

ResourceKind
linkedin_prospectortool
get_company_profiletool
search_memorytool
save_memorytool
check_lead_jobtool

Tags: leads, buying-signals, hiring, background

Invoking this from an agent

Three paths reach this skill. From the chat UI, a user can type the persona slash command followed by a natural request and the discovery step resolves to this skill automatically. From the MCP server, fetch the skill detail with get_skill({id: "hiring-manager-prospector"}) and then invoke it through the agent runtime once the authenticated tier ships. From your own code, hit /docs/skills/hiring-manager-prospector/llm.txt for the token-efficient markdown body and feed it to your model directly.

Note
Every skill page has a canonical permalink and a markdown alternate that LLM crawlers consume via Accept: text/markdown. The full machine-readable catalog lives at /.well-known/agent-skills/index.json.