Recruiter Agent

What it does

Given an open requisition, the agent pulls candidates from every source the user has connected, scores them on a thirteen-feature rubric, runs AI reasoning per candidate, applies a second-pass critic review, and returns the top thirty with concrete reasoning and "network context" observations the way a senior recruiter would frame them.

It works several ways from the web UI. Applicant ranking scores the people who applied to a req. Whole-database sourcing ("source the best candidates across all of greenhouse for a CTO") ranks the entire candidate database, applicants or not: every candidate is embedded into a persistent, incrementally-refreshed Qdrant index (built in the background, pre-warmed on session start), the whole index is ranked by similarity to the role, and the top matches get the full Claude deep-scoring pass. The rubric weights adapt to each specific role, derived per-JD on top of the learned per-archetype baseline, so a CTO and a CFO are scored differently.

Two more web modes invert the flow. Match a profile takes a resume (pasted or uploaded) and scores it against every open req as a fit %, blending semantic role match, skills overlap, and seniority, then a Claude re-rank sharpens the top openings and suggests the best-fit role or a new one worth opening. Ideal profiles takes 1-3 ideal profiles for a role (a resume, or a structured brief of title/skills/education/experience/justification) and returns the closest candidates in the database for each, ranked by similarity (top 30 for one ideal, 15 each for two, 10 each for three). Every result card across all modes is clickable into a LinkedIn-style profile panel (current title, experience, education, certificates, skills, LinkedIn link) with the reasoning or similarity shown alongside, and each candidate carries a US work-eligibility signal (green/amber/red) with optional location and eligibility filtering.

The recruiter can also ask for open requisitions as a table: "give me all open reqs by location" or "show open roles in the USA as a table" returns the open reqs inline with requisition id, title, location, department, compensation, and a JD summary, filtered or grouped by location, plus a CSV export link.

The agent learns continuously from three signals:

• Thumbs feedback per card (numeric rubric weight updates), from the web UI or the Slack feedback command
• Free-text comments per card (injected verbatim into the next ranking's reasoning prompt)
• Greenhouse rejection reasons (mapped to feature impact via intelligence/rejection_signal.py)

Deploy your own copy

Every deployment is fully isolated: its own managed Postgres, its own auto-generated encryption secrets, its own users. You do not share data with any other deployment of this blueprint. Nothing needs to be pasted at deploy time; the agent generates and persists its platform secrets on first boot.

# 1. Install the CLI and sign in
curl -fsSL https://astropods.com/install | sh
ast login

# 2. Deploy straight from the public catalog
ast deploy recruiter-agent --adapter slack --adapter web --wait

For Slack, create your own Slack app in your workspace first: at https://api.slack.com/apps choose Create New App, then "From an app manifest", and paste the manifest below. Then install it to the workspace and paste the two tokens (xapp-... app token, xoxb-... bot token) when the deploy form asks for them.

Slack app manifest (copy this; it is the same file as doc/slack-app-manifest.json in the source repo, reproduced here so you do not need repo access):

{
  "display_information": {
    "name": "Recruiter Agent",
    "description": "Candidate ranking copilot: shortlist any Greenhouse req, give feedback, draft outreach, all from Slack.",
    "background_color": "#10233F"
  },
  "features": {
    "app_home": { "messages_tab_enabled": true, "messages_tab_read_only_enabled": false },
    "bot_user": { "display_name": "recruiter-agent", "always_online": true }
  },
  "oauth_config": {
    "scopes": {
      "bot": [
        "app_mentions:read", "chat:write", "commands",
        "im:history", "im:read", "im:write",
        "users:read", "users:read.email"
      ]
    }
  },
  "settings": {
    "event_subscriptions": { "bot_events": ["app_mention", "message.im"] },
    "interactivity": { "is_enabled": false },
    "org_deploy_enabled": false,
    "socket_mode_enabled": true,
    "token_rotation_enabled": false
  }
}

Once installed, the running agent also serves this manifest at GET /slack-app-manifest.json on its own URL, so you can download it directly from your deployment.

Heads up: your web URL may not provision

The platform's shared load balancer has a limited number of URL slots. Your deployment can come up healthy but never receive a public web URL (the link returns NXDOMAIN). This is a platform capacity issue, not a broken deploy. The Slack path does not use a URL slot and works on every deployment, so treat Slack as the primary surface and the web UI as a bonus if your URL provisions.

First-run data

Pick one of three on the deploy form:

1. Nothing (default): users paste their own Greenhouse Harvest key (setkey greenhouse <key> in a Slack DM, or the web Settings page) and rank their real pipeline.
2. GREENHOUSE_MOCK_URL: point Greenhouse calls at a Postman mock for demos.
3. USE_SAMPLE_DATA=true: zero-Greenhouse demo mode; ranking runs against 15 bundled sample candidates.

In every case each user sets their own Anthropic key: setkey anthropic sk-ant-... in a Slack DM, or the web Settings page.

Using it from Slack (no web UI needed)

DM the bot after install. Your account is created automatically from your Slack email.

Command	What it does
help	Command list
whoami	Your account + which keys are set
setkey <kind> <key>	DM only. Store your BYOK key: anthropic, greenhouse, pdl, gem, gnews
list jobs	Open requisitions
rank <job-id>	Ranked shortlist with reasoning, streamed progress
similar <rank#> [count]	Candidates from your pool with a similar background (semantic search)
`feedback <rank#> <up	down> [comment]`
draft <rank#> [hook]	Claude-drafted outreach email for a shortlisted candidate

Architecture

• FastAPI agent on Astro AI: web UI on port 80, plus the messaging sidecar for Slack
• Managed Postgres for canonical state, auto-provisioned per deployment
• Managed Qdrant + gateway embeddings for semantic candidate search ("more like X"), embeddings-only gateway usage so chat costs stay BYOK
• In-process NetworkX context graph (swappable to a managed graph store post-launch)
• Anthropic Claude (Sonnet for reasoning, Haiku for cheaper passes)
• Postman API Catalog publish + Postman mocks/monitors for the integration plane

User model

Sign in with email and password on the web, or just DM the bot on Slack; identity unifies by email across both surfaces. Per-user credentials are Fernet-encrypted at rest. Every user brings their own Anthropic and Greenhouse keys, so costs land on the right account.