PROTEUS User Guide

What you get

• Match score — how closely your resume aligns with the role
• Gap analysis — specific requirements you're missing or partially matching
• Bullet-level rewrites — JD-aware suggestions to strengthen weak experience items
• Tailored resume — accept rewrites and export an ATS-safe resume in plain text, Word, or PDF
• Cover letter — a tailored letter written from the same context as your resume

How it's different

Unlike generic resume scanners, PROTEUS processes everything through a single pipeline with shared JD context. Each agent sees the same parsed job description, so your score, gap analysis, rewrites, and cover letter all reference the same requirements — no contradictions.

1. Sign in

Visit proteus-phi.vercel.app and sign in with any of these methods:

• Magic link — enter your email, click the link we send you
• Google — one-click sign in with your Google account
• GitHub — one-click sign in with your GitHub account

2. Add your job description

On the Analyze page, you can provide a JD in three ways:

1. Paste text — copy the full job posting and paste it into the text area
2. Enter a URL — paste a link to the job posting (LinkedIn, Greenhouse, Lever, etc.)
3. Upload a file — attach a .txt, .pdf, or .docx file containing the JD

3. Add your resume

Provide your resume in one of two ways:

1. Paste text — copy your resume content into the text area
2. Upload a file — attach your resume as a .pdf, .docx, or .txt file

4. Run the pipeline

Click "Run Proteus pipeline". The analysis typically takes 30–120 seconds depending on the complexity of your inputs. You'll see real-time progress as each agent completes.

Understanding your results

After the pipeline completes, you'll see these sections in order:

Match Score

A percentage showing overall alignment. Breakdown by category (technical skills, experience, education, etc.) is shown in a chart. Scores above 75% are strong matches; 50–75% is moderate; below 50% indicates significant gaps.

Gap Analysis

Each requirement from the JD is classified as matched (you have it), partial (you have something related), or missing (not found in your resume). The similarity score shows how close your resume is to each requirement.

Rewrite Suggestions

For weak bullets, PROTEUS suggests rewrites that incorporate JD keywords and quantify impact. Each suggestion includes the original text, the rewrite, a rationale, and an impact score showing how much it improves your match. Click Accept on the rewrites you want to keep, then export a tailored resume built from your original text with those rewrites applied.

Cover Letter

A tailored cover letter written from the same parsed context as your analysis, always in a professional tone. Use the copy button to copy it, or download it as a PDF or Word document.

Viewing past runs

Go to the History page to see all your previous analyses. Click any run to view the full results again. You can search runs by JD text or source.

Downloading results

On the History detail page, use the Copy button to copy your cover letter, or Download to export it as a PDF or Word file. The filename follows the format FirstName_RoleName.pdf.

Accepted rewrites export as a tailored resume in Plain text, Word, or PDF. The file is named Firstname_Lastname_Resume and uses an ATS-safe layout: single column, uniform margins, system fonts, standard section names, and text-based output with no tables, columns, or images.

AI providers

PROTEUS uses two AI providers:

• Groq — fast LLM inference on custom LPU silicon; powers the JD parser, resume parser, and rewrite suggester with dedicated open-source models
• Google Gemini — powers the cover letter generator and the gap analyzer's semantic embeddings, and acts as a cross-provider fallback when Groq models are unavailable

JD pre-filter

Before the JD reaches the parser, a pre-filter strips job board noise — "Apply Now" buttons, tracking pixels, navigation elements, and boilerplate legal text. This improves parser accuracy and reduces token usage. If the filter removes more than 70% of text (safety check), it passes the original through.

Fallback models

If the primary model for a step is unavailable or returns invalid JSON, PROTEUS automatically retries with the same model (up to 3 times with increasing temperature), then falls back to alternative models configured in models.json.

Model health checks

A health check script runs every 3 hours via GitHub Actions. It tests each role's model with that role's own provider and test prompt — Groq models via the Groq API, Gemini models via the Gemini API, and the embedding model via a live embedding request. If a model fails, the bot swaps it only within that role's own candidate pool in models.json, so one outage can't push every step onto the same model. Pinned roles are not auto-swapped. The health check results are committed to the repository.

Checking health from the app

Go to the Models page and click "Check Health"to run a live connectivity test against each pipeline step. You'll see latency and any error details.

Groq

Groq provides ultra-fast LLM inference on custom LPU (Language Processing Unit) silicon. PROTEUS uses Groq for the JD parser, resume parser, and rewrite suggester, each pinned to its own dedicated model.

