Skip to main content
Glama

Jobgent

An open-source AI job search engine you run yourself. Jobgent finds jobs, tells you which are worth your time and why, writes a tailored one-page CV and cover letter for each, and tracks every application. All of it from a web app, a CLI, or any AI agent over MCP.

It starts where its author needed it: internships for international students in the Netherlands, in English. The engine is general (search keywords, cities and dates are settings in your own profile), and the job sources are a list you can extend.

CI Python 3.12 MCP License: MIT

A job in Jobgent: the verdict, requirements matched to evidence, the ATS check and the tailored CV

The model judges, code decides. The AI reads postings and drafts documents. Plain code decides the verdict, the coverage, what counts as evidence, and whether a document is safe to send. You submit every application yourself.

Try it in two minutes (no API key)

git clone https://github.com/Oxde/jobgent && cd jobgent
uv sync && uv run playwright install chromium
(cd frontend && npm ci --ignore-scripts && npm run build)
uv run jobgent demo                                  # a made-up student with 10 jobs
JOBGENT_HOME=~/.jobgent-demo uv run jobgent web       # http://127.0.0.1:8781

The demo is entirely fictional (Sam Jansen, generic companies) and never touches your real data in ~/.jobgent.

Related MCP server: career-agent-mcp

What it does

Finds jobs

70+ company job boards read straight from their public ATS feeds (Greenhouse, Lever, Recruitee, Ashby, Workable, Homerun), LinkedIn's public job search, and any link or pasted posting. Duplicates across sources are merged.

Judges fit

Hard gates first: still open, language, location, work rights, red flags (fees, unpaid roles) and prompt injection in the posting. Then every requirement is mapped to evidence in your profile, and code decides covered / partial / gap and the verdict apply / consider / skip.

Writes the pack

A CV tailored per job (which projects and skills, in which order), a cover letter in your voice and tone, and the email. A second model pass reviews it. One A4 page, guaranteed.

Refuses to lie

A number that is not in your profile or the posting blocks the pack. Unknown names are flagged "check this". Banned filler phrases are rewritten. Every AI edit is versioned with undo.

Checks the PDF like an ATS

Reads the PDF's text layer back: contact details present, dates parseable, keywords found, keywords you have but left out, and real gaps.

Tracks the search

Drag-and-drop pipeline, a "worth a look" home ordered by urgency (offers, interviews, deadlines, follow-ups after 7 days), a funnel and weekly goal, interview prep with STAR stories, and "what to learn next" from your most common gaps.

Runs as an agent

A daily job agent fetches, evaluates and queues the best new matches, with the reason for each pick.

How it works

flowchart LR
    subgraph Sources
        ATS[Company ATS feeds]
        LI[LinkedIn public search]
        M[Link or pasted text]
    end
    Sources --> I[Ingest and dedupe] --> C[Classify: internship? English?]
    C --> G{Gates<br/>open, language, location,<br/>work rights, red flags, injection}
    G -- fail --> S[Skip, with the reason]
    G -- pass --> R[Model: extract requirements<br/>and point at evidence]
    R --> V[Code: coverage and verdict<br/>apply / consider / skip]
    V --> P[Model: tailor CV, write letter,<br/>review]
    P --> F[Code: banned phrases, fact guard,<br/>one-page PDF, ATS read-back]
    F --> T[Pack ready: you send it<br/>and track it]

Every model output is a typed schema (pydantic), so a model can only fill in fields; it cannot change the rules. Posting text is sanitized and fenced before any prompt sees it, so a posting that says "ignore your instructions" gets flagged instead of obeyed.

Use it from your AI agent

Jobgent is MCP-first: every feature is a tool, so Claude Code, Claude Desktop, Cursor or ChatGPT can drive the whole search by conversation.

claude mcp add jobgent -- uv --directory /ABSOLUTE/PATH/jobgent run jobgent mcp
uv run jobgent mcp --http        # port 8790, for ChatGPT connectors and other remote clients

Then just talk: "Find AI internships in Amsterdam starting February", "Is job 42 worth applying to?", "Make the pack for 42 in a direct tone", "Make my second bullet shorter", "What should I learn next?". The web app updates live while the agent edits.

