# JustHireMe: a local-first job search workbench that runs without an API key

> JustHireMe is an AGPL-3.0 desktop application that scrapes job leads, filters them, ranks your fit, and generates tailored application documents. Its selling point is that discovery, ranking and generation run entirely on your machine by default.

**vasu-devs/JustHireMe** — Local-first AI job intelligence workbench for scraping roles, ranking fit, and generating tailored application materials.

- Repository: https://github.com/vasu-devs/JustHireMe
- Website: https://www.JustHireMe.ai
- Stars: 2,255 · Forks: 361
- Language: Python
- License: AGPL-3.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/vasu-devs-justhireme

## The problem JustHireMe targets: noisy boards and opaque apply tools

Job search tooling splits into two camps. Job boards give you volume and no ranking you can inspect. Cloud apply tools give you automation and no visibility into what they send on your behalf. JustHireMe takes a third position: a local-first desktop workbench where ingestion, scoring and document generation all happen on the machine you are sitting at.

The README frames the audience directly, describing it as a tool for "people who are tired of noisy job boards and black-box AI apply tools." That audience is narrower than it sounds. You need to be comfortable running a desktop application that supervises a Python sidecar process, and you need a machine with enough disk for a bundled embedding model and a browser runtime. In exchange, nothing about your search leaves the machine unless you configure a keyed provider.

The scope is deliberately field-agnostic. The README states that discovery, ranking and tailoring work for healthcare, trades, finance, law, education, hospitality, creative work and software, and that scoring is relative to the candidate's own domain rather than a fixed technology vocabulary. That matters if you are not a developer, because most tools in this category quietly assume you are.

## How the pipeline works: ingestion, quality gate, ranking, graph matching, generation

The README lays out five stages, and the ordering is the interesting part.

Scrape collects leads from ATS boards, feeds, communities, APIs and configured sources. The Quality Gate then rejects stale, thin, spammy, senior-only or low-context leads before they reach the rest of the pipeline. This is a filter that runs before ranking, not after, which means a badly formed posting never gets a score that you then have to mentally discount.

Rank scores lead quality and candidate fit using deterministic rules, feedback learning and optional LLM reasoning. Match compares jobs against your profile using Kuzu graph data and LanceDB vectors. Customize produces a tailored resume PDF, a cover letter PDF and outreach drafts.

The matching layer is where the architecture gets specific. Fit scores are backed by what the README calls GraphRAG proof drawn from a Kùzu skill and project graph, rather than a bare number. Semantic matching uses a bundled ONNX model, all-MiniLM-L6-v2, with a deterministic hashing fallback, so vector comparison works offline without an API key. Embeddings run locally; there is no hosted vector service in the default path.

One architectural detail worth flagging: the installer is thin. The README describes an installer of roughly 100 MB, with the heavy runtime (browser, vector libraries, embedding model) downloaded once on first run and cached afterward. That is a reasonable trade, but it means first launch is a network operation, not a local one.

## Installing JustHireMe and running a first scrape

Release installers are published for all three desktop platforms. The README states that every release is built by GitHub Actions from a v* tag and ships a Windows .exe, a macOS .dmg plus .app, and Linux .deb and AppImage packages. The macOS build is ad-hoc signed and, per the README, not yet notarized, so Gatekeeper may require you to use "Open Anyway".

If you want to work on the backend, source adapters or packaging rather than just use the app, the README points you at the full desktop setup. That path runs through the Node scripts declared in package.json. The local runtime setup script prepares the sidecar dependencies, and dev:local chains it into the Tauri development server:

```bash
npm run setup:local
npm run dev:local
```

The first command resolves the local runtime; the second starts Tauri in development mode. You should see the desktop window open against a local Python sidecar rather than a remote API.

Configuration lives in the app settings by default. The .env.example file is explicit that shell-level overrides are for development only: most users should enter API keys in the desktop app settings instead. The sample file defines an optional local model endpoint and a set of optional provider keys:

```bash
OLLAMA_URL=http://localhost:11434/v1
OPENAI_API_KEY=
ANTHROPIC_API_KEY=
JHM_AUTO_APPLY=false
PLAYWRIGHT_CHROMIUM_EXECUTABLE=
```

Note the two flags at the bottom. JHM_AUTO_APPLY defaults to false, and the README describes browser automation and auto-apply as an experimental lab that is disabled by default and unsupported as part of the stable core. Leave it off unless you are specifically testing that lab.

Before running anything, you need a profile. The README says résumé and profile ingestion accepts PDF, DOCX, TXT and MD files, JSON Resume exports, LinkedIn zips, GitHub and portfolio URLs, and that it shows an import report listing what was pulled in, skipped or capped. Read that report on your first import. It is the fastest way to find out whether your résumé format survived the parse.

## Where JustHireMe is the wrong tool

The most obvious limitation is stated by the project itself. Browser automation and auto-apply code exists in the repository, but the README calls it experimental, opt-in and unsupported as part of the stable core. If your requirement is unattended application submission at volume, JustHireMe is not that product today, and the JHM_AUTO_APPLY flag being false by default is a deliberate signal rather than an oversight.

