Co-Agent-Recruitment: Teamwork Makes the Dream Work with A2A

Inspiration

We created this piece for the purposes of entering this hackathon! #adkhackathon ==> https://a2a-githubaction--gen-lang-client-0249131775.us-central1.hosted.app/

Hiring teams today are caught in a paradox: they are drowning in data but starving for actionable insights. The modern recruitment workflow is a grueling, manual process characterized by three core challenges:

• The Drudgery of Manual Extraction: Recruiters spend up to 30% of their time manually sifting through unstructured resumes and job descriptions, a tedious task prone to human error and bias.
• The Lack of Real-Time Alignment: The inability to get a quick, data-driven comparison between a new role and the entire candidate pool means opportunities are missed and time-to-hire metrics suffer.
• The Bottleneck of Scale: As a company grows, the sheer volume of applications can overwhelm even the most efficient hiring teams, leading to a breakdown in process and a poor candidate experience.

Our inspiration was to ask: “What if we could build not just a tool, but an autonomous team of AI specialists to solve this?” We envisioned a system where cooperative agents handle the heavy lifting, allowing human recruiters to focus on what they do best — building relationships and making final, strategic decisions. Co-Agent-Recruitment Hire was born from this vision to accelerate and fundamentally reshape the recruitment process.

What it does

Co-Agent-Recruitment Hire automates the end-to-end recruitment workflow by orchestrating a team of specialized AI agents to parse resumes, analyze job postings, and deliver data-driven match recommendations — all while safeguarding candidate privacy.

Our project directly addresses the hackathon’s “Automation of Complex Processes” category. It functions as an intelligent, agent-driven platform:

1. Intelligent Parsing: A recruiter submits a raw job description or a candidate’s resume. A dedicated Parser Agent (either the Job Parser or Resume Parser) is immediately invoked. Using Gemini, it intelligently reads, understands, and transforms the unstructured text into a structured, queryable JSON object.
2. Privacy-First Anonymization: Crucially, during the parsing stage, all Personally Identifiable Information (PII) is segregated. The data used for matching is anonymized, ensuring the process is unbiased and secure by design.
3. Orchestrated Matchmaking: When a recruiter requests matches for a job, our central Orchestrator Agent takes command. It retrieves the structured data and delegates the complex task of comparison to a specialized Matcher Agent.
4. Data-Driven Insights: The Matcher Agent performs a deep semantic analysis of skill alignment, experience relevance, and qualifications, generating a compatibility score and a concise, human-readable justification for why each candidate is a strong fit.
5. Seamless User Experience: The results are presented in a clean, ranked interface, allowing recruiters to instantly see their top candidates and make informed decisions in seconds, not days.

How we built it

We built Co-Agent-Recruitment Hire on a modern, scalable, and event-driven stack, with Google’s Agent Development Kit at its core.

• Foundation — Agent Development Kit (ADK): The entire multi-agent system is designed and built using Google’s ADK in Python. We leveraged ADK for its powerful session management, modular sub-agent support, and streamlined callback mechanisms, which were essential for orchestrating complex, multi-step interactions between our agents.
• The Agent Team: We designed four distinct agents:
• Orchestrator Agent: The central controller that routes tasks and manages the overall workflow.
• Resume Parser Agent: A specialist trained to extract and structure data from resumes.
• Job Posting Agent: A specialist for analyzing and structuring job descriptions.
• Matcher Agent: The “analyst” of the team, responsible for generating compatibility scores.

Architecture

• Intelligence Layer — Google Vertex AI (Gemini): Each agent is powered by Gemini models, accessed via ADK tools. We crafted specific, fine-tuned prompts for each agent’s task — from reliable JSON extraction to nuanced compatibility analysis.
• Communication Backbone — Google Cloud Pub/Sub: To ensure our agents could work together effectively and at scale, we implemented an asynchronous, event-driven architecture using Pub/Sub. The Orchestrator emits events like ParseResumeEvent or CompatibilityScoreEvent, which decouples our services and makes the system resilient and horizontally scalable.
• Data Persistence — Google Firestore: All structured data from jobs, candidates, and matches is saved to Firestore, triggered by events from Pub/Sub via a Google Cloud Function. This provides a serverless, highly scalable database solution.
• Full-Stack Implementation: We built a REST API using FastAPI to interact with the OrchestratorAgentRunner and a polished user interface using Next.js and TypeScript, demonstrating a complete, end-to-end functional product.

Technology Stack

Frontend

• Next.js 15 — React framework with App Router
• TypeScript — Type-safe JavaScript
• Tailwind CSS — Utility-first CSS framework
• shadcn/ui — Modern UI component library
• React Hook Form — Form handling with validation
• Zod — Schema validation

Backend & AI