No API key? Let your agent do the AI part. With evaluate_prompt / evaluate_submit and pack_prompt / pack_submit, Jobgent hands the agent the profile, the posting, the rules and the output format; the agent writes; Jobgent still runs every check (gates, verdict, fact guard, one-page PDF, ATS read-back) before anything is saved. Your Claude or ChatGPT subscription does the writing, and Jobgent stays the referee.

Area

Tools

Profile and CV

profile_get, profile_update, profile_add_item, profile_remove_item, profile_set_verified, profile_get_voice, profile_set_voice, profile_notes_append, profile_set_master_cv, profile_import_jobkiller, cv_outline, cv_export_pdf, cv_writing_guide

Jobs

jobs_search, jobs_fetch, jobs_list, job_get, job_add, job_score, job_evaluate

Agent mode

evaluate_prompt, evaluate_submit, pack_prompt, pack_submit

Packs

pack_create, pack_get

Tracking

application_set_status, applications_list, stats

Agent and insights

agent_run, agent_queue, learning_gaps, interview_prep

Set up for real

cp .env.example .env     # fill in what you have
uv run jobgent init
uv run jobgent web

Variable

What it does

ANTHROPIC_API_KEY

Claude for matching, CVs and letters.

KIE_API_KEY

Alternative: Claude through KIE. Used when no Anthropic key is set.

APIFY_TOKEN

Optional. LinkedIn through an Apify actor. Without it, LinkedIn's free guest search is used.

JOBGENT_LINKEDIN

auto (default), apify, guest or off.

JOBGENT_HOME

Where your data lives. Default ~/.jobgent.

With no AI key at all, search, tracking and the editor still work, and an MCP agent can do the AI steps (see above).

Your profile (~/.jobgent/profile/profile.yaml) is the single source of truth. Edit it on the Me page: the CV is a live A4 page you edit in place, next to a chat that edits it for you. Nothing personal is stored in this repository.

uv run jobgent init
uv run jobgent profile verify
uv run jobgent search "AI intern" --location Amsterdam
uv run jobgent fetch            # all sources → classify → score
uv run jobgent jobs --min-score 60
uv run jobgent pack 42
uv run jobgent status 42 applied
uv run jobgent stats
uv run jobgent agent            # one run of the daily job agent; --schedule 08:00 prints a launchd job
uv run jobgent companies        # check every board in data/companies.yaml
uv run jobgent eval             # run the golden evals against the live model
uv run jobgent web | mcp | demo

Quality

  • 250 tests that need no network and no API keys (uv run pytest -q), and mypy --strict on the whole package.

  • Golden evals: 10 hand-written postings in evals/golden/ cover a strong fit, Dutch required, Dutch as a plus, the wrong city, an unpaid role, an agency fee, a prompt injection, a critical gap, a weak fit and a closed posting. Tests replay recorded model output; jobgent eval runs them against the live model.

  • Security: link fetching blocks private addresses and re-checks every redirect (SSRF), secrets are never logged or returned by the API, and posting text is treated as data, never as instructions. See SECURITY.md.

Screenshots

Home

Pipeline

Home

Pipeline

Agent picks

CV editor

Agent picks

CV editor

Stack

Python 3.12 (uv), FastAPI, SQLAlchemy + SQLite, pydantic, FastMCP, Typer, Playwright for PDFs. React 19, Vite, Tailwind 4, dnd-kit. Claude (Anthropic API or KIE) as the model.

Agent skills

.agents/skills/ holds skills that coding agents load when working in this repo. jobgent-cv-writing (ours) overrides the rest: facts only from the profile, never an estimated number, gaps stated honestly. The others come from ResumeSkills by Param Choudhary (MIT), anthropics/skills (frontend-design) and ui-ux-pro-max (MIT). skills-lock.json pins them.

Roadmap

  • Indeed and a generic careers-page reader for companies without a public ATS feed.

  • Import a profile from a CV PDF.

  • More countries and languages.

  • A hosted version for students who don't want to run it locally.

Ideas, bug reports and job boards are welcome: see CONTRIBUTING.md. Adding a company is a one-line change.

