The app UI is in Traditional Chinese, tailored to Taiwan's job-search conventions (104 / Cake / Yourator / LinkedIn). Data is stored locally by default; when you run AI features, your résumé and prompts are handled by the CLI, local model, or BYOK backend you choose. See Privacy and Data Handling.

An accountless public Web preview mode is also available for mobile testing. It forces no-AI matching, stores no server-side resume/search history, and exposes only resume-to-job search plus in-browser filtering. Open Jobsmith Web, or see Public Web preview deployment.

---

Mobile Web (no AI, no install)

📱 Open Jobsmith Web on your phone

No app installation, AI account, or API key is required. The public Web preview lets you:

• Upload a PDF, DOCX, or TXT resume from your phone, then review and freely edit the target roles.
• Search 104, Cake, Yourator, LinkedIn, and other sources with deterministic 0-AI matching and a market-skills radar.
• Refine the current results by keyword, location, source, work mode, fit, experience, and salary without rerunning the search.
• Wait in an automatic queue during traffic spikes; identical search scopes briefly share public job-source data to reduce latency and third-party load.

The public site creates no account and does not write resumes, Profiles, personal match scores, or search history to a server database. Its short-lived shared cache contains only search keywords/scope and public job listings. Your full resume is still sent to the Jobsmith Web server for that request, so remove unnecessary phone, email, and address fields before testing. The site operator may enable server-side anonymous traffic and conversion events that exclude resume and search content; desktop telemetry remains disabled. See Privacy and Data Handling for the exact data flow and Anonymous product analytics for operator setup.

The preview currently runs on free test infrastructure. A cold first visit can take about a minute, and traffic spikes can show a queue position. Use the desktop app below for AI application packages, resume audits, mock interviews, and durable local history.

---

Feature Overview

• No-AI job discovery: upload a resume, review or edit up to three target roles, and search 104 / Yourator / LinkedIn / Cake with deterministic local matching.
• Mobile Web entry: the public mode provides deterministic resume recognition, job search, local result filtering, and links to original postings without an AI account.
• Ranked results: stream search results, score fit, and open the right jobs for an application package.
• Package workbench: generate tailored resume bullets, cover letters, interview prep, and company research.
• Resume health check: audit ATS fit, show deep-check or fallback status, and keep local report history.

---

Download

Windows

⬇ Download Jobsmith for Windows (64-bit) — a single .exe. No Python or Node.js required.

