Skip to main content
Glama

jobwatch

Home page

Watch the job boards of the companies you care about and get a short, ranked digest of new roles that match you, optionally fit-scored against your resume. jobwatch finds and ranks. It never applies for you.

jobwatch: watch boards, rank by fit, ask about your jobs, track applications, prep for interviews

With sound (1½ minutes, made from made-up data):

https://github.com/user-attachments/assets/71b048d0-d372-42fd-a247-c4a59c3ffd71

Tutorials

Seven short videos, two minutes or less each, made from made-up data. GitHub's video links last five minutes, so if one stops after a second or two, reload the page and play it again.

Getting started: install, jobwatch, the four onboarding steps, Today.

https://github.com/user-attachments/assets/f95f85df-406f-4ede-b84c-59569d1a586a

Your daily routine: today's picks, a job's details, the queue, "I applied", Applications, the prep sheet.

https://github.com/user-attachments/assets/8653c4ca-a79d-4135-9be1-51ba3c9fccf6

Where the AI runs: the Claude API, Antigravity or this Mac; the fallback chain; what leaves your computer.

https://github.com/user-attachments/assets/40e6f2cb-c201-4da9-ba21-77bdacc464b8

Applying: the queue, jobs found elsewhere, job-alert emails, status emails, companies to watch.

https://github.com/user-attachments/assets/9d021676-85da-4ce1-8d42-f3808b4ae03b

Tracking applications: stages and follow-ups, applications that go quiet, the calendar feed, Interviews.

https://github.com/user-attachments/assets/e2e43a54-83d2-4154-9229-a063fafefe44

Interview prep: prep sheets, answers drafted from your stories, a mock interview, a drill video.

https://github.com/user-attachments/assets/c8ac1030-700f-4cdd-823d-4b92cd411bf3

Comps and who you know: pay, career value and company health side by side; the people you know there.

https://github.com/user-attachments/assets/42eb0edb-945e-4caf-95c0-3eeae6fdada6

Related MCP server: mcp-autopilot-jobhunt

Get started

curl -LsSf https://astral.sh/uv/install.sh | sh      # installs uv (other systems: brew install uv, or the docs below)
uv tool install jobwatch

Then run jobwatch. uv brings Python with it; install options for every system: https://docs.astral.sh/uv/getting-started/installation/

Already have Python? This works too:

pipx install jobwatch      # or: pip install jobwatch

A page opens on your computer and walks you through four short steps: about you and your resume, the jobs you want, the companies to watch, and (optionally) fit scores and job-alert emails. Then press Check for new jobs. Install the page as an app from Chrome's address bar to keep it in its own window, or run jobwatch service install to have it always running (on a Mac, Linux or Windows).

