Stop rewriting. Start compounding.
Write down what you did, once. Maestro builds every tailored resume, cover letter and screening answer from that record. Scored by an engine that never guesses. Typeset locally into a real PDF. About a penny an application.
Apache-2.0 · runs on your machine · works with Claude, ChatGPT, and Cursor via MCP.
One real run: 49.2 to 70.8, every AI edit shown as a diff you can revert, and a typeset PDF at the end.
≈1¢
per application
Measured on real applications. Not guessed at.
83
MCP tools
Run the whole pipeline from Claude, Codex or ChatGPT desktop.
3
local containers
Bound to 127.0.0.1. No account, no cloud, no upload.
0
LLM calls in scoring
Same resume, same posting, same number. Enforced in CI, not claimed in a README.
The premise
Your effort should compound. Right now it evaporates.
A single opening now routinely draws hundreds of applications, and screens increasingly flag resumes that read like a machine wrote them. Volume stopped working. Depth is the only lever left, and depth is only affordable when last month's work is still sitting there.
Write it once. Reuse it forever.
Why you'd want this
You already know these feelings.
Each one is a specific, ordinary part of a job search that software should have fixed by now. Here's the pain, and here's what fixes it.
You hate that resume tailoring is a slot machine.
A score that never guesses.
Most checkers ask an LLM. One popular tool scored the same resume anywhere from 66 to 99 across a hundred runs. Maestro has no LLM in the scoring path at all, so the same resume against the same posting returns the same number and the same breakdown. Every time.
Your folder is a graveyard of resume_v2_FINAL(3).docx.
Version history, not a pile of copies.
Every edit becomes a version: manual, chat, tailoring run, even a restore. Diff any two. Restore any one. Old variants get archived instead of deleted, so the bullet you wrote in March is still findable in September.
LaTeX looks great and is miserable to edit. Tailoring one, unthinkable.
LaTeX quality without LaTeX editing.
You edit content in a structured editor. A bullet is a bullet, not a .tex line you hand-patch. Layout stays the template's job, so changing a word can't break your formatting.
How many resume templates have you changed in your life?
One or two. Here it's a button.
In Word or raw .tex, a redesign means rebuilding the document, so nobody bothers. Here a template owns presentation and nothing else. The same content renders through any design without being touched.
You re-explain how you want to sound in every single prompt.
Say it once. It sticks.
Your persona holds who you are as a candidate: strengths, goals, working style, how your writing should read. Set it once and every generated document comes out in that voice. It shapes tone and emphasis, never facts.
What makes it different
Three commitments, and everything else follows from them
Each one costs something a subscription product is unwilling to pay. That is why nothing else in this category does all three.
Scoring that can't drift
No LLM anywhere in the scoring path. Deterministic lexical layers plus a pinned embedding model running on your CPU. Same resume, same posting, same config: the same number and the same breakdown, run after run.
Determinism is enforced by the test suite in CI, not asserted in a README.
Evidence, not invention
Resumes compose from approved points in your Career KB, word for word. Rewriting a bullet is a separate step that asks first. A keyword with no evidence behind it reaches your skills list and nowhere else.
Every edit is a version. Nothing is lost, nothing is one-way.
It leaves with you
Apache-2.0. No account, no subscription, no usage tier. You pay for the tokens you spend and nothing else. Your KB exports to one career.md you can read and diff.
About a penny an application, against $15–75 a month.
The loop
Five steps, and the fourth one is where the value is
Built for few, well-evidenced applications rather than volume. Depth per application is the only lever left.
01
Feed the Career KB, once
Every resume variant you own. The old ones, the role-specific ones, the one that runs to three pages.
02
Build a base resume per track
One per track you actually target. Not one per job.
03
Capture the job, then pre-scan it
Paste the posting, or grab it with the extension from the board you're already reading.
04
Work the gaps
A gap is a requirement your resume doesn't evidence yet.
05
Render it, read it, track it
Cover letter, screening answers, and a real LaTeX or Typst PDF compiled on your machine.
Walk the whole loop, step by step.
How it worksInside the studio
The parts you will actually live in
Everything below is in the shipped app. These are real captures, not mockups.
The record
A Career KB that resolves your history
Add your resume variants and Maestro performs entity resolution, deduplication, bullet clustering and profile synthesis. What comes out is one structured record of your work, projects and skills. Certifications, project write-ups and review notes belong in there too.
Approved points compose word for word into resumes and applications
Verbatim bullets from your own files import approved; merged and model-written points wait for review
Every point keeps provenance back to the document it came from
Seeding defers cleanly with no API key and retries on a later boot
The measurement
Deterministic scoring, and a measured lift
Deterministic lexical layers plus a pinned embedding model for semantics. Soft matches need both a shared lexical anchor and embedding proximity, so “container orchestration” earns credit against Kubernetes without inventing a skill you don't have.
Same resume, posting and config version gives an identical score and breakdown, run after run
Recency is one of the inputs, so a document scored months apart can move as its work ages. Nothing else does.
Base-to-tailored delta recorded per application, so you can see if tailoring did anything
Runs offline on CPU. Scoring never calls a model.
Agent surfaces
The assistant you already use can drive all of it
Maestro ships an MCP server. Extract a posting, score it, walk the gaps, render the PDF, all without leaving Claude, the ChatGPT desktop app or the Codex CLI. Unlike SaaS-backed job-search servers, it runs on your machine against your database.
Installed from your client's settings
Claude takes an extension file, Codex and the ChatGPT desktop app a plugin marketplace. Both install from their own settings: no terminal, no config file. ./scripts/setup-mcp.sh covers every other client.
Six profiles keep the tool list relevant per chat. Every install defaults to full; scope it later if you like, one at a time.
No API key? Over MCP your assistant is the model, so tailoring and KB upkeep still work.
Agents, hunting and the consent ledgerLocal-first isn't a marketing word here. It's the architecture.
Three containers on your machine, every port on 127.0.0.1. No account, no tenancy, no server holding your career history. One hard rule follows from that.
Read the honest versionNothing is uploaded
Scoring, rendering, tracking and export run locally. The only outbound traffic goes to the one LLM provider you configure.
Your key stays yours
It lives in your .env or your local database and goes to exactly one place: the provider endpoint you set. The API never echoes a stored key back out; the settings endpoint reports only whether one is configured. A non-http(s) model endpoint is refused outright, because that URL decides where your key is sent.
No telemetry leaves your machine
The extension's one telemetry endpoint posts to your own backend on localhost. There is no collector at the other end, in this repo or anywhere else.
Your data is files you own
Resumes are JSON on your disk. Renders land in company-and-role folders. Your KB exports to one career.md with no model involved.
Get running
Three parts, and only the first is required.
The rest attach whenever you want them.
git clone https://github.com/seinun-ai/maestro-career-studio.git
cd maestro-career-studio
cp .env.example .env
# Downloads prebuilt images, about 1 GB. Your API key comes later,
# inside the app: Settings -> Models after first boot.
docker compose up -dQuestions
The ones worth answering up front
Recommended, yes. The parts that make Maestro fastest day to day run on it: in-app tailoring, the extension's tailor-on-the-go and form filling, cover letters and screening answers, KB consolidation, chat. One key, OpenAI or Gemini, is a complete setup. Without one you still get the deterministic core, and if you drive it over MCP your assistant supplies the model.
About a penny per tailored application on the default profile, under 3¢ on the fast one. Measured with Langfuse on real postings at list prices. My whole search so far has cost under $2 in tokens. The software is Apache-2.0: no account, no subscription, no tier.
No. Three containers on your machine, bound to 127.0.0.1. The only outbound traffic goes to whichever LLM provider you configure, and your key goes to exactly that endpoint. It lives in your .env or your local database, and the API never echoes it back out.
You can point it at any OpenAI-compatible endpoint, including Ollama, LM Studio and vLLM. We won't claim it works, because we haven't validated a local model end to end. Long tailoring prompts, strict JSON and streaming tool calls are where small models struggle. The deterministic core never calls a model at all, so that half is genuinely offline today.
It's our score: deterministic, versioned, reproducible. It doesn't predict what an employer's ATS shows them, and no consumer tool can. One caveat worth knowing: recency is part of the score and it is measured against today, so the same document can score slightly differently months apart as its work ages. Everything else holds still. Use it to compare your own drafts and to catch parsing and coverage problems. Chasing 100 gets you a keyword-stuffed resume that modern screens flag.
It carries an application to the point of submission and stops. Filling and submitting happen only inside a live agent session you're running, with consent recorded one turn before the click and a daily cap you set. Nothing is submitted from the web app, and a submit click that can't be verified ends there rather than being retried.
Yes, that's the point of the template layer. Start from a bundled LaTeX or Typst design, adapt one you found, or write your own in the editor. Validation compiles a sample PDF and runs a parse gate, so a design that would break an ATS parser never ships.
English resumes and job descriptions, with full support for accented Latin characters (Zürich, José, Nestlé, São Paulo). Non-Latin scripts are refused at ingest rather than scored misleadingly at zero coverage.
Early, and the repo says so. KNOWN_ISSUES.md lists what's solid, what's rough and what's a deliberate limitation: the tracker doesn't paginate server-side, scores aren't re-derived when a base resume changes, and autofill isn't first-try-clean on every ATS. If something breaks, a clear bug report is the most useful thing you can send.
It's early. I'd rather hear about it.
I built this because I needed it, and I use it every day. It is early, and early software has edges. If something breaks, tell me. A clear bug report is a contribution and right now it's the most useful kind. Pull requests welcome too.
Ajey Dhayashanker Loganathan
Career tooling should be infrastructure, not a rental.
Clone it, run it, keep everything it produces. Nothing here was built to make leaving hard.
Apache-2.0 · no account · no subscription · your data stays on your disk