1. Grab Jobsmith.exe from the latest release.
2. Double-click it. A native window opens (the first launch unpacks for ~10–30s).
3. In the top-right control panel, choose your AI engine:
   • Local CLI — a logged-in Claude Code (claude) or Codex CLI (codex) on your PATH, or
   • Local model — a running Ollama server (default http://127.0.0.1:11434/v1) or llama.cpp server (default http://127.0.0.1:8080/v1), or
   • BYOK — base_url + api_key + model for any OpenAI-compatible endpoint (OpenAI, DeepSeek, Gemini, Groq, OpenRouter, Ollama, LM Studio, vLLM…).

Requirements: Windows 10/11 (64-bit; WebView2 is built into Windows 11). Desktop history, settings, and .env are saved next to the .exe, and AI requests go only to the backend you choose. The limited public Web preview has a separate privacy model.

macOS

• ⬇ Download Jobsmith for macOS Apple Silicon — M1 / M2 / M3 / M4
• ⬇ Download Jobsmith for macOS Intel — Intel Macs

The macOS build is an unsigned .dmg. It is not signed with an Apple Developer ID and is not notarized, so first launch may trigger Gatekeeper. Open the DMG, drag Jobsmith.app to Applications, then use right-click → Open, or allow the app in System Settings.

The macOS app stores data and .env in ~/Library/Application Support/Jobsmith.

Maintainers can run Actions → Build unsigned macOS DMG manually; the workflow has a publish_release=true option that replaces the DMG files on a chosen release tag.

Quick Start (from source)

Prerequisites: Python 3.11+, Node.js 20.19+ / 22.13+ / 24+, and either a logged-in Claude Code (claude) / Codex CLI (codex) on your PATH, a running Ollama/llama.cpp server, or a BYOK key.

git clone https://github.com/kevin333353/jobsmith.git
cd jobsmith

setup.bat            # Windows  — one-time setup (venv + deps + frontend build)
# ./setup.sh         # macOS / Linux / Git Bash

desktop.bat          # launch as a native desktop window (recommended)
# run.bat            # or web mode → http://localhost:8000

Mode	Command	Notes
Desktop app	desktop.bat (or python desktop.py)	Native window; first run shows a backend picker.
Web	run.bat (or python -m uvicorn app.server:app --port 8000)	Open http://localhost:8000.
CLI (one JD)	python -m app.cli data/demo_jobs/ai_engineer.txt	Headless single-JD run.

To build your own Windows .exe: pip install pyinstaller && pyinstaller jobsmith.spec --noconfirm → dist/Jobsmith.exe. To build the unsigned macOS .app, build the frontend on macOS and run: python -m PyInstaller jobsmith-macos.spec --noconfirm --clean → dist/Jobsmith.app.

Table of Contents

• Mobile Web (no AI, no install)
• Feature Overview
• Download
• Quick Start
• Features
• LLM Backends
• Privacy and Data
• Architecture
• Evaluation
• Tech Stack
• Project Structure
• Testing
• Roadmap
• Contributing
• Disclaimer
• License

Features

• Auto job search — the default no-AI mode recognizes roles, skills, and experience locally, then lets you confirm or edit up to three target roles before searching 104 / Yourator / LinkedIn / Cake in parallel. Optional scope controls cover region, confirmed/inferred remote or hybrid work, experience, salary, named companies, and source depth. Once results arrive, refine the current pool instantly without another source or AI call.
• Market skills radar — summarizes recurring skills in the current relevant job pool, separating evidence already found in the resume from common gaps without treating missing job-source fields as candidate weaknesses.
• Search history — every desktop search is auto-saved; revisit it, apply the same local refinements, regenerate a package, or delete it.
• Résumé health check — scores against Taiwan ATS conventions with concrete fixes and before/after rewrites.
• Application-package workbench — generation is progressive and artifact-on-demand: the default quick path produces a tailored resume, while a short letter, company research, interview kit, and one-pass AI review are explicit options. Existing job-search analysis is reused, automatic rewrite loops are removed, and each selected artifact is saved as soon as it is ready.
• My packages (library) — every generated package lands here with a status (in-progress → pending review → approved). Review, approve, or delete each, re-open one to the workbench, launch a mock interview from it, and export to Word (.docx) (PDF via the browser's print dialog).
• Mock interview — generates questions from the JD and your résumé, with per-answer feedback and scores. Start from any saved package or a pasted JD; each job gets its own conversation tab, so you can run several mock interviews side by side without overwriting.
• Personalization — remembers your most recent résumé (no re-upload) and preferences (target titles, tone, skills to emphasize) across sessions, and applies them to outputs.

LLM Backends

Pick your AI engine from the top-right control panel — a local CLI subscription (no API key), a local model (Ollama / llama.cpp), or BYOK (any OpenAI-compatible endpoint). Selecting a backend takes effect immediately; the Test button is an optional connection check, never a gate. Local CLIs offer a rescan action and a selectable model.

Backend	Auth	Notes
claude_cli	Claude Code subscription	Default. No API key; strips ANTHROPIC_* env. Model selectable (auto-tiered by default).
codex_cli	Codex subscription	No API key. Model selectable; defaults to your Codex config.
ollama	Local model	Defaults to Ollama; can be switched to llama.cpp server or a custom local OpenAI-compatible endpoint. Detects local models for dropdown selection; quality and speed depend on your hardware and model.
openai	BYOK — any OpenAI-compatible endpoint	base_url + api_key + model. Works with OpenAI, DeepSeek, Gemini, Groq, OpenRouter, Ollama, LM Studio, vLLM…

CLI backends call the corresponding provider through the logged-in CLI on your machine. Local models and BYOK both call the OpenAI-compatible endpoint you configure. Full AI features remain local-first or self-hosted; BYOK and local-model settings are written only to your local .env. The public Web preview accepts no AI keys. An API-key backend (anthropic) also exists for self-hosting or CI.

Privacy and Data

The desktop app stores profile memory, preferences, searches, generated packages, .env, and error logs locally. The public Web preview creates no account or server-side resume record, but the server processes each upload for that request and the browser retains compact search results locally. Use Settings → Clear personal data on desktop, or clear the site's browser data for the Web preview.

When you run AI features, your résumé, job descriptions, and prompts are sent to the AI backend you selected. Read Privacy and Data Handling before using the app with sensitive data.

Architecture

React SPA (Vite)  ──HTTP · SSE · poll──►  FastAPI
                                            │
                  ┌─────────────────────────┼────────────────────────┐
                  ▼                         ▼                       ▼
        LangGraph StateGraph           Job sources             App SQLite
        (one per background run,       104 / Yourator /        (packages w/ status
         own in-memory checkpoint,     LinkedIn / Cake          進行中→待審→已核可,
         runs in parallel)                                      memory, searches)
                  │
                  ▼
          Pluggable LLM backend
          claude_cli · codex_cli · ollama (local) · openai (BYOK)

• Background generation: each Generate spins up its own LangGraph StateGraph with a private in-memory checkpointer, run on a small thread pool — so jobs run in parallel and survive client disconnects (refresh / navigation). The browser polls /api/run/events for live progress; the finished package is written to the app database. This decouples the run from the HTTP request — closing the tab doesn't stop it.
• Job search streams results to the browser over Server-Sent Events as each source returns and each job is scored.
• An application-level SQLite database holds packages with a lifecycle status (in-progress → pending review → approved), user memory, and saved searches; you review and approve in My packages. (The standalone CLI still uses a resumable, file-backed human-approval gate via interrupt() / Command(resume=…).)
• On the CLI backends, models are tiered automatically: haiku for extraction, sonnet for matching/generation, opus for the Critic/Supervisor (overridable per backend).

Evaluation

Does the Supervisor reflection loop (Critic → revise un-passed documents → re-critique) actually improve output quality? A small golden set of 5 job/résumé pairs is run with reflection off (no revisions) and on, and the resulting Critic scores are compared:

Reflection	Critic pass rate	Mean quality score
Off	60% (3/5)	85.6
On	100% (5/5)	87.5

Reflection lifts the Critic pass rate by +40pp (60% → 100%) and mean quality by +1.9 (85.6 → 87.5) across the 5 golden cases. Both "off" failures were cover letters making unverified company claims or an unsupported experience claim — exactly what the Critic → revise loop catches. (One harness run; LLM calls are non-deterministic, so exact numbers vary run to run.)

python -m app.evals.harness     # runs the graph on each golden case, writes app/evals/results.json

The summarize() step is a pure function with its own unit tests, so the aggregation logic is verified independently of the (non-deterministic) LLM calls.

Tech Stack

Layer	Technologies
Backend	Python, FastAPI, LangGraph, LangChain, Pydantic v2, SQLite, BeautifulSoup
Frontend	React 19, TypeScript, Vite, Tailwind CSS, lucide-react
LLM	Claude Code CLI / Codex CLI (local) · Ollama / llama.cpp local models · any OpenAI-compatible endpoint (BYOK)
Desktop	pywebview (native window) · PyInstaller (single-file .exe / unsigned .app, distributed as .dmg on macOS)

Project Structure

app/
  agents/     # résumé eval, job search, company research, refine chat, interview sim, …
  sources/    # 104 / Yourator / LinkedIn / Cake search + registry + region map
  store/      # app-level SQLite: history, memory, searches
  intake/     # résumé/JD parsing and fetching
  export/     # Word (.docx) export
  graph.py    # LangGraph StateGraph (agents + human gate)
  server.py   # FastAPI + SSE endpoints
  llm.py      # pluggable LLM backend resolution
frontend/     # Vite + React + TS + Tailwind SPA
tests/        # pytest suite
desktop.py    # native-window launcher    jobsmith.spec / jobsmith-macos.spec  # PyInstaller build

Testing

pytest                         # unit/integration suite (live API tests skipped by default)
pytest -m live                 # include tests that call the real API
cd frontend && npm run lint    # frontend lint
cd frontend && npm run build   # type-check + production build

Roadmap

• Single-file Windows desktop app (PyInstaller)
• unsigned macOS .dmg GitHub Actions build
• BYOK — any OpenAI-compatible backend
• Ollama / llama.cpp local model backend
• Background, refresh-proof package generation with parallel runs
• macOS signing and notarization
• Linux builds
• More job sources

Contributing

Issues and pull requests are welcome. For non-trivial changes, please open an issue first to discuss the approach. Run pytest, npm run lint, and npm run build before submitting. Before publishing a Windows .exe, run the clean-environment smoke test in the Release Checklist.

Disclaimer

This project is for personal, educational, and research use. It queries public job listings from 104 / Yourator / LinkedIn / Cake at low frequency to help an individual job seeker. You are responsible for complying with each site's Terms of Service and robots.txt; do not use it for bulk scraping or commercial data harvesting. The software is provided "as is", without warranty of any kind. LLM-generated content (résumés, cover letters, company research) may contain inaccuracies — always review before use.

License

Released under the Apache License 2.0.