How autonomous can it actually be?

A genuinely autonomous system would decide what roles to pursue, write and send applications, respond to recruiters, schedule interviews and negotiate — all without review. Every piece of that is technically buildable today.

The problem is not capability. It is that each of those decisions affects the candidate’s career and reputation in ways they cannot undo, on the basis of information the system does not have about their life.

It is worth noticing that the stages differ enormously in how reversible they are. Searching is free to get wrong, generating a document costs a review, and sending a message to a recruiter at a company you might want to work for in three years is permanent. A single autonomy setting across all of them is the design error, not the autonomy itself.

Autonomy fails at judgements requiring information outside the system. Whether a commute is tolerable, whether a company’s reputation matters to them, whether a lower salary is acceptable for a better role, whether they would work for someone they know.

It also fails on accountability. An application misrepresenting someone is their problem to explain, and "the system wrote it" is not an answer in an interview room.

The most awkward failure is the one nobody specified. Nothing in a profile says the candidate left their last company badly, or that their current employer must not find out they are looking, or that one particular founder is someone they will not work with — and a system optimising for coverage will walk directly into all three.

• Preferences that were never articulated because nobody asked
• Personal context the system has no access to
• Anything the candidate must later defend in conversation
• Actions that cannot be undone once an employer has seen them

Rather than a binary, think in levels: suggest only; act on reversible things; act within pre-approved boundaries; act freely with reporting. Different stages of a job search sit at different levels, and that is the design.

Discovery and tracking can sit high. Document generation sits in the middle. Submission and any outbound communication sit low, with explicit approval, because those are what the employer sees.

Levels should also move with evidence. A system whose judgements the candidate has agreed with forty times running has earned more latitude than one on its first day, and raising the level deliberately as trust accumulates is a better design than choosing a single setting at install time.

Approving every application individually does not scale; approving nothing is unsafe. Between them sits pre-approval: the candidate defines what the agent may do — these employers, this seniority range, up to this many per week, with these documents — and the agent acts within it.

That makes the boundaries explicit and enforceable in code, and it means the candidate’s judgement is applied once rather than repeatedly. It is the design most likely to be both used and safe.

The boundaries have to be checkable without a model, which is the constraint that shapes the whole feature. "Roles similar to the ones I liked" cannot be enforced; "salary at or above this figure, within these locations, excluding these employers, at most eight per week" can be checked by a function that returns a boolean, and that is what a guardrail has to be.

Any autonomous operation needs hard limits on volume and spend, a suppression list for employers to exclude, a complete log of what was done, an immediate stop, and idempotency so that a restart never duplicates an application.

All of these live in code. None can be a prompt instruction, because an agent’s reasoning is exactly the thing they exist to bound.

Idempotency is the one most often discovered late. A queue that retries a partially completed submission will submit twice, and the candidate finds out when the employer’s tracking system flags a duplicate — so the key should be derived from candidate plus employer plus role and checked before the browser opens, not after.

Autonomous on everything mechanical, pre-approved on everything that produces an application, and human on everything an employer reads or that determines what the candidate is aiming at.

That leaves a system doing the overwhelming majority of the work while the candidate remains the author of their own job search — which is the outcome worth building, rather than the maximum autonomy the technology allows.

It is also the version people keep using. Tools that act too freely get switched off after the first embarrassing incident, and a system trusted for six months delivers far more than one that was briefly more impressive.