Or run it from Claude:

  • Claude Code (the Claude app's Code tab, the terminal, and Cowork): add the marketplace vinayvobbili/jobwatch (Settings → Plugins → Add → Add marketplace, or /plugin marketplace add vinayvobbili/jobwatch), then install jobwatch (/plugin install jobwatch@jobwatch). The plugin brings the tools and a skill with the daily routine; it runs jobwatch with uv. Then ask Claude "watch Stripe for product designer roles".

  • Claude Desktop with Settings → Extensions: download jobwatch-<version>.mcpb from the latest release, open it and press Install. Claude Desktop sets up everything it needs, uv included.

A chat on claude.ai, or in an app whose plugins run in the cloud, can't reach jobwatch on your computer: the skill loads there, but the tools don't.

Extras: jobwatch[score] (fit scores with the Claude API), jobwatch[local] (fit scores with a local model: run any OpenAI-compatible server, e.g. vllm-mlx serve, mlx_lm.server or LM Studio, and set LOCAL_LLM_URL if it isn't at http://127.0.0.1:8010/v1), jobwatch[mcp] (an MCP server for Claude and other assistants), jobwatch[video] (drill videos for interview prep), jobwatch[lca] (H-1B wage filings from the U.S. Department of Labor as a second pay source: needs openpyxl to read its Excel files; see the watchlist guide). Prefer a terminal? jobwatch init, jobwatch find "Globex", then jobwatch run daily. More on the page and the command line →

What it does

Watches company boards

Greenhouse, Lever, Ashby, Workable, Workday, Eightfold, Oracle, SmartRecruiters, Rippling, iCIMS, Jobvite, Comeet, Gem, Recruitee, Avature, Google, Amazon, careers sites with a job sitemap, HN's Who is hiring and VC portfolio job boards (one board, hundreds of companies). Fresh roles, real pay ranges, robots.txt respected. Why boards · the watchlist

Scores fit

Your resume against each posting: must-haves met, gaps, a score out of 100. On the Claude API, Antigravity, or this Mac. Fit scores

Keeps a short queue

Today's picks, a queue to apply from, job-alert emails and status emails read for you, reposts caught. Applying

Tailors a resume per job

With resume-kit installed, one button on a queued job builds a resume from your confirmed facts and keeps it with the application for Apply and the extension to attach. Tailoring

Tracks applications

Every stage, the next step, follow-ups for the ones gone quiet, a calendar feed. Tracking

Preps interviews

A prep sheet per interview, answers drafted from your own stories, a mock interview, a drill video. Interview prep

Compares offers

Pay, career value and company health side by side. Comps

Shows who you know

Your LinkedIn connections at each company, the people you actually talk to first. Who you know

Answers questions

A chat about today's jobs and each posting, and the skills your matches keep asking for. Chat · Skills

Works with assistants

An MCP server and an agent skill, so Claude can run your search with you. MCP server

Everything stays on your computer. The only exception is a model you choose for fit scores and chat: the Claude API or Antigravity get the posting and your resume (and, for drafted interview answers, your stories); on-device models send nothing anywhere.

Why it doesn't auto-apply

Tools that auto-apply to hundreds of jobs make the process worse for everyone and rarely work for the person using them:

  • Recruiters recognize mass applications.

  • Some companies cap how many roles one person can apply to.

  • Application forms ask legal questions (work authorization, export control, signatures) that you answer yourself.

jobwatch's job is to make sure you never miss a role worth applying to, and to spend your time on those. Getting more interviews has what moves an application from the pile to a recruiter's call.

The guide

Everything else, from every watchlist setting to the drill video, is in the guide. Development covers running the tests and making a release. MIT licensed.

Support and listings

If jobwatch helps your search, a ⭐ on GitHub is how I know: jobwatch sends nothing home, so stars are the only count of who uses it. If it landed you an interview, a $1 coffee says so too. M8ven Score vinayvobbili/jobwatch MCP server Listed on mcpservers.org jobwatch on AI Agents Listing jobwatch skill on Agensi

Available Tools

32 tools
add_applicationA

Add a job jobwatch didn't find (a referral, a recruiter, LinkedIn...), so everything is in one place: an application (only after the person has applied themselves), or status queued for one they're considering. A url to one job on Greenhouse, Lever, Ashby, Workable, Workday, Rippling, Google Careers (a .../jobs/results/ link), amazon.jobs (a .../jobs/ link), Oracle Recruiting Cloud (an ...oraclecloud.com/.../sites//job/ link), SmartRecruiters (a jobs.smartrecruiters.com// link), an Avature portal (a .../JobDetail// link) or iCIMS (a .../jobs///job link) or Jobvite (a jobs.jobvite.com//job/ link) or a careers site's job page (a .../jobs// link whose page has JobPosting markup) is read in full (company and title may be left out). A LinkedIn job link is never read (LinkedIn's robots.txt disallows it): give company and title with it (and text to score it), and it's tracked on the company's own board when the same job is found there. Otherwise give company and title, and text (the posting, pasted) so it can be scored. For a job jobwatch already tracks (it came from get_digest or get_job), use mark_job instead; for the jobs in job-alert emails, import_job_alerts. When it's (maybe) the same opening as one already applied to, queued or skipped, the reply ends with that warning: tell the person.

Inputs: url, note, text, title, +5 more. Returns: result

add_boardA
Idempotent

Add a company's board to the watchlist, so fetch_jobs checks it from now on. Find the entry with find_board first and check its sample titles: a guessed board name can belong to another company (list_suggested_boards gives entries for companies whose jobs keep coming in from alerts or HN). Adding one that's already there only updates its name and careers link. For Google, leave name empty: each role keeps its own employer (Google, YouTube, DeepMind). Creates the watchlist when there is none yet. The watchlist is rewritten (a copy of the old one is kept as .bak; comments in a hand-written file are not kept).

Inputs: entry (required), name, careers.

check_postingsA
Idempotent

Check that the postings of queued jobs and open applications still take applications, and record the ones that closed or came back. result is open, closed, reopened, or unknown (check it yourself); an open job's detail may say its board's hosted pages are offline and where to apply instead. Run it before working through list_queued_jobs, so time isn't spent on closed postings.

Inputs: no named parameters. Returns: result

dismiss_suggested_boardA
Idempotent

Stop suggesting a company in list_suggested_boards, when the person doesn't want to watch it. Its jobs stay tracked. To watch one instead, use add_board with its add_board arguments.

Inputs: company (required). Returns: result

fetch_jobsA
Idempotent

Check every board in the watchlist and record new roles. Returns counts, each board that failed to load (skipped; the rest are still recorded), and warnings: a board whose hosted job pages are offline while its jobs are still listed, which needs the company's careers site (add_board with careers). Run it before get_digest, which lists the new roles themselves.

Inputs: no named parameters. Returns: result

find_boardA
Read-onlyIdempotent

Find a company's job board by name or by a job/careers link. Returns entries for the watchlist. A guessed board name can belong to another company: check the sample titles before adding one. Google (with YouTube and DeepMind) is one board, google:google (its US roles; google:google/any for all). So is Amazon (with AWS), amazon:amazon (its US roles; amazon:amazon/any for all). A Workday, Oracle Recruiting Cloud or Jibe board that isn't found by name is found from a link to a job on it. An Avature careers portal is host/portal (avature:careers.initech.example/careers); a name finds one only at name.avature.net/careers, so give a job link from any other. An iCIMS careers site is icims: (careers-.icims.com), or the whole host for another (icims:jobs-acme.icims.com); a name finds one at careers-.icims.com. A Jobvite careers site is jobvite: (jobs.jobvite.com/); a name finds one there. A Gem job board is gem: (jobs.gem.com/); a name finds one there. A Recruitee careers site is recruitee: (.recruitee.com); a name finds one there. A name that fits no board is looked up on the company's own site (.com, .ai, .io at /careers or /jobs), whose careers page links its board. A Comeet careers page is comeet:/ (comeet.com/jobs/initech/12.345); a link to it or a job on it finds it, a name doesn't (the uid is only in the link). A careers site that lists its job pages in a sitemap (their pages carrying schema.org JobPosting markup) is sitemap:, like sitemap:careers.example.com; a link to its careers page or a job on it finds it, a name doesn't. Hacker News' "Who is hiring?" thread is one board, hn:whoishiring (hn:whoishiring/N: the last N months'), found by "Hacker News" or the news.ycombinator.com/submitted?id=whoishiring link. A VC fund's portfolio job board (Consider, Getro, or the fund's own page) isn't found here: pass add_board vc:, like vc:jobs.example.vc (vc:host/path when the list isn't at /jobs). Use it before add_board; to track one job from its link, use add_application instead.

Inputs: company (required). Returns: result

find_duplicatesA
Read-onlyIdempotent

Jobs tracked twice: pairs of tracked jobs, open or closed, where the person queued, applied to or skipped one and the other is the same opening (strong: a shared req or posting id, from a title, note, posting text or link; why says which, "reposted as req ..." for a repost) or maybe the same (why "same title": check it's a different opening). The same opening first, applications first. Each: why, strong, and both jobs (key, company, title, status, date, closed), the one acted on first. Read-only: the person decides what to skip (mark_job). For one job, get_job's duplicate_of says the same.

Inputs: strong_only. Returns: result

find_past_answersA
Read-onlyIdempotent

Form answers the person gave on earlier applications (kept by save_application_package), newest application first: key, company, title, applied, question and answer; without a query each question once, with asked (how many applications had it) and only the first line or so of its answer: search for the question's words to read it whole. Use it before filling a form, to reuse what was answered to "reason for leaving", "notice period" or "salary" instead of writing it again; for everything sent with one application use get_application_package.

Inputs: limit, query. Returns: result

get_application_packageA
Read-onlyIdempotent

What was sent with an application: files kept (with their folder), form answers, note, and the day the posting was saved as it read then (posting.md in the folder). Use it to check exactly what was sent; for a full prep sheet use get_interview_prep, and for the posting and fit use get_job.

Inputs: key (required).

get_companyA
Read-onlyIdempotent

Everything tracked at one company, whatever the status of its jobs (new, queued, applied, screening, interviewing, offer, rejected, withdrawn, skipped) and open or closed. company, counts (jobs by status), and jobs: each with key, title, status, posted, applied_at, closed, next_step, follow_up, due, note, package (what was saved: files, answers, note) and duplicate_of (see get_job); contacts: people the user knows there, with find_referral, a LinkedIn search for someone who could introduce them; watch: whether the company's board is on the watchlist and, when it isn't, add_board (the entry and name to pass add_board) and command. Closed postings never acted on are only counted (closed_unacted), so are open ones not acted on that the filters leave out (left_out, with left_out_by: filter -> count) unless every_role, and the other open ones not acted on are listed up to 25 (more_open). also names other companies the name matched. Returns an error when none matches. Use it when the person names a company and you don't know which stage it's at; for one job's full text, fit and prep use get_job, for every application list_applications, and for all jobs of one status list_jobs.

Inputs: name (required), every_role.

get_compsA
Read-onlyIdempotent

Open applications side by side, to compare offers and processes: for each, its stage, applied day, next step and follow-up, pay as posted, places, fit score (must-haves met, top gaps), people the person knows there, and the compensation details they were told (base, bonus, equity, sign-on, asked, offered, note; set them with set_comp), and the company's health (set it with set_company_health; stale when older than 90 days: research it again). best says which opportunity is highest in posted pay, base, offered and fit. suggestion ranks them by rules (career value from the company's kind and the job's role, pay against the person's target, fit, how far along, company health) with the weights, each part's score and input, and a reason: explain it, and say what is missing (no health kept, no kind or role, no pay known) rather than guessing. Use it when the person asks how their opportunities compare; for one application's status use list_applications.

Inputs: keys, stages, companies.

get_digestA

New jobs that pass the watchlist's filters, best first (fit score when scored, then keyword relevance), with people the user knows at each company. Call fetch_jobs first to pick up today's postings. This is for finding jobs to consider; for jobs already queued use list_queued_jobs, and for applications use list_applications. total is how many matched before the limit (jobs left out stay new for the next digest). not_scored, when set, says why a job is never fit-scored (a Hacker News post listing several roles). pace, unless the user turned it off: applications sent today against how many they aim for a day (daily) and the most (max); once met, suggest the rest wait for tomorrow, but never refuse to help.

Inputs: limit, company, score_top, mark_shown, +1 more.

get_interview_prepA
Read-onlyIdempotent

A prep sheet for a recruiter call or interview: stage and next step, each requirement and responsibility in the posting next to the closest resume line (quoted, never written), gaps to be honest about, what was sent, questions to expect and to ask, and the posting. For an application added by hand, the posting is found on a watched board by its requisition id. markdown is the sheet ready to read. Also: brief, the company as the posting and the person's own notes tell it (about: the posting's lines; facts; notes; contacts: people they know there; source), nothing looked up elsewhere, so say it's from the posting; pay, the posted range (posted, posted_min, posted_max), the person's target (target, and target_max when it's a range) and how it sits against the range (target_note); and role_questions, questions for this role written from the posting's asks (questions_note says where they came from; empty: expect's generic questions stand). The person's private pay floor is never returned here (pay.floor_withheld says one is set): don't ask for it or guess it. With draft_answers, drafted holds the drafted questions and draft_note how they were made, or why there are none. practised holds the answers the person kept from mock interviews (jobwatch ask --job KEY --mock): question, answer as they said it, and improved, the tightened version built from their own words and stories. Present a drafted answer as the person's only where it cites their stories. story_gaps lists what a story would help with (ask, why): asks with nothing close on the resume, drafted questions with no story yet, missing must-haves; to fill one, interview the person and keep what they confirm with save_story. Use it before a call; get_job and get_application_package give the raw pieces.

Inputs: key (required), draft_answers, role_questions.

get_jobA
Read-onlyIdempotent

Everything about one job, by key or posting id: the full posting text, pay, tracking (status, note, next step, follow-up), its fit score against the resume (score, must-haves met, gaps, and requirements: each requirement with its verdict, met/partial/not_met, and the resume's words backing it; scores saved before jobwatch kept these have none), people the user knows there plus a LinkedIn search for a referral, skills it asks for that the resume doesn't show, what was sent with the application, and candidate_home: the company's page where the person signs in to see the application's status (Workday only; each company has its own account). link_note, when set, says the board's hosted job pages are offline and where to apply instead (url is then the company's careers site, when the watchlist gives one). With no fit score, unscored_reason says why ({code, text}: no_text means it needs its posting, a link via mark_job(url=) or the text pasted; queued means it's in the page's background scorer's line; many_roles, a post listing several roles, is never scored; stale, an older scorer's score, is scored again only when asked). duplicate_of is the job already applied to, queued or skipped that this one is (maybe) the same opening as: key, title, status, date, why, strong (a shared req or posting id; false: the same title only, so check it's a different opening), reposted, and text, the warning to heed; null when there's none. Check it before drafting a referral request or an application. staffing_firm, when the posting is from a staffing or recruiting agency, is the warning to heed (ask the client's name, and full-time vs contract); null otherwise. pay_sources has one entry per pay source, in order: posted (the posting's range), levels (Levels.fyi), lca (H-1B filings), recruiter (what set_comp kept), glassdoor (only what the person typed in: never fetched) and ask (the base to ask for); each is {label, value, reason, blank, ...}: value is null when the source has nothing, and reason says why (blank is TBD when it will be known later, none or off). lca_pay, once jobwatch lca update has been run, is the base pay the company filed for H-1B hires in titles like this one (median, 25th-75th percentile, count, wage levels, examples; U.S. DOL LCA disclosures): base only, not total compensation. Use it to tailor a resume or decide whether to apply; for only what was sent use get_application_package, and for a call or interview use get_interview_prep.

Inputs: key (required).

import_job_alertsA
Idempotent

Track the jobs in job-alert emails (LinkedIn, Built In, Indeed; other senders with a generic reader). Search the person's mail for them first, e.g. from:jobalerts-noreply@linkedin.com, from:builtin.com, from:jobalert.indeed.com, from:match.indeed.com (Indeed's job matches, as its app notifies them), and pass each message in; jobwatch never needs a mail password. Links lose their tracking parameters. Each job whose title, place and pay pass the watchlist's filters is looked for on the company's own board (a link to a supported board is read from there); job sites' pages are read only when their robots.txt allows (LinkedIn's and Indeed's don't, so the email's details are used). Jobs already tracked are left alone (known); new ones show up in get_digest, with via saying where they came from. Returns counts and each job: key, result (new, known, duplicate: twice in these emails), how (board, posting, page or email), filtered (why the filters leave it out of the digest, or null) and duplicate_of (the job applied to, queued or skipped that it's maybe the same opening as, as get_job gives it, or null). For emails about the person's applications (confirmations, rejections, interviews), use read_status_emails.

Inputs: emails (required), dry_run, follow_links.

import_job_listA

Take in a LinkedIn or Indeed job list the person had open ("Jobs based on your preferences", "Jobs that match your profile", "Jobs for you", a search's results), read in their own browser; jobwatch never fetches linkedin.com or indeed.com. Each job is matched to a tracked one (its link on the site, or its company and title); each new one is looked for on the company's own board and tracked there as new, whatever the filters say (they decide what get_digest shows); one not found there is tracked from the list's text and comes back as unplaced, with why (no board found, or not on it): find its board with find_board and watch it, and the alerts backfill fills it in. Each company counts toward list_suggested_boards. Returns counts (seen, tracked: jobwatch had it, earlier: an earlier import added it, added, unplaced) and coverage (jobwatch's own share: tracked over seen, 0-1; jobs an earlier import added count as missed), with a note when most of the list was imported before ("Same list as before: nothing new"), overall and by_source, and each job with its outcome and key. Every run is kept: jobwatch import-list --history shows the trend per site.

Inputs: records (required), dry_run.

list_applicationsA
Read-onlyIdempotent

Every application (applied or a later stage) and where it stands, follow-ups due soonest first; candidate_home is the company's page for checking its status, when it has one (Workday). Use it to see what needs a follow-up; for jobs not applied to yet use list_queued_jobs, and for any status use list_jobs. quiet is set on an application with no stage change or note for weeks (the watchlist's quiet: days per stage): days, since, posting_open, long (quiet so long that it sorts below the fresher ones), move (nudge: a short check-in to the recruiter or a contact, or close: likely closed, ask the person whether to mark it rejected or withdrawn; never change it on your own), advice, and contacts the person knows there.

Inputs: due_only. Returns: result

list_boardsA
Read-onlyIdempotent

The boards on the watchlist (entry, display name, careers: the board's own page, careers_link: the company's own careers site when the watchlist gives one) and where the watchlist file is. Use it to see what fetch_jobs checks; add_board and remove_board change it.

Inputs: no named parameters.

list_jobsA
Read-onlyIdempotent

Tracked jobs with their tracking fields, newest first, including closed postings. A plain list by status (e.g. every skipped job); for ranked new jobs use get_digest, for the next to apply to list_queued_jobs, and for follow-ups list_applications.

Inputs: status. Returns: result

list_queued_jobsA
Read-onlyIdempotent

Jobs queued to apply to, oldest first, with fit scores, notes, people the user knows there (ask them for a referral before applying) and warnings to check first (pay, place, flagged text). The first warning, and duplicate_of, say when it's (maybe) the same opening as one already applied to, queued or skipped: read them before asking anyone for a referral. Use it to pick the next application; jobs get here through mark_job with status queued. For applications already sent use list_applications.

Inputs: no named parameters. Returns: result

list_skill_gapsA
Read-onlyIdempotent

Skills today's matching jobs and the person's applications ask for, most in demand first, each with on_resume, how many jobs mention it, how many scored jobs list it as a missing must-have, and ways to learn it: curated courses and certifications (official pages, each with a rough time and whether it fits the timeline) and searches on Coursera, LinkedIn Learning, edX and nearby colleges. Also fit-score gaps no course closes (clearance, citizenship, degree, travel). Recommend only from these links; never suggest claiming a skill the resume doesn't show. For one job's gaps use get_job; to prepare for a call use get_interview_prep.

Inputs: timeline.

list_suggested_boardsA
Idempotent

Companies to watch: those whose jobs came in from job-alert emails (import_job_alerts), add_application or posts in HN's Who is hiring thread (fetch_jobs, when it's watched) while their board isn't on the watchlist, ranked by how many of their jobs pass the watchlist's filters, recent ones counting more. Each: company, matching_jobs, last_seen, board (source:board, or null), board_found (posting: one of its jobs is on that board, or its HN post links to it; name: found under its name, so check with find_board's sample titles that it's theirs), careers, sample_titles, and add_board: the arguments to pass to add_board to watch it (null when no board was found: find_board with a link to its careers page may find one). dismiss_suggested_board stops suggesting one. rescan picks up HN posts kept before (see its description). Suggest; let the person decide which to add.

Inputs: limit, rescan, look_up_boards. Returns: result

mark_jobA
DestructiveIdempotent

Record a job's status: new, shown, queued (to apply to next), applied, screening, interviewing, offer, rejected, withdrawn or skipped (omit status to keep it and only update the rest). key is the job's key, its posting id, or its company's name when that names one job (the one queued or applied to there); when it names several, nothing changes and the error lists them. Use applied only after the person has submitted the application themselves. add_note adds a dated line to the note, keeping what's there: prefer it for news ("recruiter replied: onsite only"); note replaces the whole note. next_step says what happens next ("recruiter screen Tuesday"), with its date and time; round says which interview it is (see its description), so it counts as a meeting without depending on its words; follow_up is the day to act (YYYY-MM-DD or +N days); applied_on is the day applied, if not today. url sets the link of a job added by hand (its posting, or the company's careers site once the posting is gone); when the job has no posting text and the link is to one job on a supported board, the posting is read from it (text, pay, places), so it can be scored. text sets its posting's text, pasted (found later, or from a copy once the posting is gone), so it can be scored and prepped. An empty string clears a field. For a job jobwatch doesn't track yet, use add_application. Queuing a job that's (maybe) the same opening as one applied to or queued still queues it, and the reply ends with the warning: tell the person.

Inputs: key (required), url, note, text, +6 more. Returns: result

rate_contactA
DestructiveIdempotent

Record what the person says about someone they know at a company: use (a good person to ask for a referral: listed first wherever contacts are), skip (never suggest them, e.g. never answers messages) or clear (forget it), with an optional short note that is shown with their name. Call it when the person tells you whom to ask or not to ask; it only changes how contacts are ordered and listed. Returns the connection (name, company, position, verdict, note). Errors when no connection (or more than one) has that name: then use their profile link.

Inputs: who (required), verdict (required), note.

read_profileA
Read-onlyIdempotent

Who an interviewer or contact is: their roles, from the text of their LinkedIn experience page, for interview prep. Each: title, company, start, end ("Present" if current), duration, location, workplace (Hybrid, Remote or On-site) and bullets (the description). The page's sidebars and footer are dropped. This only parses text it is given: jobwatch never reads linkedin.com (its robots.txt disallows it), so get the page text through the person's own browser. Returns an error when no roles are found.

Inputs: text (required). Returns: result

read_status_emailsA
Read-onlyIdempotent

Read emails about the person's applications (a "thank you for applying" confirmation, a rejection, an interview invitation or scheduling link, a take-home assignment, an offer, a recruiter's reply) and PROPOSE what changes; nothing is recorded. Search the person's mail first (e.g. their applications' companies, or "thank you for applying", "your application", "interview"), and pass each message in; jobwatch never needs a mail password. Present the proposals to the person and only call mark_job for the ones they confirm, with the proposal's mark_job arguments (status, add_note, next_step, follow_up). Returns proposals (key, company, title, current_status, suggested_status (null: only a note), kind, note, next_step, email (date, sender, subject), confidence, why, mark_job), unmatched (emails about no tracked application, with the company guessed: offer to add it with add_application, or say it's an application it can't tell apart), nothing_new (emails that add nothing: already recorded or already past that stage) and other (the count of emails that aren't about an application). A status only moves forward: a late confirmation for an application already interviewing is not a proposal. For job-alert emails use import_job_alerts.

Inputs: emails (required).

remove_boardA
DestructiveIdempotent

Take a board off the watchlist, so fetch_jobs stops checking it. Jobs and applications already recorded from it are kept. The watchlist is rewritten, with a copy of the old one kept as .bak.

Inputs: entry (required).

save_application_packageA
Destructive

Keep what was sent with an application, as copies: files (local paths to the resume PDF, cover letter... exactly as uploaded), answers (the form's questions and the answers given, [{question, answer}]; replaces any saved before) and note (a cover letter or message pasted into the form). Call it once the person has submitted, with what they actually sent; get_application_package reads it back.

Inputs: key (required), note, files, answers.

save_storyA

Add a story to the person's story file (the watchlist's stories:, or stories.yaml beside it, which the watchlist then names), for drafted interview answers and mock interviews. Use it after interviewing the person about one of get_interview_prep's story_gaps: ask one question at a time; if you offer typical details to jog their memory, say they're common patterns, not their case; keep their real role (took part is not led); keep internal system names, people's names and countries out. Only what they confirmed goes in did, hard and result; the rest goes in avoid. Show them the story and save it only after they say yes. Returns the story as saved, the file and how many stories it has.

Inputs: id (required), did (required), hard (required), title (required), +3 more.

set_compA
DestructiveIdempotent

Keep what a recruiter told the person about pay for a job, so get_comps can put it next to the others, and what the job is for their career (role, career_note). Only the fields given change; an empty string clears one. Write amounts the way they were said ("165-195K", "$215,000"): the first amount found is read to mark the highest. Returns what is kept for the job.

Inputs: key (required), base, note, role, +7 more.

set_company_healthA
DestructiveIdempotent

Keep what is known of a company's health, per company, for get_comps to show and weigh. Search the web yourself (jobwatch fetches none of these sites) and record what you found with its source links and the day; say so when you could not find something, and leave that field out rather than guessing. Only the fields given change; an empty string clears one. Returns what is kept, with how old it is.

Inputs: company (required), kind, risk, as_of, +8 more.

tailor_resumeA
Idempotent

Tailor a resume to one job with resume-kit and keep the PDF as that job's resume, which the browser extension attaches. The first call drafts a version from the posting; later calls rebuild it without overwriting edits. Takes seconds. Returns version, pdf, pages, ok, problems and new. Needs resume-kit; the person reviews the PDF before applying.

Inputs: key (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 32 tools

    Disambiguation4/5

    The set has many closely-related read/list tools (list_jobs, list_queued_jobs, list_applications, get_digest, get_company, get_comps, list_boards), but nearly every description explicitly states which sibling to use instead, which resolves most confusion. A few boundaries still require care — add_application vs mark_job, find_board vs list_suggested_boards vs add_board — though the descriptions draw those lines too.

    Naming Consistency5/5

    Every tool is snake_case verb_noun (list_boards, add_board, fetch_jobs, get_job, mark_job, set_comp, save_story, tailor_resume). The verb choice is meaningful and stable across domains (list_ for enumerations, get_ for single-resource reads, import_/read_ for ingestion, set_/save_ for writes).

    Tool Count3/5

    32 tools exceeds the comfortable range and the surface is broad (boards, imports, email parsing, applications, comps, resume tailoring, interview prep, skill gaps). Each tool does justify itself as a distinct operation, but the count is heavy enough that discoverability suffers and some operations could be consolidated.

    Completeness5/5

    The surface covers the full job-search lifecycle end to end: watchlist CRUD, job discovery/import, status transitions, application packages, compensation and company research, resume tailoring, interview prep, stories and skill gaps. No obvious dead ends; even edge cases like duplicate detection, closed postings, and mail-based status proposals have dedicated tools.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      Scans 130+ company careers pages and scores every role against your resume with an LLM (0–100), surfacing top matches. Drafts tailored cover letters and resume bullets for any job on demand, and exports scan results to CSV.
      3
      24 PyPI
      218
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables users to upload a resume to build a profile, discover jobs from company websites and official ATS boards, receive scheduled recommendations, and swipe to manage interest and application status. Runs self-hosted on Cloudflare with private resume storage and no OpenAI API key required.
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to discover postings from watched company boards ranked by keyword fit, tailor and fact-check resumes against a source-cited profile, render ATS-readable PDFs, submit applications through the user's own browser, and track replies and follow-ups. All ranking, claim checking and email classification run as plain code, so LLM tokens are spent only on writing.
      1
      Apache 2.0