Credits

Ideas for the evaluation and the pack were studied from career-ops, ai-job-search and Dossier. The design history is in docs/design/.

License

MIT © Oxde

Available Tools

33 tools
agent_queueB

Postings the agent recommends (apply first, then consider), with its reason and any red flags.

Inputs: no named parameters.

agent_runA

Run the job agent once: fetch new postings, score them, evaluate the best max_evaluate new ones (score ≥ min_score) and queue those worth applying to. Never applies or sends anything. Then call agent_queue.

Inputs: min_score, max_evaluate.

application_set_statusC

Track progress. status: new, liked, pack_ready, applied, interview, offer, rejected, skipped.

Inputs: job_id (required), status (required), notes.

applications_listC

Everything with a status other than new, most recently updated first.

Inputs: status.

cv_export_pdfA

Render the general (untailored) CV to an A4 PDF and return its path. Template ids: see profile_get preferences or the web app; default is the user's chosen one.

Inputs: template.

cv_outlineA

The whole CV/profile as path: value lines. Use the paths with profile_update to change any line, e.g. experience[0].bullets[1]. The web app at /me shows the result live.

Inputs: no named parameters.

cv_writing_guideA

Read this BEFORE writing or tailoring any CV text: ATS rules, structure, bullet formula, the user's own tailoring pattern, cover-letter rules. Never invent facts.

Inputs: no named parameters.

evaluate_promptA

Agent mode, step 1 of evaluation: everything you need to evaluate a posting with your own model. Runs the deterministic gates first; if one fails the job is skipped right away (done=true, no work for you). Otherwise follow instructions: extract the requirements (extracted_schema) from posting only, then map each to evidence in profile (mapped_schema, indexes into the profile lists), and call evaluate_submit.

Inputs: job_id (required).

evaluate_submitB

Agent mode, step 2 of evaluation: submit your extraction and mapping. Jobgent re-runs the gates, checks every evidence pointer against the profile (pointers to entries that do not exist count as gaps), resolves covered / partial / gap, and decides the verdict from coverage.

Inputs: job_id (required), mapped (required), extracted (required).

interview_prepA

Interview prep for one application: likely questions, STAR stories from profile facts only, consistency reminders against the CV and letter that were sent, questions to ask, gaps to prepare.

Inputs: job_id (required), stage.

job_addA

Add a posting by URL or pasted text (for anything the search missed, e.g. a LinkedIn link). Classifies and scores it.

Inputs: url, text.

job_evaluateA

Full evaluation of one posting: checks it is still open, runs the gates (language, location, work rights, red flags, integrity), builds the requirement → evidence table (covered / partial / gap, decided by code) and returns a verdict apply / consider / skip with the reason. Use before pack_create.

Inputs: job_id (required).

job_getC

Full posting plus score reasons, gaps and classification.

Inputs: job_id (required).

job_scoreC

Re-score one job against the current profile.

Inputs: job_id (required).

jobs_fetchB

Run every job source (company boards, LinkedIn via Apify if configured), then classify and score new jobs. Check skipped and each result's error: a source can fail without stopping the others.

Inputs: score, classify.

jobs_listB

The feed: internships in English, no Dutch required, sorted by match score. Skipped/rejected are hidden unless status is given.

Inputs: limit, source, status, min_score.

learning_gapsA

What to learn next: requirements the student lacks, weighted by importance and how often they cost a job. Skills already in the profile are excluded (those are CV-wording problems, not learning gaps).

Inputs: no named parameters.

pack_createB

Generate the application pack: tailored one-page A4 CV (PDF + HTML), cover letter, and how to apply. Every claim is checked against the profile; fails loudly if anything unsupported slips in.

Inputs: job_id (required).

pack_getC

Paths and summary of an existing pack.

Inputs: job_id (required).

pack_promptB

Agent mode, step 1 of the pack: everything you need to write the tailored CV and cover letter yourself. Write the CV as JSON matching cv_schema (cv_instructions), the letter as plain text (letter_instructions), then call pack_submit. Use only facts from profile and facts.

Inputs: job_id (required).

pack_submitA

