CareerOps — Autonomous AI Job Search & Application Agent

An autonomous AI agent that turns a single job search goal into live discoveries, weighted match scoring, tailored application packages, and follow-up tasks on Google Cloud.

Comment

💡 Inspiration

Like millions of job seekers, I found myself spending countless exhausting hours every single day searching for jobs across fragmented job boards. The process felt like an unpaid full-time job: manually filtering through dozens of job listings, deciphering buzzword-heavy requirements, repeatedly tailoring my resume and writing custom cover letters for every role, and trying to keep track of everything in messy spreadsheets.

After spending so much valuable time on this repetitive, draining cycle, I realized that modern AI should be able to eliminate this friction entirely.

However, existing AI tools were almost all built as conversational chatbots. But when you're searching for a job, you don't want to sit and chat back and forth prompting a bot all day. You need an autonomous background agent — an AI system that you can give a single high-level goal to, and it independently discovers live roles, scores them against your profile, generates tailored application packages, and schedules your follow-ups while you focus on interview prep.

That personal frustration inspired me to build CareerOps for the All Things Agentic Hackathon (Taskmaster Track).

⚡ What It Does

Given a single prompt like "Find Senior SDET roles matching my profile in San Francisco or Remote", CareerOps autonomously executes a 12-step multi-agent lifecycle:

  1. Profile & Memory Ingestion: Loads the candidate's verified skills, experience history, and target compensation from Cloud Firestore.
  2. Live Job Discovery: Fetches real-time job openings across LinkedIn, Greenhouse, and Lever via the Google Custom Search API.
  3. Deduplication Engine: Uses cryptographic SHA-256 content hashing to deduplicate identical listings across multiple job boards.
  4. Gemma 3 Pre-Filter Gate: Runs a fast, cost-effective YES/NO relevance classifier using Gemma 3 27B on Vertex AI to filter out unrelated roles before expensive deep scoring.
  5. Parallel Evaluation: Analyzes up to 15 jobs concurrently in parallel using Python's asyncio.gather and concurrency semaphores.
  6. Transparent 6-Dimension Scoring: Evaluates candidate fit against a transparent weighted mathematical rubric:

$$\text{Match Score} = 0.35 \cdot S + 0.25 \cdot E + 0.15 \cdot R + 0.10 \cdot L + 0.10 \cdot D + 0.05 \cdot O$$

Where $S$ is Skills fit, $E$ is Experience level, $R$ is Role alignment, $L$ is Location/Remote preference, $D$ is Education, and $O$ represents other preferences.

  1. Autonomous Decisioning: Categorizes roles into HIGH_PRIORITY ($\ge 80$), REVIEW ($60 - 79$), or SKIP ($< 60$).
  2. End-to-End Material Generation: For every HIGH_PRIORITY match, Gemini 3.6 Flash autonomously generates:
    • 📝 Tailored resume bullet points matching the JD's specific technology stack
    • 💬 Personalized LinkedIn / InMail recruiter outreach message
    • 📨 Full custom cover letter
    • 🎯 5 Technical interview preparation questions with answer guides
  3. State Machine Pipeline: Automatically advances applications through validated state transitions (discovered $\rightarrow$ analyzing $\rightarrow$ shortlisted $\rightarrow$ materials_ready $\rightarrow$ awaiting_approval).
  4. Follow-Up Task Scheduling: Auto-generates prioritized action items with due-date countdowns (e.g. "Follow up with hiring manager in 3 days").
  5. Executive Run Report: Synthesizes a structured summary report of findings and market insights.
  6. Real-Time Streaming UX: Pushes continuous event telemetry via native WebSockets to a dark-themed React dashboard.

🏗️ How We Built It

CareerOps is built using the official Google AI and Google Cloud ecosystem:

  • Google ADK (Agent Development Kit): Orchestrates the multi-agent hierarchy with an OrchestratorAgent directing specialized sub-agents (SearchAgent, AnalysisAgent, WriterAgent, TrackerAgent).
  • Gemini 3.6 Flash & 2.5 Flash: Accessed via both Google GenAI SDK and Vertex AI for multi-dimensional matching and content drafting.
  • Gemma 3 27B (Vertex AI): Acts as a fast pre-filter gate, demonstrating a multi-model architecture that reduces latency and API costs by ~40%.
  • Google Cloud Run: Hosts the containerized FastAPI backend serverlessly with auto-scaling from 0 to 3 instances.
  • Google Cloud Firestore: Persists runs, applications, materials, profiles, and scheduled tasks.
  • Google Secret Manager: Secures API keys and credentials in production without plaintext secrets in code.
  • Google Cloud Build: Automated CI/CD pipeline that runs the automated test suite before building and deploying containers.
  • React + Vite Frontend: Responsive dark-themed UI with real-time WebSocket connection indicators, live activity stream, Kanban pipeline, and slide-in materials drawer.

🧗 Challenges We Ran Into

  1. Free-Tier Gemini API Concurrency: Gemini's free tier has strict requests-per-minute limits. We engineered an asynchronous worker using asyncio.Semaphore(2) and an exponential backoff jitter algorithm to guarantee that jobs process in parallel without quota errors.
  2. State & Connection Resilience Across Navigation: When users switch between Dashboard, Applications, and Tasks tabs, React components unmount. We built a global RunContext with localStorage persistence and event replay buffers so the background WebSocket stream never drops and pages auto-refresh seamlessly.
  3. Deterministic Unit Testing with LLMs: Live AI calls in CI/CD pipelines can be slow and unpredictable. We built a dual-mode service architecture that allows all 73 unit and integration tests to run deterministically in under 6 seconds with 100% pass rates.

🏆 Accomplishments That We're Proud Of

  • True Autonomous Execution: No conversational back-and-forth — a single goal triggers a complete 12-step workflow that delivers actionable applications and scheduled tasks.
  • Multi-Model Synergy: Successfully combining Gemma 3 (lightweight classification) with Gemini (deep multi-dimensional reasoning).
  • 100% Test Coverage & Production Polish: 73 automated tests, a 1-command deployment script to Google Cloud Run, and clean visual architecture documentation.

📚 What We Learned

  • How to structure production-grade multi-agent workflows using Google ADK.
  • The power of combining lightweight open models (Gemma) as triage filters before heavyweight frontier models (Gemini).
  • Techniques for zero-latency UI updates using in-memory asyncio.Queue EventBuses feeding WebSocket endpoints.

🔮 What's Next for CareerOps

  • Browser Automation Sidecar: Direct 1-click form autofill submission to Greenhouse, Lever, and Workday portals.
  • Interactive Mock Interview Voice Agent: Practicing generated interview questions with real-time voice feedback using the Gemini Live Multimodal API.
  • Compensation & Equity Benchmarking: Automated market rate comparison using live salary data APIs.

Built With

  • agentic-ai
  • asyncio
  • autonomous-agents
  • css3
  • docker
  • fastapi
  • gemini
  • gemma
  • google-adk
  • google-cloud-build
  • google-cloud-firestore
  • google-cloud-run
  • google-custom-search-api
  • google-genai-sdk
  • google-secret-manager
  • html5
  • javascript
  • pydantic
  • pytest
  • python
  • react
  • rest-api
  • vertex-ai
  • vite
  • websockets
Share this project:

Updates

Submission history