LangHire

AI-powered job application automation with a native desktop UI

English · हिन्दी · Deutsch · Français · Español · العربية · Nederlands · 日本語 · 한국어 · Português · Bahasa Melayu

Applying to jobs is tedious. You find a listing, click through to the application, fill in the same fields you filled in yesterday, answer the same screening questions, upload your resume again — repeat fifty times. LangHire automates the entire loop.

It uses AI browser agents to search LinkedIn, collect matching jobs, fill out applications, upload your resume, and submit — while a self-learning memory system remembers how each applicant tracking system (ATS) works so it gets faster and more accurate over time. Everything runs locally on your machine. No data leaves your computer except LLM API calls.

Download

macOS	Windows	Linux
Apple Silicon (.dmg)	64-bit Installer (.exe)	AppImage (Universal)
Intel (.dmg)		Debian / Ubuntu x64 (.deb)
		Debian / Ubuntu ARM64 (.deb)

_{Requires an LLM API key (OpenAI, Anthropic, or AWS). Chromium is installed automatically on first launch. See Quick Start.}

Developers -- See Development Setup to run from source.

Installation Notes

chmod +x LangHire_1.0.0_amd64.AppImage
./LangHire_1.0.0_amd64.AppImage

# Install uv package manager (required for browser management)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install the app
sudo dpkg -i LangHire_1.0.0_arm64.deb

Features

• Native desktop app -- macOS, Windows, and Linux
• Plugin-based job sources -- LinkedIn, Indeed, SEEK, Naukri, Reed, StepStone ship as built-in YAML plugins. Write your own plugin for any job site in minutes — no code required, just a YAML file with prompts. Import community plugins via the UI.
• Global ATS support -- 30+ applicant tracking systems supported out of the box (Workday, Greenhouse, Lever, iCIMS, SmartRecruiters, Taleo, SuccessFactors, Personio, Teamtailor, Darwinbox, and more). The self-learning memory system transfers knowledge across all sites using the same ATS — apply on one Workday site, and every future Workday application benefits.
• 18 countries, 11 languages -- Country-aware profiles (date formats, currencies, work authorization, notice periods) with full UI translation. Auto-detects language from your country.
• Job collection -- AI browser agent searches your selected platform for jobs matching your target titles and locations
• Automated applications -- AI agent fills forms, uploads your resume, answers screening questions
• AI cover letter generation -- One-click tailored cover letters using your LLM, customized per job description
• Tailored resumes (beta) -- Auto-customizes your resume for each job description
• Self-learning memory -- Stores per-ATS procedural knowledge (navigation patterns, form strategies, UI quirks). Lessons from one Workday site apply to all Workday sites globally.
• Smart Q&A reuse -- Learns answers from previous applications and reuses them
• Multi-LLM support -- OpenAI, Anthropic, AWS Bedrock, Ollama, or OpenRouter (100+ models)
• Dashboard -- Real-time stats, success rates, per-domain performance, memory impact analysis
• CLI tools -- Power-user scripts for collection, application, memory management, and analytics
• 100% local -- All data stored on your machine in your OS app data directory

Screenshots

Dashboard

Jobs

Memory

_{Click any screenshot to expand}

Quick Start

1. Download and install from the Download section above
2. Open the app -- Chromium downloads automatically on first launch (~400 MB, one time)
3. Setup wizard walks you through: LLM provider → Resume upload (auto-parses your profile) → Review profile → Ready
4. Collect jobs -- go to Jobs → enter a job title → Start Collecting
5. Apply -- go to Apply → Start Applying and watch the dashboard as applications roll in

How It Works

LangHire runs a three-stage loop: Collect → Apply → Learn.

Collect -- An AI browser agent logs into LinkedIn, searches for jobs matching your target titles and locations, and saves each listing with its URL, company, title, and description.

Apply -- For each pending job, the agent opens the application (Easy Apply or external ATS), fills every field using your profile, uploads your resume, answers screening questions from its Q&A bank, and submits. Multiple workers can run in parallel.

Learn -- After each application, the system extracts procedural learnings: which buttons to click, how forms are structured, what fails and what works. These memories are stored per-ATS domain with confidence scores, so next time it encounters the same ATS, it already knows how to navigate it.

Architecture

