Technology

You, Robot: Job Search as a Product Manager with an Agent

By Stephen Bolen,

Published on Nov 17, 2026   —   11 min read

Work
Photo by Leon JL / Unsplash

Summary

How I wired a personal agent, Reactive Resume, and a Kan board into one system to automate my job search.

So, a funny thing happened on October 27 – my role at Mastercard was eliminated in a large corporate restructuring. I, along with many others, found myself thrown into the blender of the current tech job market.

So, I'm running a job search the way I'd run a product: with a backlog, a definition of done, and an uncomfortable amount of manual state-keeping. For the first few weeks that lived in my head and in about 60 browser tabs. It worked the way most undocumented systems work, which is to say it worked until it didn't, and then I couldn't tell you which version of my resume went to which company.

The fog of war is real!

This post is about fixing that. Not with a job-search SaaS product, LinkedIn Premium, or Glassdoor, but with three things I already had: an agent that runs on my own server, an open source resume builder with a real API, and the Kan board I use for everything else. The interesting part isn't that it works. It's that the work split cleanly into things software should do and things it absolutely should not, and finding that line took a few ugly iterations.

The Agent

Hermes Agent is a personal agent from Nous Research. The description undersells it, so here's the practical version: it's a process that runs on a machine I control — in my case a small Hetzner VPS in Helsinki — and it has tools. Shell access, file read and write, a browser it can drive, web fetch, scheduled jobs, persistent memory, and connections to outside services through MCP.

Hermes AI Agent by Nous Research | Official Site
The official Hermes Agent from Nous Research. A free, open-source AI agent with memory and skills. Download for Mac, Windows or Linux.

Hermes can run on my crazy cheap €3,99 Hetzner VPS (2CPU/4GB RAM)

The part that matters most is that it isn't a chat window with a search box bolted on. It's a thing that can hold a task for an hour, run commands, read the output, change its approach when the output is wrong, and then write down what it learned so the next run doesn't repeat the mistake. If you've ever used Siri on your iOS device, you know how frustrating repeated mistakes can be. This solves it.

That last bit deserves its own paragraph, because it's the difference between a demo and a tool. After every tech discovery — an endpoint that silently ignores a field, an auth flow that doesn't support the standard device grant — the agent writes a skill: a small markdown file with the rule, the reason, and the workaround. Those files load when they're relevant. Over a couple of weeks the system accumulated a runbook for my specific job search, written by the thing that kept breaking its knuckles on it. I didn't author any of it, I just approved the fixes and made sure they were implemented.

I interact with my agent through a Discord DM, which sounds completely unserious until you remember that Discord is just a chat client and my phone or Mac already has it open. I’ve even got a fun name for this agent: Count Slopula.

A discord profile for Count Scopula, my Hermes Agent.
Count Slopula's Discord Profile

Multi-model fallback

The agent can run on different models, and mine routes through a chain. My primary is a cheap, fast model that handles the 90% case: read this page, extract the salary band, rename the file, tell me what changed. Behind it sit fallbacks — a frontier model through OpenRouter, a couple of others — that pick up when the primary is rate-limited, down, or just not smart enough for the turn.

A graph showing my model usage across GPT-4.1, Qwen3.7 Flash, DeepSeek V4.1Flash, Claude Haiku5.5, DeepSeek V4 Flash0731, and Other.
Current usage by Model via OpenRouter. Not pictured: Usage with my DeepSeek API key.

This started as a cost decision and eventually turned into a reliability one. Early on, I had a free model at the front of the chain and kept hitting quota errors from a shared pool. The fix wasn't a bigger budget, it was reordering: put the model with a dedicated quota first, keep the frontier model as the safety net, and stop paying for capability I don't need on every turn. I am, after all, suddenly on a fixed income!

There's a real cost story here, and it's less dramatic than I thought. Over one twelve-day stretch the agent processed roughly 14.8 million input tokens and 372,000 output tokens. Nearly all of that input was cache reads — the same standing context, billed at a fraction of the normal rate. The whole arrangement runs on the order of a few dollars a month plus whatever the frontier fallback costs when it gets called.

The chain exists so that a $0.02 task doesn't stall because the cheap provider had a busy afternoon.

Three different systems, one wired model

When I started, I had three sources of truth and no agreement between them.

Reactive Resume was the resume. It's open source, it produces genuinely good-looking PDFs, and — critically — it has an API and an MCP server. It's now the golden record for resume text. I stopped treating the Word documents on my disk as canonical and started treating them as exports.

