From RAG to Multi-Agent AI for Job Matching

A while back, I wrote a blog post about building an AI resume matcher using a RAG approach with Java and Google Vertex AI. I originally built a RAG-based AI to match resumes against job postings using a vector store. It was a fantastic project, but it got me thinking: how could this be even more intelligent and nuanced?

That question led me straight to the Google ADK Hackathon. The challenge was to build autonomous multi-agent systems, which felt like the perfect evolution of my previous project. So, I decided to tackle the same problem job matching, but with a completely new architecture. In this post, I’ll walk you through my journey building JobMatch AI and explore why a multi-agent system was a game-changer.

🚀 Let’s get started!

🤔 The Problem (Revisited)

The core problem remains the same: finding the right job is overwhelming. Manually sifting through roles is exhausting. My goal was to create an AI assistant to do the heavy lifting, but this time, I wanted to build a system that could reason about a candidate’s profile on a deeper level.

⚙️ Building the AI Hiring Committee: A Look Under the Hood

In my previous RAG project, a single “generalist” AI handled everything. For the hackathon, I moved to a “team of specialists.” Using the ADK, I created a SequentialAgent that acts as the team coordinator, ensuring each agent performs its task in a precise order. It’s like an automated assembly line for career matching.

But why is this “team of specialists” approach better? In my experience, it leads to significantly more accurate and reliable results. A single, generalist AI trying to handle everything at once can get overwhelmed. It might miss nuances in the resume, fail to properly weigh career aspirations against experience, or get sidetracked during the scoring process. By breaking the problem down, each agent can focus on doing one thing exceptionally well. This division of labor ensures every step of the process is handled with higher precision, leading to a final list of job matches that are genuinely a better fit for the user.

🏛️ Architecture Overview

Before diving into the specifics of each agent, let’s take a high-level look at the system’s architecture. The entire application is hosted on Google Cloud, leveraging a few key services to make the magic happen.

Here’s a breakdown of the flow:

The User uploads their resume and aspirations to the web application.

The request hits the JobMatch AI App, a Java application built with the Java ADK running on Google Cloud Run.

The ADK orchestrates the multi-agent workflow. For all language processing tasks, summarizing the resume, scoring jobs, and formatting the final output, the agents make calls to Vertex AI, specifically using the Gemini 2.0 model.

When the SearchAgent needs to find jobs, it uses a static tool to invoke a query against the job postings stored in a Firebase DB.

Finally, the scored and formatted job matches are returned to the user through the web app.

This setup creates a robust and scalable system where the application logic on Cloud Run coordinates the powerful AI capabilities of Vertex AI and the data storage of Firebase.

🤝 Here’s how the four-agent team works together

Step 1: The Profile & Goal Synthesizer (SummarizeAgent)

Everything starts here. This first agent is a specialist in understanding people. It takes the raw text of a user’s resume and their career aspirations and gets to work. Its most critical instruction is to prioritize aspirations over experience. If a software developer wants to move into product management, this agent focuses on that goal. It intelligently extracts transferable skills from their past to support their future. It then synthesizes all this information into a detailed user profile, creating a rich summary for later analysis and a lean set of search terms for the next agent in the chain.

Step 2: The Job Query Specialist (SearchAgent)

This agent has one job, and it’s strictly enforced: query the job database. During early tests, I ran into the classic LLM problem of “hallucination,” where the model would invent jobs. The solution was to build a highly constrained agent. The SearchAgent is only permitted to use a single tool, getAllJobPostings, which connects to my project’s Firebase database. (I chose Firebase for its flexibility, which was perfect for rapid prototyping during a hackathon). The agent is explicitly forbidden from inventing, modifying, or filtering jobs. It takes the search profile from the first agent, calls the tool, and passes the exact, unmodified results to the next agent. This completely solved the hallucination issue by separating the tasks of searching and thinking.

Step 3: The Analytical Scorer (ScoringAgent)

Now that we have a user profile and a list of potential jobs, it’s time for the heavy analysis. This agent acts as a highly analytical hiring manager. For every single job, it performs a multi-dimensional analysis, scoring the fit based on three key areas:

Aspiration Fit (The Most Important Factor): How well does this job align with the user’s stated career goals?

Skill Fit: Do the user’s skills match what the job requires?

Experience Fit: Is the seniority and type of experience a good match?

It then generates a comprehensive analysis for each job, containing the original job posting, a breakdown of the scores, an overall score from 0-100, and a brief, data-driven reasoning for its decision.

Step 4: The Encouraging Matchmaker (MatchmakerAgent)

This is the final agent in the sequence, and it’s the one responsible for communicating with the user. It takes the list of scored jobs from the ScoringAgent and first filters out anything with a score below 70, we only want to show high-quality matches. It then sorts the best jobs and crafts a personalized, encouraging report in Markdown. It doesn’t just list the facts; it builds a narrative. It rephrases the reasoning in a friendly tone and, most importantly, explicitly connects the job back to the user’s aspirations (e.g., “This is a fantastic opportunity because it directly aligns with your goal of moving into Product Management.”). This final, human-centric touch is what turns a list of data into actionable career advice.

This is just a high-level overview of how the agents collaborate. If you’re interested in diving deeper into the prompts and the specific implementation of each agent, you can find the complete source code on my GitHub repository.

🎨 From Programmer Art to Polished UI: A Visual Journey

While the agents were the core of the project, the user interface is what brings it to life. My initial UI was classic “programmer art” functional, but not exactly beautiful. It had the basic elements needed to upload a file and see the results, but it lacked any design polish.
The prototype:

This is where I turned to some incredible Google tools that felt like a superpower. Using Google Stitch, I was able to quickly create a clean, professional mockup of what I wanted the final application to look like.
The mockup:

I fed the visual mockup from Stitch directly to Gemini, and it generated the frontend code to bring that design to life. This workflow was a complete gamechanger, allowing me to go from a basic mockup to a polished, user friendly interface without spending days on frontend development and UI designing.
The final result:

🎯 The Result

The final application is simple and powerful. You visit the site, upload your resume (and optionally, your career aspirations), and within moments, the AI hiring committee gets to work, delivering a personalized report of your top matches.

Watch the submission video here:

✅ Wrapping Up

This hackathon was an incredible learning experience. Adopting a multi-agent architecture proved to be a game-changer for accuracy, showing that a team of specialist AIs can outperform a single generalist by breaking a complex problem down into manageable, high-precision tasks. To complete my submission, I even used Veo to generate the demo video, another example of how AI can be a massive force multiplier in a time crunched solo person project.

🔮 What’s Next for JobMatch AI?

This project is currently a prototype, but there’s so much potential. I’d love to integrate more job sources and build pre-filtering tools for the search agent. The ultimate dream? An agent that, with your permission, could even auto-apply to your top matches!

Let me know if you try it out! What improvements would you make?

👨‍💻 Happy coding!