JobClaw

Inspiration

Every CS student knows the tedium of job searching. Without good connections, we were left spending countless hours tailoring resumes to fit individual job listings. Finding a job after graduation shouldn't feel like taking another 5-unit class. Each application takes 30–60 minutes to customize, ATS filters reject 75% of resumes before a human ever sees them, and the average new grad sends 100+ applications before landing a single offer. We experienced real burnout: staying up late, tweaking bullet points, losing track of which resume we sent where, and losing sleep over something that should be solvable with software. We built JobClaw because we needed it ourselves.

What it does

JobClaw takes your profile and a job posting and produces a tailored, ATS-optimized resume in seconds. Here's the full flow:

Profile onboarding → you fill in experience, projects, skills, and job preferences via a React + Supabase frontend

Job discovery → Adzuna Live Jobs API polls for new listings every 30 minutes via APScheduler, filtered to your role, location, and salary preferences

Batch AI analysis → agent/analyzer.py scores every listing against your profile using Nemotron Super 120B, ranking your experiences by relevance to each role

ReAct agent loop → agent/loop.py runs a think/tool-call/observe cycle, calling Tavily for real-time web search when needed, streaming every reasoning step live to the frontend via NDJSON over a single HTTP connection

NemoClaw sandbox → every agent action runs inside a policy-enforced sandbox (policy.yaml) — filesystem access is scoped to /app and /tmp, network access is limited to integrate.api.nvidia.com and api.tavily.com, everything else is blocked and logged

Live UI → React reads the ReadableStream and renders each event (thoughts, tool calls, tool results, final answer) as it arrives no polling, no page refresh

Persistent tracking → all job listings, compatibility scores, and experience rankings are stored in Supabase (Postgres) and updated in real-time via Supabase Realtime subscriptions

How we built it

• Orchestration: Custom ReAct loop (agent/loop.py) — think/tool-call/observe cycles streamed live
• LLM: Nemotron Super 120B via NVIDIA Build API (nvidia/nemotron-super-120b-a12b)
• Job Feed: Adzuna Live Jobs API with APScheduler background polling + Supabase caching
• Job Analysis: Batch AI analyzer (agent/analyzer.py) — scores and ranks listings against user profile
• Auth: Supabase Auth (email/password + Google OAuth) with JWT verification via JWKS
• Backend: FastAPI streaming NDJSON events live over a single HTTP connection
• Frontend: React + Vite (agent.runner framework) — ReadableStream renders events as they arrive
• Database: Supabase (Postgres) — stores user profiles and cached job listings
• Search: Tavily API for real-time web search inside the agent loop
• Sandbox: NemoClaw (cutestagent instance) via policy.yaml

Challenges we ran into

Our experience levels varied widely, making it difficult to split up the work effectively. Moreover, this was our first hackathon, our first time building multi-agent software, and our first time using LangGraph, NemoClaw, and the NVIDIA API. Coordinating agent logic, frontend streaming, and sandbox integration were harder than anticipated — developers with less experience required significant research time before any hands-on development could begin.

Accomplishments that we're proud of

Our team delivered a fully deployable app. We built an end-to-end pipeline that ingests a posting, reasons over a profile, enforces grounding, and logs the result. The NemoClaw live demo — feed it a blocked URL and watch the audit log deny it in real time — is exactly the safety story we set out to tell.

What we learned

Through building JobClaw, we learned how to build a real agentic workflow using NVIDIA's Nemotron model. We implemented a ReAct loop where the agent iteratively reasons, decides when to call tools like web search, and streams its thinking back to the user in real time. This allows Nemotron to autonomously determine when external information is needed rather than following a fixed script. We also integrated NemoClaw's policy enforcement layer, which transparently controls which network endpoints the agent is permitted to call, teaching us the importance of separating an agent's reasoning from its permissions as a critical pattern for building safe AI agents.

What's next for JobClaw

The future of JobClaw is a fully autonomous agent that continuously scrapes job boards, scores new postings against your profile, and auto-applies once a match threshold is reached. No more late-night job searching, you sleep while JobClaw does the hunt for you.

Built With

• adzuna-live-jobs-api
• agent
• apscheduler
• brev-cloud
• fastapi
• google-oauth
• javascript
• jwks
• jwt
• ndjson
• nemoclaw
• nemotron-super-120b
• nvidia-build-api
• openshell
• python
• react
• readablestream
• supabase-auth
• supabase-postgres
• supabase-realtime
• tavily-search-api
• vite
• yaml