For job seekers
Run the whole search from one workspace.
Profile, opportunities, tailored drafts, approvals, application pipeline, interview preparation, company research, and the agent conversation stay connected.
ADK-Rust multi-agent product
Land your next role. Make your next great hire.
JobHunter gives job seekers and recruiters separate React workspaces backed by purpose-built ADK-Rust agent teams. One side researches roles, prepares applications, and tracks a search. The other defines openings, finds consenting candidates, explains matches, and manages a hiring pipeline.
Actual React productJob seeker workspace
One platform · two users
A dedicated workspace for each side of hiring.
A candidate and a recruiter should not share the same dashboard or the same agent instructions. JobHunter uses the authenticated role to select the workspace, navigation, coordinator, tools, and data the person is allowed to use.
For recruiters
Turn an open role into a visible hiring pipeline.
Open roles, candidate search, scored matches, editable outreach, pipeline stages, analytics, and the headhunter agent are built for the recruiter’s decisions.
Job seeker agent team
One conversation, specialist responsibilities.
The coordinator stays responsible for the conversation. It delegates focused work to agents with narrower instructions and toolsets, then brings the result back into the same session.
Coordinator
Routes each request and keeps the user-facing conversation together.
Sourcing
Searches configured job connectors and saves useful leads.
Ranking
Scores roles against the candidate profile and explains strengths and gaps.
Tailoring
Builds truthful, market-aware resumes, cover letters, and screening answers.
Apply
Checks board policy, prepares the browser workflow, and stops for approval.
Tracker
Keeps applications, follow-ups, and outcomes in one pipeline.
Coach
Prepares interview practice and feedback.
Intel
Researches companies, roles, and interview patterns.
Closer
Supports offer comparison and negotiation.
- 01
Build one verified profile
Skills, achievements, target roles, locations, salary preferences, resume content, and market format become shared context for the specialists.
- 02
Find and compare roles
The sourcing agent calls configured connectors. Ranking then compares saved roles with the profile and makes the fit rationale visible.
- 03
Prepare the application
The tailoring agent selects the target-market format and creates truthful materials from the candidate’s own experience.
- 04
Review the consequential step
The apply agent checks site policy and the prepared draft. Submission tools require the correct scope and an approved request.
- 05
Keep the search moving
The tracker, coach, company-intelligence, networking, and offer agents continue the work around the application itself.
Recruiter agent team
The headhunter works from the role outward.
Recruiter work starts with an opening and a clear set of constraints. The agent team searches only profiles that candidates have made recruiter-visible, records why each match was made, and prepares outreach for human review.
Headhunter coordinator
Turns a hiring request into role, sourcing, ranking, and outreach work.
Candidate search
Finds recruiter-visible profiles that meet the role constraints.
Recruiter ranking
Scores candidates and records the reasons and risks behind each match.
Outreach
Drafts a reviewable first message without sending it automatically.
- 01
Define the role
A recruiter records the title, locations, work policy, skills, experience, compensation, and hiring context.
- 02
Source consenting candidates
Search is limited to profiles marked visible to recruiters; filters narrow skills, location, experience, and remote preference.
- 03
Explain each match
The ranking agent stores a fit score, positive evidence, and risks so a recruiter can understand why a candidate surfaced.
- 04
Move people through the pipeline
Sourced, shortlisted, contacted, interviewing, offered, hired, and rejected remain explicit states in the recruiter workspace.
- 05
Draft outreach for review
The outreach agent produces an editable subject and message. The recruiter remains responsible for the relationship and the send action.
Architecture
Two coordinators share one production foundation.
Authentication selects the job-seeker or recruiter surface. ADK-Rust then loads the matching coordinator and keeps model calls, tools, sessions, memory, browser work, and streamed events inside the same runtime contract.
Job seeker pathRecruiter pathADK-Rust executionTools and state
Human control
Preparation can be automated. Accountability stays visible.
An application changes a person’s relationship with an employer. JobHunter separates preparation from execution: board policy is checked, an approval record is created, scoped tools verify that approval, and the pipeline records the final outcome.
The same principle applies to hiring. Candidate visibility is opt-in, matching evidence is stored, and outreach is drafted for a recruiter to inspect rather than silently sent.
agents/mod.rs · coordinator and specialists
let coordinator = LlmAgentBuilder::new("job_hunter_coordinator")
.model(pro)
.sub_agent(Arc::new(sourcing_agent))
.sub_agent(Arc::new(ranking_agent))
.sub_agent(Arc::new(tailoring_agent))
.sub_agent(Arc::new(apply_agent))
.sub_agent(Arc::new(tracker_agent))
.sub_agent(Arc::new(coach_agent))
.build()?;tools/approval.rs · approval enforced in Rust
if !matches!(record.status, ApprovalStatus::Approved) {
return Ok(json!({
"error": "approval_required",
"approval": record,
}));
}
state.pipeline.upsert(&user_id, &item).await?;What was verified
The case study now comes from the product.
The repository, React routes, Rust agent builders, recruiter API, persistence layer, approval tools, and local stack were inspected. The captures on this page were taken from that React application with local data.
Implemented surfaces
- ●Job-seeker and recruiter React workspaces
- ●Separate coordinator and specialist teams
- ●Job connectors, RAG, and browser toolset
- ●PostgreSQL persistence and Redis sessions
- ●A2A card, HTTP, SSE, and WebSocket UI paths
- ●Role-aware authentication and recruiter APIs
Local capture boundary
- ●Local Postgres and Redis
- ●No external application was submitted
- ●No recruiter outreach was sent
- ●Fixture or locally seeded demonstration records
- ●Screenshots show the real UI, not a marketing mockup
- ●External connectors still require operator configuration
Build role-aware agent products
Give each user the right agents, tools, state, and decisions.
JobHunter shows how ADK-Rust can support two substantial workflows in one product without flattening them into a generic chatbot.