Jobgent
Reads public Greenhouse job-board feeds for companies, pulling in their open postings alongside other ATS sources so jobs can be ingested, deduplicated, evaluated for fit against the user's profile, and turned into tailored application packs.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Jobgent Find AI internships in Amsterdam starting February"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
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.

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:8781The 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 clientsThen 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 |
|
Jobs |
|
Agent mode |
|
Packs |
|
Tracking |
|
Agent and insights |
|
Set up for real
cp .env.example .env # fill in what you have
uv run jobgent init
uv run jobgent webVariable | What it does |
| Claude for matching, CVs and letters. |
| Alternative: Claude through KIE. Used when no Anthropic key is set. |
| Optional. LinkedIn through an Apify actor. Without it, LinkedIn's free guest search is used. |
|
|
| Where your data lives. Default |
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 | demoQuality
250 tests that need no network and no API keys (
uv run pytest -q), andmypy --stricton 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 evalruns 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 |
|
|
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 toolsagent_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.
jobs_searchA
Search internships now: runs a LinkedIn search for query in location (via Apify, if configured), saves what
it finds, then returns matching internships from everything saved (company boards included), best first.
Example: query="AI engineering intern", location="Amsterdam". Check source_error if LinkedIn failed.
Inputs: query (required), limit, location, use_linkedin.
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
Scored across 33 tools
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.
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.
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.
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
Job application tracker for developers - AI agents write over MCP, you review in a dashboard.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Tailor resumes, score ATS fit, find hiring leads, and send cold outreach, from your agent.
Run your tech job search from your AI agent: matches, job unlocks, applications and follow-ups.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn 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
- AlicenseAqualityBmaintenanceEnables 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.7Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables 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

Civify MCP Serverofficial
AlicenseAqualityBmaintenanceEnables AI agents to parse resumes, tailor CVs, score ATS compatibility, redact PII, scrape job postings, and track applications through a career platform.823 npmAGPL 3.0