Key storage is the second gap. The README says API keys live in local app settings, that .env is for development overrides, and that OS keychain integration is planned. Planned is not shipped. If your threat model requires credentials in the platform keychain, the current arrangement does not meet it.

Distribution has a platform wrinkle. The macOS build is ad-hoc signed and not notarized, so first launch may require a manual Gatekeeper override. That is fine for a developer, awkward for anyone you hand the .dmg to.

There is also a class of user this tool simply does not fit. If you apply to a handful of roles through personal referrals and never touch an ATS board, the ingestion and ranking machinery has nothing to chew on. The value here scales with the number of leads you need to triage, not with how badly you want one particular job.

## How JustHireMe differs from cloud apply assistants and plain ATS aggregators

The nearest comparison is a cloud-based apply assistant. Those tools typically ingest your profile, run matching on their servers, and submit applications through their own automation. The difference is not just where the compute runs. It is what you can inspect. A cloud assistant returns a match decision you cannot audit. JustHireMe's README describes deterministic scoring rules, feedback learning and a graph-backed explanation for each fit score, all computed against a local Kùzu graph and LanceDB vectors. You can look at why a role scored the way it did.

The second comparison is a plain aggregator that pulls ATS feeds into one list. Aggregators solve discovery and stop there. JustHireMe adds a quality gate before ranking, then carries the surviving leads through to generated resume and cover letter PDFs. That is a longer pipeline, and a longer pipeline has more places to fail, but it also means the output is a document rather than a URL.

A third difference is the model layer. The README states that discovery, ranking and generation all run with zero API key, using local Ollama or an existing Claude Code or Codex CLI subscription, with keyed providers such as OpenAI, Gemini and Groq optional rather than required. Most hosted competitors invert that default. If you already pay for one of those CLI subscriptions, the marginal cost of running JustHireMe is disk space.

## Maintenance cadence, upgrades and what AGPL-3.0 means here

The repository is not archived, and the last push was on 2026-09-09. Releases are frequent: v1.7.0 on 2026-09-01, preceded by v1.6.2 on 2026-08-27 and v1.6.1 on 2026-08-26. The README states that every release is built by GitHub Actions from a v* tag, which is the mechanism that keeps the three platform installers in step with the tag.

Upgrades are handled in-app. The README says auto-update is built in and the application updates itself from the latest GitHub release. There is a release:verify-updater script in package.json, which suggests the update path is tested as part of release preparation, though the README does not document a rollback procedure if an update goes wrong. Treat that as an open question rather than a supported feature.

Licensing is AGPL-3.0. The LICENSE file carries that identifier, package.json declares "AGPL-3.0-only", and the repository also contains a COMMERCIAL_LICENSE.md and a CLA.md. The presence of a separate commercial licence file means the maintainer offers terms outside the AGPL for cases the copyleft does not suit. Whether your use triggers the network copyleft depends on how you deploy modified code, and that is a question for your own counsel, not something this article can settle. If you plan to embed JustHireMe in a service you expose to others, read COMMERCIAL_LICENSE.md before you build on it.

The practical maintenance cost for an individual user is low: the app updates itself, and the heavy runtime is cached after first run. The cost lands on contributors, who need Node, a Python 3.13 sidecar and the Tauri toolchain to run the development path at all.

## Conclusion

Adopt JustHireMe if you want your job pipeline on your own disk, you are willing to run a Tauri desktop build plus a Python sidecar, and you want explainable ranking rather than a black-box apply button. Do not adopt it if you need unattended auto-apply (that code is experimental and disabled by default), if you expect a notarized macOS build, or if AGPL-3.0 does not fit how you intend to distribute your work. Before committing, verify three things yourself: that your machine has Python 3.13 and Node available for the sidecar and frontend, that the first-run runtime download completes on your network, and that a single source adapter returns leads for the region you actually search in.

## FAQ

### Does JustHireMe require an API key to work?

No. The README states that discovery, ranking and generation all run with zero API key, using local Ollama or an existing Claude Code or Codex CLI subscription, and that keyed providers such as OpenAI, Gemini and Groq are optional rather than required.

### Which platforms does JustHireMe ship installers for?

The README states that every release ships a Windows .exe, a macOS .dmg plus .app, and Linux .deb and AppImage packages, all built by GitHub Actions from a v* tag. The macOS build is ad-hoc signed and not yet notarized, so Gatekeeper may need "Open Anyway".

### Does JustHireMe submit job applications automatically?

Not as part of the stable core. The README describes browser automation and auto-apply as an experimental lab that is disabled by default, and the .env.example file sets JHM_AUTO_APPLY to false.

## Sources

- [License: AGPL-3.0](https://github.com/vasu-devs/JustHireMe/blob/main/LICENSE)
- [Project website](https://www.JustHireMe.ai)
- [README](https://github.com/vasu-devs/JustHireMe/blob/main/README.md)
- [Releases](https://github.com/vasu-devs/JustHireMe/releases)
- [vasu-devs/JustHireMe on GitHub](https://github.com/vasu-devs/JustHireMe)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/vasu-devs-justhireme