There's a specific way auto-apply tools fail, and it's worse than not applying at all.
A form asks: Do you require visa sponsorship to work in this country? The honest answer depends on your citizenship, where the job is, and what you're authorized to do. A naive bot doesn't know any of that, so it picks a default (usually whatever keeps the form moving) and submits. Now there's an application out there, under your name, that quietly says the wrong thing about your work authorization. You'll never see it. You'll just never hear back, and you won't know why.
That failure mode is the reason we spent most of our build time on applying correctly rather than applying fast, and specifically on teaching the agent to notice when it's about to get something wrong.
We call it self-healing. It sounds fancier than it is, and it matters more than it sounds. Here's what's actually happening.
It checks its own work
The obvious way to fill a form is to read the question, generate an answer, and type it in. The problem is that a language model will happily produce a confident answer to a question it has no business answering. Ask it how many years of Python you have and it'll pick a number that sounds reasonable, whether or not it matches your resume.
So we don't trust the first draft. The agent checks every answer against your actual profile before it goes anywhere: years of experience, work history, and the specific traps forms like to set. A rating scale that wants a number. A "how many years" dropdown that stops at 10+. A text box with a hidden character minimum. If the drafted answer doesn't line up with what your profile supports, it doesn't get sent. It gets rewritten and checked again.
This runs on remembered answers too. The agent keeps track of how it answered a question last time so it isn't re-solving the same thing on every application. But a remembered answer still has to pass the same check against your current profile before it's reused. Update your work history and the old answer stops being trusted on its own. Nothing sits around going stale where you can't see it.
It asks instead of guessing
Some questions aren't worth guessing on at any confidence level. Work authorization, visa sponsorship, and citizenship are the obvious ones. These aren't preference questions where a reasonable default is fine. A wrong answer here can get an application discarded, or worse, misrepresent you to an employer.
So for this category the agent holds itself to a higher bar. If it can't ground the answer directly in your profile, it doesn't reach for the safe-looking option. It stops.
When that happens, the application doesn't fail and it doesn't go out with a shrug. It gets held and flagged for you, with the exact question it couldn't answer. You fill in the gap once, say your citizenship or your status for that region, and the agent picks up where it paused. After that it knows, and it won't ask again.
This is the part that's genuinely hard to build, because the lazy version is so tempting. A default is one line of code. Knowing when a default is unacceptable is the actual work. But that's the difference between an agent that represents you and one that just fills space with your name on it.
It fixes what breaks
Forms reject things. A phone field wants a different format. A location field expects an autocomplete match. A required box got missed. A brittle tool treats any rejection as failure and quits.
Ours treats a rejection as information. When a field comes back invalid, the agent reads why, fixes that specific field, and tries again, up to a point rather than forever. If it still can't get through after a couple of honest attempts, it stops and marks the application for you instead of hammering the same wall. There's a real difference between recovering from a hiccup and refusing to accept reality, and the retry limit is where we draw it.
And when an answer turns out to be wrong, caught later by a check or by you correcting it, that answer gets cleared. Not just for this application, but so it can't quietly poison the next one. A mistake the agent makes once shouldn't be one it keeps making. The system should get more accurate as it learns your specifics, not less.
Why this is the hard part
Anyone can build a bot that fills forms fast. Speed is cheap. We could have shipped a spray cannon in a month.
The hard part, the part worth six months, is judgment at volume. It means reading a form closely enough to know which answers you can actually trust, recognizing when a question is too important to answer without you, and recovering from the small breakages without inventing facts to cover the gap.
That's what self-healing means here. Not that the agent is never wrong, because nothing that touches a thousand different forms is never wrong. It means the agent is built to catch itself: to check before it commits, to hand a question back when the stakes are too high, and to fix what it can and stop when it can't.
An application going out under your name should be one you'd have been comfortable sending yourself. You don't see the checks, or the retries, or the questions it quietly resolved. You see clean applications you can stand behind, plus a short list of moments where the agent decided something was important enough to ask you first.
That short list isn't a gap in the automation. It's the agent knowing when it doesn't know.