A local agentic job-processing pipeline combining deterministic job deduplication, LLM-based suitability analysis, application-state tracking, CV synchronization, and a lightweight Go terminal dashboard.
Project status: Independent engineering project / local prototype. It automates a personal workflow and is not presented as a production SaaS platform.
Job-search automation mixes deterministic work with probabilistic reasoning.
Some tasks should not require an LLM:
- duplicate detection
- local-state validation
- CV synchronization
- application tracking
Other tasks benefit from semantic reasoning:
- interpreting job requirements
- comparing requirements with a candidate profile
- deciding whether a position is worth pursuing
Career Autopilot separates those concerns.
Job Sources
|
v
+---------------------+
| Ingestion / Parsing |
+----------+----------+
|
v
+---------------------+
| Deterministic |
| Deduplication |
+----------+----------+
|
v
+---------------------+ +--------------------+
| Candidate Profile | | Job Specification |
| profile.yml | | normalized data |
+----------+----------+ +---------+----------+
| |
+-------------+---------------+
|
v
+----------------------+
| Career-Ops AI Agents |
| Claude / Gemini |
+----------+-----------+
|
v
+----------------------+
| Suitability / |
| Apply-or-Skip Logic |
+----------+-----------+
|
+-------+-------+
| |
v v
SKIP STAGING
|
v
CV Synchronization
|
v
Application Tracker
|
v
Go Terminal UI
The Go TUI acts as an observability layer over the local pipeline rather than as part of the LLM reasoning path.
- Job descriptions enter the local pipeline.
- Ingestion normalizes available job data.
dedup-tracker.mjsremoves already-processed/duplicate job IDs before expensive model calls.- Candidate profile and job information are supplied to the career-ops agents.
- Claude/Gemini-based agents perform semantic suitability analysis.
- Relevant jobs move into the staging/application workflow.
- CV synchronization checks ensure the current application asset is used.
- Local state is exposed through the Go terminal dashboard.
JOB
|
v
Deterministic checks
/
duplicate new job
| |
DROP v
LLM semantic reasoning
|
+------+------+
| |
SKIP APPLY
|
v
deterministic
CV/state checks
Duplicate detection is deterministic and inexpensive, so the system avoids spending an LLM call on a decision ordinary program logic can make exactly.
The career-ops workflow performs semantic reasoning over job requirements and candidate information.
The surrounding pipeline remains deterministic where possible, so the AI layer does not become the source of truth for application state.
The repository uses local YAML/JSON state and DATA_CONTRACT.md to define expected pipeline structures.
This matters because the Go dashboard and application-tracking scripts consume the AI pipeline's outputs. Model output is therefore treated as application data that must conform to a contract rather than arbitrary text passed directly downstream.
The project uses Go for a lightweight terminal UI instead of another web frontend.
The dashboard:
- displays pipeline progress
- exposes application state
- renders a Kanban-style view
- consumes local pipeline state
- keeps the operational interface lightweight
The repository reports sub-50ms state-update rendering in its local environment. This is a prototype measurement, not a production performance guarantee.
Duplicate detection is deterministic and inexpensive. Running the same job through an LLM multiple times wastes latency and API budget.
The system is local and single-user, so JSON/YAML files are sufficient for the current state-management requirements. A database becomes more useful for concurrency, transactional state, and larger history.
The dashboard is an operational interface for a developer workflow. A terminal UI avoids adding another application stack just for visualization.
The LLM can recommend an action, but deterministic scripts maintain the actual pipeline state.
External job pages can change their DOM or data structures.
Mitigation: isolate ingestion from downstream processing.
Parallel processing can hit provider rate limits.
Mitigation: the batch runner includes backoff behavior, but the local prototype does not claim a fully durable distributed job queue.
A process terminated during a write could corrupt local tracker state.
Possible improvement: SQLite or another transactional state store with durable writes.
Different providers can return semantically similar but structurally different outputs.
Mitigation: enforce a shared data contract before downstream components consume results.
The project emphasizes deterministic controls around the AI workflow:
- duplicate jobs are filtered before model calls
- pipeline state is tracked explicitly
- data contracts define expected structures
- Go provides a live operational view
- CI includes Go tests, CodeQL scanning, and SBOM generation
These are engineering controls around a local agentic workflow, not proof of production reliability.
If expanded beyond a personal local tool, the main changes would include durable state storage, queue-based execution, distributed workers, provider fallback, structured evaluation of suitability decisions, monitored job-source adapters, application auditing, secret management, cost/token telemetry, multi-user isolation, and stronger failure recovery.
Agentic systems benefit from a deterministic shell around probabilistic reasoning.
The LLM is useful for interpreting ambiguous job requirements, but it should not be responsible for duplicate detection, application state, file synchronization, or the basic integrity of the pipeline.
Career Autopilot is best described as:
A local agentic job-processing and application workflow combining deterministic automation with LLM-based semantic reasoning and terminal observability.
It is not presented as an autonomous production job-application service.