Agent mode, step 2 of the pack: submit your CV (cv_schema) and letter. Jobgent blocks invented numbers and banned phrases, renders the one-page A4 PDF, runs the ATS check, saves the documents (with undo) and marks the job pack_ready. If refused, fix exactly what the error names and submit again.

Inputs: cv (required), job_id (required), letter (required).

profile_add_itemA

Append one entry to a list section: experience {company, title, period, bullets[]}, education {institution, degree, period, gpa, details}, projects {name, description, tech[], link}, skills {name, evidence}, languages {name, level}. Only add facts the user told you.

Inputs: item (required), section (required).

profile_getA

The user's knowledge base (profile.yaml): facts, preferences and search settings. Read this first.

Inputs: no named parameters.

profile_get_voiceC

The writing-style guide used for cover letters.

Inputs: no named parameters.

profile_import_jobkillerB

Bootstrap the profile from a JobKiller user_info .json or a CV .html made by JobKiller. Leaves verified=false.

Inputs: json_path (required).

profile_notes_appendA

Append raw notes from the user (onboarding answers, voice-note transcripts). Kept verbatim in notes.md.

Inputs: text (required).

profile_remove_itemA

Remove entry index (0-based) from a list section. Check cv_outline for indexes first.

Inputs: index (required), section (required).

profile_set_master_cvA

Set a custom CV template (Jinja2 HTML using personal, cv, languages). Default template is used otherwise.

Inputs: html (required).

profile_set_verifiedA

Mark the profile as reviewed by the user. pack_create refuses to run while it is false.

Inputs: verified (required).

profile_set_voiceB

Replace the writing-style guide for cover letters.

Inputs: text (required).

profile_updateA

Change one field by dotted path, e.g. 'preferences.weekly_goal' = '12', 'search.keywords' = '[data intern, AI intern]', 'education[0].period' = '2023 – 2027'. Text fields are stored as given; numbers, lists and booleans are parsed from YAML.

Inputs: path (required), value (required).

statsA

Applications sent this week versus the weekly goal, plus counts per status.

Inputs: no named parameters.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 33 tools

    Disambiguation3/5

    Several tool clusters overlap in purpose: jobs_fetch vs jobs_search vs agent_run all bring in postings, job_score vs job_evaluate both score a job, and pack_create vs pack_prompt/pack_submit produce application packs. Descriptions do clarify the deterministic-vs-agent-mode split and the step-1/step-2 pairing, but an agent still has to read carefully to pick the right entry point.

    Naming Consistency3/5

    Mostly snake_case with noun_verb or verb_noun shapes, but prefixes are inconsistent (job_score vs jobs_fetch vs jobs_list, application_set_status vs applications_list) and some names are nouns rather than actions (agent_queue, cv_outline, stats, learning_gaps, interview_prep, evaluate_prompt vs pack_prompt). Readable, but the convention shifts between singular/plural and verb/noun forms.

    Tool Count2/5

    33 tools is heavy for this domain, and much of the bulk comes from duplicated paths for the same outcome (job_evaluate/evaluate_prompt/evaluate_submit, pack_create/pack_prompt/pack_submit, jobs_fetch/jobs_search/agent_run). The set would be tighter if the agent-mode pairs were folded into a mode flag on the deterministic tools.

    Completeness4/5

    Coverage is broad across the lifecycle: profile read/write/add/remove/import, CV outline and PDF export, job ingestion, search, evaluation, pack generation, application status tracking, stats, learning gaps and interview prep. Minor gaps exist (no explicit job removal from the feed, no listing of generated pack documents beyond pack_get), but agents can work around them via application_set_status.

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      An MCP server that exposes job-search and application-management capabilities to compatible AI clients, enabling discovery of vacancies, drafting of tailored application materials, and coordinated human-approved submissions.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Enables LLM clients to analyse job postings, tailor resumes from an evidence-labelled profile, validate every claim against that profile, and track applications, all through deterministic MCP tools.
      7
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables AI clients to serve as a personal career analyst by searching, matching, and explaining job recommendations, managing job applications, and syncing public job boards through standardized MCP tools.
      MIT