A Kan board at pm.bolen.cc holds the pipeline. Job Postings, Applications, Rejections, Closed. Each card carries the fit analysis, the compensation read, and the plan. This is the thing I actually look at when I want to know where I stand.

A build pipeline on disk produces an ATS-safe DOCX from a master document, because some portals want Word and some parsers are unforgiving.

Three systems, three formats, one tired human-in-the-loop translating between them. You can guess how that went. The board said one thing, the resume folder said another, and the application record — when I actually remembered to make one — said a third.

MCP to the rescue

Reactive Resume ships an MCP server at rxresu.me/mcp. MCP is the Model Context Protocol, and the short version is that it's a standard way for an agent to discover and call another application's tools without me writing a bespoke integration for each one. I added it to Hermes Agent's config, ran the OAuth flow, and the agent went from "can read files I give it" to "has 157 tools that operate on my resumes, applications, cover letters, and job matches."

The auth flow was the first thing to go sideways, naturally. The standard device-code flow wasn't supported, so we fell back to the browser flow: the agent produced an authorization URL, I pasted the callback URL back, and it completed the handshake. Twenty minutes of fiddling, then 157 tools. All from a Discord DM!

That's the moment the project changed shape. Before MCP, the agent could draft a resume if I handed it the text. After, it could read my master resume, duplicate it, patch specific bullets, run a term-by-term match against a job description, create an application record, and check the export for parser problems — all through the same interface, all without me copying anything into a prompt.

The five-step pipeline

Here's what a job posting looks like now.

  1. I paste a job application link into my Discord DM with Count Slopula. The agent fetches the posting, extracts the requisition number, location, salary band, and closing date, and writes the full text to a file so the original wording survives even if the company pulls the req.
  2. Then it checks the board for an existing card. This is not paranoia: the Kan API has no idempotency key on card creation, so a retry after a timeout silently produces a duplicate, and I have exactly one of those scars. If a card exists, it stops and says so.
  3. If not, it creates one with the analysis I actually use: what the role is, which requirements are load-bearing, a fit percentage with the gaps named, a compensation read against my current total comp, and a plan for the interview. Then it saves the job in Reactive Resume, at stage saved, with the posting text attached.
  4. Next comes the tailoring, which is the part I expected to be easy and wasn't. The agent duplicates my master resume — never edits the master itself — and works on the copy. It cleans the job description first, because raw scraped postings are full of boilerplate ("equal opportunity employer," "reasonable accommodation," the entire legal footer), and every one of those phrases registers as a missing keyword. On the first run, uncleaned, the match report showed fourteen gaps. After cutting the boilerplate, there was one real gap and some noise.
  5. Then it patches the copy: headline, summary, the skills groups, and the specific bullets that should lead with the posting's vocabulary. Not by inventing anything — by reordering emphasis and reusing the words the employer used for work I'd already done.

And then it tells me it's finished, in Discord, with the card link, the match score, and what's still missing.

The ATS roadblock nobody warns you about

An applicant tracking system (ATS) is the database and workflow layer that most mid-size and large employers run hiring through: it receives applications, parses resumes into structured fields, stores them against a requisition, and moves candidates through stages and gates while logging who did what and when. Its primary job is administrative — routing, search, and compliance record keeping — not autonomous rejection.

The part that matters to applicants is the two places a human or a rule touches your document: knockout questions (work authorization, location, credentials) that screen before anyone reads, and keyword search, where a recruiter filters a stack of 400 resumes by typing "data governance" or "product operations." A resume that parses badly, or that labels its skills section something a parser doesn't recognize, can be perfectly qualified and still never surface in that search.

So "beating the ATS" is really just making sure your document survives extraction cleanly and uses the same vocabulary the posting does for work you've actually done — which is why keyword mirroring helps and keyword stuffing doesn't. This is where Reactive Resume shines.

I ran my finished PDF resume through a parser check on the platform and got an 88/100. Not terrible, but the report was specific: twenty bullet characters were Symbol/Wingdings glyphs from my Word original, which doesn't survive text extraction, and the parser didn't recognize my "Technology and Tools" section as a skills section.

I made the recommended fixes – every bullet became a real U+2022 character in Calibri at 9.5 points. And "Technology and Tools" became "Skills," because a section header is a signal, and a parser that doesn't see the signal scores the section at zero no matter what's inside it. That's a lesson worth generalizing: the content was fine, the label was invisible.

