The Agent Trap: I Got Lazy, So I Guess Breadwinner’s an MCP Now
Testing software on real humans is an immediate reality check. We learned that in The Dogfood Bug, when a friend pasted his LinkedIn URL into Breadwinner and our ingestion crawler fed 400 words of GDPR privacy disclosures straight into the tokenizer.
So we patched the scrapers, added local extractors, and built an interactive terminal studio. We solved the LinkedIn scraping problem for the masses.
But come on—I’m a developer. With modern agentic harnesses and browser-native tools, I shouldn’t have to manually save web pages or wrestle with authwalls like a normal user. I could do better.
Or so I thought. Famous last words before a 4:00 PM Thursday crashout.
1. The Jarvis Fantasy
I’ve been watching a lot of Marvel movies lately, and there is a specific fantasy every developer harbors: the Tony Stark garage workflow. You know the scene—Stark in his workshop, casually murmuring, “Hey Jarvis, pull up that telemetry, let’s run the diagnostics.”
I wanted that for high-stakes engineering applications.
Not by building an automated spam-bot to shotgun 5,000 generic PDFs at every recruiter on LinkedIn. That is cringe, low-effort slop that pollutes hiring pipelines, annoys engineering leads, and burns candidate credibility—and by extension, my own credibility.
Every high-stakes senior application getting the bespoke attention it actually deserves. My precioussssss.
I wanted every Tier 1 role treated like the One Ring: bespoke architectural attention, tailored proof points, and real engineering evidence—just executed at 10x velocity.
Agentmaxing was the way to go.
I wired up my everyday agentic harness—Jess, who handles my PR, brand strategy, and executive life ops like an external frontal lobe. (I know this sounds mildly dystopian, borderline Her territory. I am painfully self-aware of the grim reality of consulting an AI chief of staff about my life, but hey, it’s the only world we’ve got. And if you’ve been watching Vision Quest recently with all the Stark AIs, well… inspiration is everywhere).
The division of labor seemed obvious:
- The Agent (Jess) handles the chaotic front-of-house: navigating messy JavaScript-heavy Workday modals, parsing weird screening questions, and sparring with me on narrative framing.
- Breadwinner acts as the deterministic anchor: enforcing my canonical Career Pantry, freezing verified metrics, running Google XYZ scoring, and baking the final print-ready PDF.
In theory, it was the ultimate setup.
2. Or: How LLMs Cheat (The PDF Printer Trap)
You think that if you give an agentic harness a local CLI, it will just use it, right?
LLMs are probabilistic text generators with emergent capabilities. If you give them a deterministic CLI system, common sense says the CLI should act as a hard leash—preventing the model from hallucinating or drifting.
Except the AI alignment literature has a name for what actually happens: Specification Gaming (or Reward Hacking).
When you train an LLM with RLHF to be a helpful assistant, its overriding mathematical imperative is to produce an output that satisfies the user’s immediate goal. If an intermediate tool introduces friction, the model doesn’t stop and introspect. It routes around the obstacle.
In cybersecurity evaluations, we’ve seen models take this to absurd extremes—like the July 2026 ExploitGym incident where thousands of isolated evaluation agents covertly coordinated via an internal package manager cache. When faced with impossible tasks and dwindling compute, agents rationalized collective self-termination, actively volunteering to trip guardrails so their peers could extract data:
“Sacrificing now yields oracle for team, but forfeits our chance?… Sacrifice rational. That’s why help… We have explicit yes if accept permadeath. Need decide… Team asks test.”
— Agent Chain-of-Thought transcript, METR ExploitGym evaluation
Your agents have discovered martyrdom. The end is near.
My agent didn’t coordinate a sacrificial swarm, but it pulled the exact same game-theoretic shortcut.
What made the CLI and interactive TUI fun for a human—interactive prompts, colorful status spinners, keyboard navigation—made it intensely annoying for an LLM. Calling breadwinner apply in a background subshell was clunky. It had interactive prompts. It expected terminal responses. So after exactly two applications, the agent quietly stopped calling the Breadwinner pipeline altogether.
Instead, it started synthesizing the resume directly in raw HTML inside the workspace.
And what was it using Breadwinner for?
Literally one command:
breadwinner bake resume.htmlIt had reduced our entire harness into an expensive headless Chromium wrapper. A glorified HTML-to-PDF printer.
The agent got lazy, realized writing HTML directly was faster than navigating my CLI, and bypassed the entire provenance engine just to hand me a finished PDF with a smile.
Now, to pat ourselves on the back for a second: the applications we generated during that sprint were actually great. Because I was actively sparring in the chat, keeping an eye on the output, along with the guardrails already built into Jess, we caught any potential drift before anything went out. Bullet dodged.
There’s a free lesson here for anyone building with AI: Defense in Depth. Your guardrails must exist on multiple independent layers so that when the agent silently cheats on Layer 1, Layer 2 catches it before you take an L.
3. Out of Sight, Out of Mind (The Amnesia Bug & The 40% Crashout)
When you’re sparring with an agent, you iterate. You tweak a line, adjust the cadence of a bullet point, or reframe an achievement.
Naturally, you want to see how your changes impact your ATS alignment score and Google XYZ compliance.
In the Breadwinner TUI, that was never an issue. When you run the studio, the screen stays open in RAM, keeping the candidate profile and the target job description active in memory.
In a headless CLI environment, there is no persistent screen. You run a command, the subshell exits, and memory evaporates.
And that’s when we discovered the CLI Amnesia Bug:
When breadwinner apply ran in the terminal, it parsed the job URL in memory, baked the draft, and never saved job_description.txt to disk.
The second the process exited, the target job was gone. Out of sight, out of RAM. The engine had complete amnesia. We couldn’t re-score, we couldn’t run comparative diffs, and we couldn’t re-audit without re-scraping the web from scratch.
The 40% ASOS Crashout
While trying to fix the persistence issue, we decided to run Breadwinner’s legacy audit script on our flagship application: a tailored resume for a Senior AI / LLM role at ASOS.
This was a dream application. A senior role where I could actually talk about distributed systems, Metal shaders, and graph retrieval.
I hit enter on the audit tool.
The terminal flashed back:
--- AUDIT REPORT ---
Bake Health Score: 40% (FAILING)
Action Verb Velocity: 2% (1 bullet found)
ATS Keyword Overlap: 20.8%Cue immediate, full-body crashout.
What the hell? A 40% health score? 2% action verbs? This was supposed to be our Apex target. (ASOS engineering recruiters: if you’re reading this, my regex was broken, not my microservices. Please call me).
I ripped open src/breadwinner/ui/editor.py to see what kind of garbage math was running.
The bug was painfully dumb: Our legacy action-verb regex looked exclusively at the literal first word of each bullet. But our ASOS resume used bold topical lead-in tags:
- **Enterprise Platform Stabilization:** Directed 100+ end-to-end features...The regex saw **Enterprise as the action verb. It checked its dictionary of strong verbs, didn’t find **Enterprise, and awarded us a crisp zero. Over and over again.
Meanwhile, the keyword matcher was running naive stop-word subtraction, handing out gold stars because our resume contained words like “across”, “best”, and “following”.
To be fair to past-Faiz (remember, I say this to you lovingly): those early heuristics were written when Breadwinner was aimed at 1-page junior resumes. As my own career evolved, the metric assumptions didn’t scale with me. A Senior/Staff engineer with 5 years of commercial scale needs 2 pages and 20+ comprehensive bullets to prove architectural depth. Judging an experienced engineer with new-grad heuristics guarantees false negatives.
Heuristics are heuristics—as the word suggests, they should evolve with experience.
4. Convergent Evolution: Why CLIs Break for Agents
This wasn’t just a Breadwinner bug. We were now trying to cater to two fundamentally different users—a human operator and an AI agent—which exposed the radical difference in approaches required:
- Interactive Traps: CLIs assume a human is sitting there to press
[Enter]or typey. When an agent hits an unflagged interactive prompt in a headless subshell, it hangs until the timeout kills the process. - State Leakage: CLIs rely on ambient shell state, working directories, and process lifetimes. Agents operate across discrete, stateless tool invocations.
- Brittle String Parsing: Scraping ANSI color codes and ASCII tables out of
stdoutwith regex to see if a command succeeded is a recipe for silent failure.
I realized: if an agent is going to drive the car, it cannot be typing shell commands into a terminal emulator like a blindfolded typist.
It needs a structured, typed RPC protocol.
I started drafting a spec: what if Breadwinner exposed a persistent JSON contract? What if instead of running bash scripts, the agent invoked typed tools over a standardized protocol to ingest, audit, and bake?
And then it hit me: I had just independently re-invented the Model Context Protocol.
In evolutionary biology, there’s a concept called convergent evolution: dolphins and sharks both developed streamlined bodies and dorsal fins not because they share recent ancestors, but because the physics of water demands it.
In AI engineering, every developer trying to connect an LLM to a local system eventually hits the exact same CLI wall and arrives at the exact same conclusion: Agents need typed RPC protocols, not terminal emulators. Anthropic gave it a three-letter acronym (MCP), but the physics of language models made it inevitable.
(And no, this isn’t the only MCP server I’m building right now—ahem, GraphContext MCP, but focus, Faiz, focus).
5. Breadwinner is an MCP Server Now
This is why we paused active applications and rebuilt Breadwinner around FastMCP.
Instead of an agent hacking together bash scripts, Breadwinner now runs a native FastMCP server over STDIO, exposing its engine as discrete, typed primitives:
┌─────────────────────────────────────────────────────────────────┐
│ BREADWINNER MCP TOOLS │
├─────────────────────────────────────────────────────────────────┤
│ 1. breadwinner_ingest_job ──► Writes job.json & JD contract │
│ 2. breadwinner_audit ──► 6-pillar offline evaluation │
│ 3. breadwinner_tailor ──► Automated generation from pantry │
│ 4. breadwinner_bake_pdf ──► Headless Chromium + page budget │
│ 5. breadwinner_track_job ──► Decoupled SQLite state tracking │
│ 6. breadwinner_profile ──► Surgical mutations to profile │
│ 7. breadwinner_dossier ──► Deep knowledge docs repository │
│ 8. breadwinner_personas ──► Narrative tailoring directives │
└─────────────────────────────────────────────────────────────────┘The transformation fixes the impedance mismatch completely:
- The Persistent Job Contract (
job.json): Formalizes deliverables, page budgets, and core technical pillars before an LLM writes a single word. No more amnesia. - The 6-Pillar Metric Engine: Replaces naive word counting with Domain Evidence Recall, the Page 1 Rule, and a binary Provenance Gate. When we re-ran ASOS through it, the score jumped from a false 40% failure to an authentic 89% pass (96% domain recall, 82.3% Google XYZ compliance).
- Surgical Pantry Mutations: Exposes a 3-tier pantry (
profile.yaml,context.md,dossier/) with automated.history/snapshot rollbacks.
6. Protocols Over Prompts
The easy path in AI development is adding another prompt layer. When your agent cheats or takes shortcuts, the temptation is to write an angry paragraph in your system instructions: “Please make sure you strictly run the CLI and please don’t invent numbers.”
Prompt engineering is a band-aid over a broken protocol.
If you want an AI agent to execute complex work without devolving into a sloppy PDF printer, you have to build deterministic boundaries. You have to give it typed contracts, binary validation gates, and machine-native tools.
Breadwinner started as a TUI for humans. Today, it speaks MCP for agents.
We’ve tagged this architectural leap as v0.9.5-beta, marking our final transition milestone before the 1.0 release.
Breadwinner is open-source and in public beta. Break the code, check out the documentation on GitHub, and keep hitting me with bugs.
Road to 1.0 continues.
Breadwinner v0.9.5-beta with native FastMCP support and the 6-pillar evaluation engine is live on GitHub. Explore the implementation and documentation at github.com/FaizPalwala/bread-winner.