Personal Project
Career Intelligence
Private repositoryCareer Intelligence is my “career brain”: an agentic system that owns my professional history as a curated, evidence-grounded knowledge graph and exposes capabilities on top of it. Given a job description, it retrieves relevant evidence, plans content deterministically, generates resume prose with AI, validates every claim against its sources, and renders the final document—archiving each run as an immutable session.
The governing idea: models are temporary, evidence is immutable, knowledge is durable. AI works inside strict deterministic boundaries—it may rank, evaluate, and phrase, but it can never invent experience or bypass validation.
Why I built it
The practical trigger was a job search. After three and a half years heads-down building, updating my resume took a surprising amount of time—multiple drafts, review rounds, second-guessing what to include. And a single generic resume undersells: every application deserves a version tailored to its job description, which simply does not scale by hand.
The deeper goal was to stop re-explaining my career to AI tools one chat at a time. I wanted a durable knowledge base— every project, skill, and situation captured as structured, interlinked evidence—that a model can load into context whenever it is needed, with capabilities layered on top: resume generation today; cover letters, interview preparation, and suitability statements on the same foundation next.
Two ideas shaped the design. Andrej Karpathy’s LLM-wiki pattern argues that knowledge should compound in curated, interlinked Markdown rather than be rediscovered from scratch on every query. And QMD, Tobi Lütke’s local hybrid search engine, made high-quality retrieval over that corpus practical without owning search infrastructure myself.
Designed as an agentic system
The system is organised as knowledge → capability → action → artifact. Knowledge answers “what is true about my career”. Capabilities are the verbs the domain exposes—productised operations with typed inputs, bounded context, and validated outputs. Actions are concrete invocations (a CLI today, MCP tools next). Artifacts are the durable results: resumes, reports, session archives—and they never write back into knowledge.
The model is treated the way a well-designed agent treats any tool: it receives a scoped evidence pack rather than the whole repository, works inside deterministic contracts, and its output is untrusted until it passes schema parsing and integrity checks. Agentic engineering, in this codebase, does not mean giving the model more freedom—it means giving it better-shaped tools.
Interfaces
how the domain is reached
Capabilities
what the domain can do
Knowledge graph
what is true — curated, evidence-backed Markdown
How a resume gets generated
Job description
Parse & validate
The job description becomes structured requirements with provenance—every extracted requirement knows where it came from.
Retrieve
Hybrid search over the knowledge graph via QMD: lexical + vector search with reranking, scoped to eligible evidence.
Evaluate & pack
AI ranks candidates against the requirements; deterministic caps and diversity rules assemble the approved evidence pack.
Plan
A content plan fixes positioning, experience depth, and exactly which evidence each resume section may cite.
Generate
The model phrases the approved plan into resume prose—nothing outside the plan, no new claims, no invented metrics.
Validate
Every generated claim is checked against its evidence IDs. Unsupported claims fail the run; gaps are reported, not hidden.
Render & archive
React and Playwright render HTML and PDF; the entire run is archived as an immutable, content-hashed session.
Tailored resume + immutable session
What it does
Knowledge graph in Markdown
Projects, skills, technologies, situations, and achievements live as typed Markdown entities with stable IDs and validated relationships. The corpus is human-curated, Git-versioned, and readable by both people and agents.
Hybrid evidence retrieval
Evidence discovery runs on QMD, a local hybrid search engine combining lexical search, vector search, and reranking. The migration from a custom engine was decided by a frozen benchmark, not by impressions.
Deterministic content planning
A planner selects which experience and evidence a resume may use, under explicit caps, coverage, and diversity rules. AI ranks and evaluates candidates inside those boundaries—it never chooses outside them.
Evidence-grounded generation
The model phrases approved plans only. Every generated claim is validated against selected evidence IDs, and unsupported job requirements are surfaced as gaps instead of being papered over.
Deterministic rendering
Structured resume documents are rendered to HTML and PDF through React and Playwright. Layout is owned by deterministic code, so rendering can never rewrite a claim.
Immutable session archives
Every run is archived with a deterministic, content-hashed ID: inputs, retrieval results, prompts, models, validation, and artefacts. Loading a session never reruns AI—history stays inspectable and reproducible.
Architecture
- Language & runtime
TypeScript, Node.js, CLI-first interface
- Contracts & validation
Zod schemas, frontmatter validation, graph integrity checks
- Retrieval
QMD hybrid search (lexical + vector + reranking)
- AI generation
OpenAI provider behind ports; output untrusted until validated
- Rendering
React, Playwright (HTML / PDF)
- Testing
Vitest, fixtures, retrieval benchmarks, visual tests
The codebase follows a layered architecture: a CLI composes application services over a pure domain model, with filesystem, AI providers, and rendering kept behind ports. Deterministic code owns schemas, selection contracts, identity facts, and failure behaviour; AI output is treated as untrusted until it passes Zod parsing and integrity checks. Swapping the model provider—or the retrieval engine, as the QMD migration proved—does not touch the domain.
Where it is now
An MCP server now exposes the knowledge graph as tools—hybrid evidence search with provenance, entity and graph reads—over the same application services the CLI uses, not a second implementation. It runs locally over stdio for my own assistants, and remotely over authenticated HTTP serving a deliberately public subset of the corpus.
That remote server powers the idea I like most, now live: the “Ask about my work” chat on this site. Visitors ask questions— “has Alan built agentic AI systems?”—and get answers grounded in cited evidence rather than marketing copy, with anything marked private staying invisible. Further out, a raw evidence store and replaceable compiler agents will let knowledge be recompiled from immutable originals as models improve, instead of being hand-patched forever.
Career Intelligence is built around a simple conviction: agentic systems earn trust through boundaries, not capability. The interesting engineering is not the generation step—it is everything around it that guarantees the output stays true.