┌──────────────────────────────────────────────────┐
│              Tauri Desktop Shell (Rust)           │
│     Lightweight native wrapper, ~10 MB           │
└────────────────────┬─────────────────────────────┘
                     │ spawns sidecar
                     ▼
┌──────────────────────────────────────────────────┐
│  React Frontend          │  FastAPI Backend      │
│  (TypeScript)            │  (Python sidecar)     │
│                          │                       │
│  - Dashboard             │  - browser-use agents │
│  - Profile editor        │  - Playwright browser │
│  - LLM settings          │  - Memory system      │
│  - Job browser           │  - Multi-LLM factory  │
│  - Apply controls        │  - 20+ REST endpoints │
│  - Memory viewer         │                       │
│          ◄── HTTP localhost:8742 ──►             │
└──────────────────────────────────────────────────┘
                     │
                     ▼
        SQLite + JSON (OS app data directory)

All data is stored locally:

Development Setup

Prerequisites

Clone and Install

git clone https://github.com/jaimaann/LangHire.git
cd LangHire

npm install                                    # Node dependencies
uv sync                                        # Python dependencies
uv run python -m playwright install chromium   # Browser engine

Run in Development

Two terminals:

# Terminal 1 -- Python backend
uv run python backend/main.py

# Terminal 2 -- Frontend dev server
npm run dev

Open http://localhost:1420, or run as a native desktop app instead:

# Terminal 2 (alternative) -- Native Tauri app
cargo tauri dev

The first cargo tauri dev compiles the Rust shell (~2 min). Subsequent runs are fast.

Build for Production

cargo tauri build

Produces platform-specific installers in src-tauri/target/release/bundle/.

Project Structure

LangHire/
├── src/                        # React frontend (TypeScript)
│   ├── pages/                  # Dashboard, Profile, Jobs, Apply, Memory, Settings, LLMSettings, Logs
│   ├── components/             # UI primitives, SetupWizard, Sidebar, LoginCards
│   └── lib/                    # API client, TypeScript types
│
├── backend/                    # Python backend (FastAPI)
│   ├── main.py                 # Server with 20+ endpoints
│   ├── core/                   # Config, LLM factory, shared utilities
│   └── memory/                 # SQLite store, post-run extractors, metrics
│
├── src-tauri/                  # Tauri native shell (Rust)
│   ├── src/lib.rs              # App setup, sidecar launch
│   └── tauri.conf.json         # Window config, permissions, bundling
│
├── cli/                        # CLI automation scripts
│   ├── collect_jobs.py         # Job collection
│   ├── apply_jobs.py           # Job application (multi-worker)
│   ├── apply_jobs_tailored.py  # Tailored resume variant
│   ├── dashboard.py            # Terminal analytics dashboard
│   └── memory_cli.py           # Memory management
│
└── scripts/                    # Build helpers (macOS DMG, backend bundling)

CLI Usage

The CLI scripts work standalone alongside the desktop app:

# Collect jobs from LinkedIn
uv run python cli/collect_jobs.py

# Apply to jobs (3 parallel workers)
uv run python cli/apply_jobs.py --workers 3

# Apply with per-job tailored resumes
uv run python cli/apply_jobs_tailored.py --workers 2

# Memory management
uv run python cli/memory_cli.py stats
uv run python cli/memory_cli.py domains
uv run python cli/memory_cli.py show linkedin.com

# Terminal performance dashboard
uv run python cli/dashboard.py

Contributing

Contributions are welcome. See CONTRIBUTING.md for full guidelines.

git clone https://github.com/jaimaann/LangHire.git
cd LangHire
npm install && uv sync
uv run python backend/main.py   # Terminal 1
npm run dev                     # Terminal 2

Areas where help is needed:

• More job platforms -- Indeed, Glassdoor, and other job listing sites beyond LinkedIn
• Local LLM support -- Ollama, llama.cpp, and other local inference options
• Multi-country support -- Localized job sites, address formats, and work authorization flows
• Documentation -- Tutorials, video walkthroughs, and guides
• Testing -- Unit, integration, and E2E test coverage

License

MIT

Disclaimer

This tool automates job applications on LinkedIn and other platforms. Use it responsibly:

• Respect each platform's Terms of Service and rate limits
• Don't spam employers with low-quality applications
• Review your profile and settings before running automated applications
• You are responsible for all applications submitted through this tool

Built with Tauri, React, Python, and browser-use