My score went from 88 to 96/100 on the tailored version and 97/100 on the master. The two remaining flags I left alone deliberately — one is, as far as I can tell, a false positive with no evidence attached, and the other would cost me a third page to fix, which honestly felt like a worse trade-off.

Version sprawl, and the rule that fixed it

At some point I looked at my project directory and counted: 12 resume files. Six cover letters. Four with names that didn't tell me anything. I'd been solving the tailoring problem by creating a new artifact every time, which is how you end up with a folder you just can't trust.

My fix was structural, not procedural. One master document, in one folder, and it's the only thing I ever edit. Application folders are frozen snapshots — generated from the master, never edited in place. Scripts live in a build directory. Everything superseded goes to an archive so it stops competing for attention.

Reactive Resume made this cleaner than the filesystem did. One resume tagged master. Every application duplicates it. The copy carries the same design — Rhyhorn Resume/Cover Letter template, typeset in IBM Plex Serif, a Moss accent ( #3E6B4F), single column, US Letter — because the master holds those settings and duplicates inherit them.

Oh yeah, Cover Letters

Cover letters are where agents embarrass themselves fastest. Ask a model for one and you get "I am excited to apply for this exciting opportunity," three paragraphs of alignment, and a closing that thanks the reader for their consideration. Nobody writes like that, and every hiring manager knows what it means.

So the rules are explicit and non-negotiable. Four paragraphs, 320 to 380 words. Contractions. Open on a specific claim, not on enthusiasm. No claim that isn't already proven on the resume. No invented metrics, ever. Average sentence length under 23 words, because the moment it climbs, the prose starts sounding like a press release.

The letter now gets created in Reactive Resume in the same run as the resume, linked to the application and design-linked to the resume variant. Which means the "What you'll send" panel shows a matched pair instead of one document and an empty slot.

Keeping it Synced

My instinct was to build a listener: something that watches both systems and reconciles them the moment either changes. I checked whether that was possible. It isn't. Neither Kan nor Reactive Resume gives me a webhook to subscribe to, so there's no event to listen for.

What's possible is a reconciler, and it turned out to be better. It's a scheduled cron job — twice a day, 8am and 6pm — that pulls applications from Reactive Resume, pulls the board from Kan, diffs them, and fixes drift. It moves a card to the list matching its stage. It adds the Application label once something has actually been submitted. It rewrites a small sync block at the top of each card so the linked resume and cover letter are always current. It creates a card for an active application that has none.

Two design decisions in there matter more than the code.

The first is that there's no model in the loop. The job is plain Python against two APIs. It costs nothing to run, it can't hallucinate a stage change, and it either matches or it doesn't. Automation that needs an LLM to decide whether to send an email is automation you'll turn off in a month.

The second is that it's silent when nothing changed. Empty output sends nothing. You only hear from it when it did something or hit something it couldn't fix. A job that reports "all good" every morning trains you to ignore it by Thursday.

The job found real drift on its first run, by the way. A card I'd filed under Closed was sitting in the wrong column given what Reactive Resume recorded about how the application actually ended. That's the entire argument for the system: I'd stopped noticing, and the diff hadn't.

Costs and Tradeoffs

The scheduled job costs nothing — no token spend, only two API calls. The agent turns cost cents, mostly cache reads. The real expense of this project was the afternoons spent discovering that a card update silently ignores the field you'd expect to work, or that the label endpoint is a toggle and calling it twice undoes itself.

What it doesn't do is the part I want to be honest about: It can't get past LinkedIn's auth wall, so postings come in as pasted text. It can't export a PDF from Reactive Resume, because exports happen client-side in the browser — so there's still one manual download step, and I attach that file to the application record so there's a frozen copy of exactly what went out. And it can't interview for me, which remains the rate-limiting step. (I have seen those videos, though, where AI interviews AI – I'm not sure I'd ever want to work at a company that employs those kind of practices, anyway.)

What it does extremely well is remember.

Remembering which version went where, which stage each application is actually at in the process, and which gaps are real and which were scraped boilerplate. So when a recruiter calls six weeks from now and asks what I sent, the answer isn't a guess.

That's not an agent doing my job search. It's an agent doing the bookkeeping, so I can spend the time on the parts that need a person.

Share on Facebook Share on Linkedin Share on Twitter Send by email