• Custom LPU hardware — purpose-built for LLM inference, not general-purpose GPUs
• Consistent latency — no cold starts or priority queuing
• OpenAI-compatible API — same request/response format, drop-in replacement
• Open-source models — runs models like GPT-OSS 120B with fast response times

Google Gemini

Google Gemini handles two pipeline steps directly: it powers the cover letter generator (Gemini 2.5 Flash) and the gap analyzer's semantic matching (gemini-embedding-001). It also serves as a cross-provider fallback when Groq models are unavailable.

• Two roles in production — Gemini 2.5 Flash writes cover letters; gemini-embedding-001 powers gap analysis
• Fast inference — Gemini Flash models provide quick response times
• Semantic embeddings — purpose-built vector scoring for requirement matching
• Cross-provider fallback — pool candidate when Groq models are down

How it works

• Each successful pipeline run counts as 1 analysis
• Failed runs (errors, timeouts) do NOT count against your limit
• Your current usage is shown below the Analyze button
• The counter resets at midnight UTC every day

What happens when you hit the limit

You'll see a clear error message telling you how many analyses you've used and when the limit resets. The Analyze button will be disabled until the next day.

Writing effective resumes for AI analysis

• Use clear, action-led bullet points (e.g. 'Led a team of 5 engineers' not 'Was responsible for team')
• Include measurable outcomes (percentages, dollar amounts, team sizes)
• Mirror keywords from the job description — AI scoring is heavily keyword-driven
• Keep formatting simple — avoid tables, columns, headers/footers, and graphics
• One page is ideal for most roles; two pages max for senior positions

Getting the best JD input

• Copy the full job posting, not just the title — more context = better analysis
• Include requirements, responsibilities, and nice-to-haves
• If the JD is behind a login, paste the text directly instead of using a URL
• For multi-role postings, specify which role you're applying for in the text

Improving your score over time

• Run analysis on the same JD after making changes to see your score improve
• Focus on 'missing' gaps first — they have the biggest impact on your score
• Use the rewrite suggestions as starting points, then personalize them
• Don't copy rewrites verbatim — hiring managers can spot AI-generated text

Analysis fails with timeout

The pipeline has a 300-second limit. If your inputs are very long, try trimming them. Resume should be under 10,000 characters; JD under 18,000 characters.

Analysis returns no results

This usually means the AI models returned invalid JSON. PROTEUS will automatically retry (up to 3 times) and fall back to alternative models. If it still fails, try simplifying your input text.

PDF upload fails to extract text

PROTEUS uses unpdf for PDF parsing. Some PDFs are image-based (scans) and contain no extractable text. If you have a scanned PDF, use an OCR tool first to convert it to text.

Score seems wrong or too low

The score measures requirement coverage, not formatting quality. A low score usually means your resume doesn't contain the keywords the JD is looking for. Check the gap analysis section for specific missing requirements.

Cover letter doesn't match the role

The cover letter is generated from the same parsed context as your analysis. If the JD parser extracted the wrong role title or requirements, the cover letter will reflect that. Ensure your JD text is complete and accurate.

Health check shows errors

Go to the Models page and click "Check Health". If a model is down, PROTEUS will automatically use fallback models. You can also check the GitHub Actions health check results in the repository.

Why did my analysis take so long?

Each LLM step makes an API call to its configured Groq or Gemini model. Gap analysis uses Gemini embeddings and falls back to local exact matching if the embedding API is unavailable. Complex resumes or JDs with many requirements take longer. Typical runs are 30–120 seconds. If it exceeds 300 seconds, it times out automatically.

Why is my score so low?

The score reflects how many JD requirements your resume covers, using semantic embeddings plus exact and word-level matching. A low score means the JD keywords and requirements aren't well represented in your resume. Use the rewrite suggestions and gap analysis to improve.

Can I use PROTEUS without signing in?

No. PROTEUS requires authentication to track your usage and save your analysis history. You can sign in with email, Google, or GitHub.

Is my data private?

Yes. Your resume and JD text are only used for the analysis. Results are stored in your account and only visible to you. We never share your data with third parties.

What file formats are supported?

JDs: paste text, URLs (LinkedIn, Greenhouse, Lever, etc.), or .txt/.pdf/.docx files. Resumes: paste text or .pdf, .docx, or .txt files. PDFs are parsed with unpdf for reliable text extraction.

Why did I get an error about another sign-in method?

If you try to sign in with a different method than the one you used before, you'll see a friendly message suggesting which provider to use. For example, if you signed up with Google, use Google again — not GitHub.

How do I delete my account or data?

You can delete individual analysis runs from the History page. For account deletion, contact support.