• Google Genkit — AI application framework
• Google Vertex AI — Gemini models for AI processing
• Python FastAPI — Backend API for agent orchestration
• Google ADK — Agent Development Kit

Authentication & Database

• NextAuth.js — Authentication framework
• Firebase Auth — User authentication
• Firestore — NoSQL database
• Firebase Admin SDK — Server-side Firebase operations

Cloud Infrastructure

• Google Cloud Run — Serverless container platform
• Google Cloud Pub/Sub — Event messaging
• Google Cloud Functions — Serverless functions
• Docker — Containerization

Development Tools

• Jest — Testing framework
• ESLint — Code linting
• Prettier — Code formatting
• TypeScript — Static type checking

Challenges we ran into

1. Complex State Management in Asynchronous Orchestration: Managing the flow and state between multiple asynchronous agents was our biggest challenge. When the Orchestrator delegates a task, how does it track completion or handle errors? We solved this by implementing a robust session management system using the ADK’s InMemorySessionService and by correlating all Pub/Sub events with a unique session_id, allowing us to trace a single request across multiple distributed services.
2. Ensuring Reliable Structured Output from LLMs: Gemini is incredibly powerful, but getting it to return perfectly-formatted JSON every single time required significant effort. We overcame this with iterative prompt engineering and, more importantly, by building a “self-healing” parsing tool that uses Pydantic for strict validation. If the initial JSON output from the LLM was malformed, our tool would re-prompt the model with the error, asking it to correct its own output, dramatically increasing reliability.
3. Debugging an Event-Driven System: Unlike a simple monolithic application, debugging a bug in an event-driven system can be like finding a needle in a haystack. We set up a local development environment using Docker Compose to run a Pub/Sub emulator, which allowed us to inspect messages and trigger events locally. We also implemented structured logging across all agents and services, which was invaluable for tracing requests from the UI all the way to Firestore.

Accomplishments that we’re proud of

1. Achieving True Multi-Agent Orchestration: We are incredibly proud that we didn’t just build a wrapper around an LLM API. We successfully designed and implemented a genuine multi-agent system where specialized agents collaborate to complete a complex task. This directly fulfills the core spirit and requirement of the hackathon.
2. Building a Privacy-First Architecture by Design: We didn’t add privacy as an afterthought. Our system was architected from the ground up to anonymize candidate data during the matching process. This is a critical feature for any real-world recruitment tool and a major accomplishment in product thinking.
3. Delivering an End-to-End, Polished Solution: We built a fully functional, installable, and aesthetically pleasing application. From the Next.js frontend to the FastAPI backend and the scalable Google Cloud architecture, we delivered a complete prototype, not just a proof-of-concept script.
4. Creating a Genuinely Useful & Scalable Tool: The event-driven architecture using Pub/Sub means this isn’t just a hackathon project; it’s a blueprint for a real-world, scalable SaaS product that could handle thousands of concurrent users.

What we learned

1. The Power of Specialization in Agent Design: Our key takeaway is that a team of specialist agents is far more powerful and maintainable than a single, monolithic “do-everything” agent. By giving each agent one job to do well, we created a system that is easier to debug, update, and scale.
2. ADK is a True Accelerator: We learned firsthand how the Agent Development Kit abstracts away so much of the boilerplate code involved in building agentic systems. Features like session management and tool integration allowed us to focus on the high-level logic of our agents’ interactions rather than the low-level plumbing.
3. Asynchronous is the Future for Agentic Systems: We learned that for agents to work together effectively, especially for long-running tasks like complex analysis, asynchronous communication is not just a choice — it’s a necessity. It builds resilience, enables scalability, and allows for a more responsive user experience.

What’s next for Co-Agent Recruitment: Teamwork Makes the Dream Work with A2A

The current platform is a powerful foundation. We envision expanding our agent team to automate even more of the recruitment lifecycle:

1. The Interview Scheduling Agent: Once a match score exceeds a certain threshold, this new agent would be automatically triggered. It would be responsible for communicating with the candidate to find availability and integrating with Google Calendar to schedule interviews automatically.
2. The Candidate Engagement Agent: This agent would proactively communicate with candidates, providing status updates on their application, answering common questions, and ensuring a positive experience throughout the process.
3. A Self-Improving Matcher Agent: We plan to create a feedback loop where recruiters can mark which matches were hired. The Matcher Agent would then use this data to fine-tune its own compatibility models, getting smarter and more accurate with every successful placement.
4. Company-Side Analytics Agent: An agent that analyzes all job postings and successful matches for a company, providing insights on how to write better job descriptions or what skills are most in-demand, adding another layer of strategic value.
5. Company-Side Analytics Agent: An agent that analyzes all job postings and successful matches for a company, providing insights on how to write better job descriptions or what skills are most in-demand, adding another layer of strategic value.