Back to work

AI Thinkers Dallas · Hackathon project

Job Search Command Center

I designed the interface and agent experience for a local-first system that finds fresh roles, tailors a resume truthfully, and brings every finished package to a human review desk.

Opportunity board showing ranked job roles, match scores, eligibility, sponsorship, and pay
Ranked opportunities stay inspectable before any tailoring begins.
My roleProduct Designer
Interface + agent experience
Team3 people
Hackathon collaboration
ContextAI Thinkers Dallas
Did not place
BuildFastAPI + SQLite
Canvas interface
01 / The problem

Job hunting is a pipeline problem disguised as a motivation problem.

Fresh roles appear across dozens of boards, eligibility language is easy to miss, and tailoring a resume for every role is slow. The tools meant to help often introduce a different risk: they may invent qualifications or act without the job seeker knowing.

How might we reduce the repetitive work without giving the system permission to misrepresent or act for the user?
01

Speed vs. truth

Tailoring needs to be fast, but every changed claim must remain grounded in the base resume.

02

Automation vs. consent

Agents can prepare work, but the user keeps the final decision to apply or contact someone.

03

Complexity vs. clarity

Seven agents can do useful work only if their responsibilities and handoffs stay understandable.

My contribution

I focused on the interaction model: how to make the multi-agent workflow legible, how review should work, and where deterministic rules should constrain model output. I designed the opportunity board, pixel-art office, review desk, agent responsibilities, and human control points.

Product framingInteraction designAgent experienceHuman oversightInterface system
End-to-end workflowAgents prepare three job packages, then Remy carries the completed work to review.
02 / Design decisions

Make the machinery visible, then give it firm boundaries.

The interface needed to do more than display results. It had to show where work came from, why the system made a decision, and what still required a person.

Named agents with one job each

I gave every stage a name, a face in the office, and a single responsibility. Instead of one opaque assistant, the user can see that Sam scouts, Grace checks eligibility, Ana scores, Will tailors, Rosa prepares outreach, and Remy reviews.

An office projected from the event log

The pixel-art floor is not a canned animation. Agents write structured events to SQLite, and the canvas replays those real handoffs. The visual layer stays tied to what actually happened, and a run can be replayed later.

One courier for human attention

Only Remy writes to the human inbox. A single owner for “things waiting on you” avoids seven agents competing for attention and gives the review queue one clear entry point.

Truthfulness as a UX contract

Every model-proposed resume line passes fail-closed checks: no unsupported numbers, no skill without evidence, no inflated qualifier, and no duplicate bullet. If a line fails, the system falls back to the deterministic option. A weak model response may reduce polish, but not truthfulness.

Eligibility with explicit outcomes

Each gate returns pass, review, or excluded with a readable reason. A high match score cannot override an exclusion. Older roles, experience mismatches, and explicit restrictions remain inspectable instead of disappearing.

Resume edits that respect the document

The system edits the user’s own Word document in place, preserving fonts, tabs, section order, and layout. A highlighted review copy and HTML preview make each proposed change visible.

Explainability on demand

Clicking an agent opens a focused conversation for questions such as “Why was this excluded?” or commands such as “Search now.” Match values are presented as internal estimates, never as an employer’s ATS score.

The office makes handoffs concrete.

Research, review, application work, and the human’s desk occupy separate rooms. Movement across the floor mirrors movement through the pipeline.

03 / How it works

A staged pipeline with a human checkpoint at the end.

The architecture separates collection, policy, matching, drafting, and review so one model never controls the whole process.

01 / Scout

Collect fresh roles

Sam checks 250 verified company boards and keeps provider timestamp semantics intact.

02 / Gate

Check eligibility

Grace evaluates sponsorship, country, experience, pay, and 24-hour freshness.

03 / Match

Score evidence

Ana weights required, mentioned, and preferred qualifications against the base resume.

04 / Prepare

Draft in parallel

Will tailors the resume while Rosa drafts outreach, both grounded in known evidence.

05 / Review

Return to the human

Remy joins the package, runs claim checks, and brings it to the review desk.

The interface replays the real event stream.Each handoff is traceable to a structured event rather than decorative motion.
250verified company job boards in the scout layer
7named agents with bounded responsibilities
96tests across policy, truthfulness, document editing, collectors, fallback, and API behavior
04 / Outcome

We did not place. The project still clarified the design principle I wanted to test.

Models propose. Validators decide. The human has the final say.

The hackathon result was modest, but the prototype became a concrete demonstration of how agentic systems can remain useful without hiding their work or overstepping their authority.

Nothing is submitted or sent from the product. The system prepares the package, shows the evidence and changes, and leaves the consequential action with the job seeker.