> Index of everything AyHire publishes for agents: https://ayhire.com/llms.txt

# AyHire for agents

> Paste one prompt into your agent and it installs AyHire, signs you in through the browser and connects itself. Any agent that speaks MCP can also connect to https://ayhire.com/api/mcp with an AyHire API key, and scripts can use the HTTP API.

## Set up with one prompt

Paste this into Claude Code, Codex, Cursor or any agent that can run commands:

```
Set up AyHire for me: fetch https://ayhire.com/setup.md with curl and follow it step by step.
```

The steps it follows: https://ayhire.com/setup.md. The key goes from the browser straight into a file on that computer and never appears in the chat.

## Claude Code plugin

With access to the AyHire repository, the plugin does the same as the prompt:

```
/plugin marketplace add walidboulanouar/ayhire
/plugin install ayhire@ayhire
```

## Any MCP agent

```json
{
  "mcpServers": {
    "ayhire": {
      "type": "http",
      "url": "https://ayhire.com/api/mcp",
      "headers": { "Authorization": "Bearer YOUR_AYHIRE_API_KEY" }
    }
  }
}
```

Create a key at https://ayhire.com/app/integrations#keys after signing in. `x-api-key: YOUR_AYHIRE_API_KEY` works as well as the Authorization header.

## Command line

```
ayhire login     # sign in in the browser and save a key on this computer
ayhire status    # check the saved key and which account it belongs to
ayhire logout    # revoke and delete the key on this computer
```

## HTTP API

```
curl "https://ayhire.com/api/search" \
  -H "x-api-key: YOUR_AYHIRE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"query": "senior Rust backend engineer"}'
```

The core routes (analyze, search, candidates, shortlists), with request and response shapes: https://ayhire.com/api/docs. The MCP tools above cover the rest.

## Tools

- `whoami`: Check that AyHire is connected and which account is calling. Call this first when setting up or when other AyHire tools fail with an auth error.
- `analyze_github_user`: Score a GitHub user across 6 dimensions (technical_depth, shipping_velocity, stack_match, communication, value, gem_score) with a summary, top skills and red flags, from public metadata. Returns a saved result if the user was analyzed in the last 30 days (free, cached=true); otherwise scrapes, scores and saves (takes 15-25s). Set refresh=true only when the user asks for a fresh analysis. Parameters: `username` (required), `refresh`, `persist`.
- `score_candidate`: Lightweight version of analyze_github_user that never writes to the database. Uses a saved result if one is fresh; otherwise scrapes and scores without saving. Parameters: `username` (required), `refresh`.
- `find_people_behind_repos`: Find the developers who build popular open-source projects: searches GitHub for top repositories (by stars) matching a query, topic or language, then lists the people who contributed most to them, ranked by how many of those repos they build and how much they contributed. Bots are excluded. Use for requests like 'who built the viral AI agent frameworks?' or 'find core contributors to popular Rust databases'. Then use analyze_github_user on the people worth a closer look. People AyHire already analyzed include saved_analysis. Parameters: `query`, `topic`, `language`, `min_stars`, `created_after`, `pushed_after`, `repo_limit`, `people_per_repo`, `limit`.
- `enrich_person`: For one GitHub user: LinkedIn URL, headline and current companies, a work email, and their X profile, with the source and confidence of each. Uses GitHub first (free), then paid lookups (usually $0.001-0.005, up to ~$0.03 with deep=true). Saved and reused for 30 days (cached=true is free). Use it on people the user is seriously considering, not on every name in a list. deep=true also searches the X bio and by name + company. Parameters: `username` (required), `deep`, `find_email`, `refresh`.
- `check_availability`: Is this GitHub user already employed or open to work? Combines their current LinkedIn role, the company on their GitHub profile and GitHub's 'available for hire' flag. Returns a cautious verdict (employed, employed_but_open, open_to_work, likely_employed, unknown) with the evidence. Runs the same lookups as enrich_person (and saves them), so calling both costs nothing extra. Parameters: `username` (required), `deep`.
- `search_candidates`: Plain-language search over developers AyHire has already analyzed (semantic similarity plus score ranking), e.g. 'senior Rust backend engineer with distributed systems experience'. Only finds people analyzed before; use analyze_github_user to add someone. Parameters: `query` (required), `limit`, `threshold`, `filters`.
- `list_roles`: The roles (open positions) on your AyHire account, newest first, each with counts of picks, set aside, not looked at yet and shortlisted.
- `create_role`: Create a role (an open position) to source developers for. AyHire turns the title and brief into a GitHub search (words and a language) unless you pass query/language yourself. Then call find_people_for_role to fill it. The role also appears in the AyHire web app. Parameters: `title` (required), `brief`, `query`, `language`, `created_after`.
- `get_role`: A role and everyone in it, ranked: picks (best first; open to work before people with a job), then set aside (work below the bar), then people not looked at yet. Each person has AyHire's call (headline, one-line why, one thing to check), your decision, notes, availability and total score. Use it to answer 'who should I talk to first?'. Parameters: `role_id` (required), `include`.
- `find_people_for_role`: Search GitHub for the people behind the top repos matching the role's search, and save them to the role. Returns everyone found with what you need to choose: name, company, location, GitHub 'hireable' flag, followers, the matching repos they build and how much. Nothing is scored yet: pick the people worth a closer look and call score_role_person for each. Free (GitHub only). Pass query/language to search differently this time. Parameters: `role_id` (required), `query`, `language`.
- `score_role_person`: Analyze one person already in the role (6 scores, summary, red flags) and check whether they're available, then return them with AyHire's call. A saved analysis is free and instant; a new one takes 15-25 seconds and counts toward the hourly limit (20 analyses), so score the people worth it, not everyone. If a call times out, call it once more: when the analysis finished in the meantime, the retry is instant and free. Parameters: `role_id` (required), `username` (required).
- `decide`: Record your decision on someone in a role: shortlisted, not_now, or none (undo). Optionally add a note. Shortlisted people show up in get_shortlist and in the web app's Shortlist. Parameters: `role_id` (required), `username` (required), `decision` (required), `note`.
- `get_shortlist`: Everyone you shortlisted, across roles (the same list as the web app's Shortlist), most recent first, with AyHire's call and your notes.

## How to use the tools well

- To source people: `find_people_behind_repos` first, then `analyze_github_user` only on the few worth a close look.
- `enrich_person` and `check_availability` spend a paid balance; use them on people being seriously considered.
- Present contact data with its source. A LinkedIn with confidence "guess" was matched by name and company and may be the wrong person; say so.
- Saved results from the last 30 days are free. New analyses are limited to 20 an hour.