Openings — Agent Native Job Discovery

• 

  Openings — Agent-Native Job Discovery

Inspiration

Job hunting is a two-surface problem. Aggregators like Naukri and Indeed are great at telling you which companies are hiring — but they surface only a fraction of each company's roles and bury the link to the company's own careers page, where the complete, current list actually lives. Bridging those two surfaces — take a company name, find its official portal, extract every matching role, repeat, twenty times over — is exactly the repetitive, multi-step web work a human dreads and an agent is good at.

We wanted to see what happens when an AI agent and a human work the same job board, live, on the same page — not a chatbot bolted on the side, but an agent driving the app's real functions. That's the promise of WebMCP, and job discovery turned out to be a perfect fit.

What it does

Openings is an agent-native job-discovery workspace. You start from a Naukri search or just name a few companies, and Openings:

• Resolves each company's official career portal — skipping aggregators, going straight to the source (e.g. stripe.com/jobs, ramp.com/careers).
• Extracts the real, current openings from that portal via a server-side crawl and structured extraction.
• Scores every role 0–100 against your resume, with honest strengths, gaps, and tailored bullet rewrites that reframe your real experience — never fabricated.
• Keeps everything on one shared board with a live activity feed.

The key idea: nothing is "agent-only" or "human-only." Every WebMCP tool is a thin wrapper over the same store action a UI button calls, so the human and the agent drive identical code and see one shared state. Paste companies and click Import, or ask the agent to do it — the outcome is the same. The agent handles the breadth (opening twenty portals in seconds); the human keeps the judgment (shortlisting, accepting resume edits).

How we built it

• Frontend: Vite + React + TypeScript + Tailwind CSS — a split-screen workspace (pipeline board on the left, resume canvas + activity feed on the right).
• State: a framework-agnostic observable store (src/store.ts) shared by both the UI and the agent, persisted to the browser's localStorage.
• WebMCP: five tools registered on document.modelContext.registerTool(...) — import_from_naukri, discover_company_jobs, add_job_to_board, match_with_resume, list_board_jobs. Each is a thin wrapper over a store action, and registration no-ops gracefully when WebMCP is absent, so the app still works as an ordinary web app.
• Serverless: Netlify Functions handle portal resolution, career-page crawling, structured extraction, and resume scoring — so no API key ever touches the browser, and the SPA and functions share one origin (which WebMCP requires).
• AI: a pluggable provider facade — Mistral (mistral-small-latest, default) or Google Gemini (gemini-3.6-flash) — behind one generateJson contract, swappable with a single env var.

Challenges we ran into

• JS-only career SPAs that can't be crawled. We added a knowledge-based fallback that returns the model's best-known roles, clearly flagged unverified in the activity feed so the user is never misled.
• Structured-output reliability. Gemini's JSON mode could stall, so we built a circuit breaker: structured output is throttled independently, and if it trips, the helper falls back to plain-text JSON and skips the slow path on later calls.
• Bounded latency. SDK retries are capped and every attempt is timed out, so a request never hangs for minutes during a live demo.
• One-origin constraint. WebMCP requires the SPA and its functions on the same origin — we run everything through netlify dev locally so the tools connect exactly as they do in production.

Accomplishments that we're proud of

• A genuinely shared human–agent surface: one code path, one board, no "demo-only" wiring.
• Going past aggregators to the official source for every role, with a direct link on every card.
• Honest resume scoring with truthful bullet rewrites — sharpening real experience, never inventing it.
• A backend that stays resilient even on free API tiers, so the demo doesn't fall over.

What we learned

WebMCP changes how you architect an app: the moment your UI actions and your agent tools are the same functions, "agentic" stops being a bolt-on and becomes the natural shape of the code. The hard part isn't exposing tools — it's designing a store clean enough that a button and an agent can safely share it.

What's next for Openings — Agent Native Job Discovery

• More ATS adapters (Greenhouse, Lever, Ashby) for deeper, verified extraction.
• Application tracking and status stages on the board.
• Multi-resume profiles and per-role tailoring.
• Swappable persistence (Netlify Blobs) so a board can sync across devices.

Built With

• ai
• context
• css
• functions
• gemini
• google
• mistral
• model
• netlify
• protocol
• react
• serverless
• tailwind
• typescript
• vite
• webmcp