Compass: AI Copilot for Students, Hackathons & Careers

One AI copilot for your hackathons, code, coursework and internship hunt. Nemotron on Nebius plans your week, Tavily checks live facts, and nothing changes without your OK.

Comment

Inspiration

As students, we constantly switch between coursework, coding projects, hackathons and internship applications. Each comes with its own tools, deadlines and information, but most of these tools operate independently.

A chatbot might forget a decision made last week. A task manager won't know when a hackathon deadline changes. An internship platform might recommend jobs without checking whether we're eligible. And there's rarely anything connecting our academic workload to upcoming commitments.

We built Compass to solve this problem. It's a productivity and career assistant that keeps track of our work across Hackathons, Code, Coursework and Career, while giving us control over what it can change.

What it does

Productivity Copilot

  • Tiered model routing: Uses three Nemotron models through Nebius Token Factory. Nano handles intent detection and tool routing, Super handles multi-step reasoning and planning, and Ultra handles complex synthesis and cross-domain summaries.
  • Persistent memory: Stores code decisions, notes and ingested web pages using Qwen3-Embedding-8B embeddings (768 dimensions) in Neon PostgreSQL with pgvector and HNSW indexing.
  • Confirmation before changes: Read-only operations run immediately. Changes such as adding, editing or deleting tasks, applying triage plans, committing schedules and ingesting URLs require explicit approval. Every change is logged and can be undone.
  • Live information retrieval: When Compass cannot answer from memory, it returns [ABSTAIN] and triggers a Tavily search rather than making up an answer.
  • Tavily integration: Three tools handle web searches (search_web), URL ingestion into memory (ingest_url) and deadline verification against live sources (verify_deadline).
  • Realistic task planning: The Realist uses deterministic capacity calculations to check whether a plan is feasible. A Super planner proposes a schedule, while an adversarial Ultra reviewer challenges it. For example, if you have 31 hours of work and only four hours available, Compass identifies what to keep, defer or drop instead of pretending everything fits.
  • Specialist agents: Coursework, Research, Calendar and Memory agents handle their respective domains and can be called by the planner.

Career Copilot

  • Internship Radar: Finds relevant openings and checks eligibility against degree, academic year, graduation year, country and work authorization. Every result receives one of four statuses (ELIGIBLE, POTENTIAL_MATCH, INELIGIBLE or INSUFFICIENT_INFORMATION) along with reasons and missing requirements. Predicted hiring cycles are kept separate from confirmed openings.
  • Resume Studio: Tailors resumes by rearranging verified skills and projects to match a job description. A factual-integrity auditor checks every claim against the master profile and blocks unsupported information.
  • Company Intelligence: Generates employer research briefs using Tavily, with caching and a separate API credit budget.
  • Application Center: Tracks applications from Saved to Offer. Application answers are populated using verified profile information. Batch reviews are frozen before approval, and submissions require explicit confirmation of accuracy, work authorization and legal declarations. For portals without API support, Compass generates handoff kits for manual submission.
  • Chat integration: Career features are accessible through the same chat interface. Users can ask questions such as "Find AI/ML internships in India for third-year B.Tech students" or "Tailor my resume for this role" without switching between separate tools.

The product includes a web dashboard with a timeline, calendar, chat with shareable links and a dedicated career section. A terminal CLI is also available. Judges can explore the application without creating an account.

How we built it

  • Inference: Nebius Token Factory serves four models: nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B, nvidia/nemotron-3-super-120b-a12b, nvidia/Nemotron-3-Ultra-550b-a55b and Qwen/Qwen3-Embedding-8B. All use a single OpenAI-compatible endpoint through the standard OpenAI SDK. Model selection is configurable through environment variables.
  • Backend: FastAPI with Python 3.12, asyncpg and SSE streaming. Per-call token usage and cost telemetry are available through /api/telemetry. Deployed on Render.
  • Database: Neon PostgreSQL with pgvector and HNSW indexing.
  • Frontend: React 19 and Vite, deployed on Vercel behind an HMAC-signed edge proxy.
  • Web intelligence: Tavily's async API handles external research. Retrieved content is isolated inside <untrusted_web_content> tags and scanned for prompt injection.
  • Testing and security: 1,793 automated tests across 147 files, supported by CI and CodeQL.

Challenges we ran into

  • pgvector's HNSW dimension limit: Qwen3-Embedding-8B produces 4,096-dimensional embeddings, exceeding pgvector's 2,000-dimensional HNSW index limit. We used Matryoshka truncation to reduce embeddings to 768 dimensions, followed by L2 re-normalization.
  • Stale information: Stored deadlines can become outdated. We addressed this with [ABSTAIN]-triggered retrieval and a verify_deadline tool that checks information against live sources.
  • Resume hallucinations: Language models tend to embellish qualifications when tailoring resumes. We implemented a factual auditor that checks every generated claim against the user's verified master profile and rejects unsupported claims.
  • Preventing unintended changes: We introduced confirmation gates, audit logging and undo functionality for mutations. Applications also require explicit approval before submission.
  • Model-specific tool-calling issues: Nano occasionally returned multiple tool calls concatenated as JSON inside message content. We implemented a bracket-matching fallback parser to handle these responses.

Accomplishments we're proud of

  • Built a single assistant that handles four areas of student life and retains context between them.
  • Implemented a career assistant that checks eligibility and prevents unsupported resume claims.
  • Added human approval for important changes and application submissions.
  • Used tiered model routing to keep routine operations on smaller, faster models.
  • Deployed a working application that judges can test without signing up.
  • Reached 1,793 automated tests across 147 files.

What we learned

Working with multiple models taught us that using the largest model for every request is rarely necessary. Routing simpler operations to Nano and reserving larger models for complex reasoning helps manage latency and inference costs.

We also found that retrieval works better when the system explicitly recognizes what it doesn't know. Triggering a search when memory is insufficient is more reliable than expecting a model to avoid hallucinations on its own.

Finally, building Resume Studio highlighted the importance of validating generated information. A well-written resume isn't useful if it contains qualifications the applicant doesn't have.

What's next

  • Two-way Google and Apple Calendar synchronization.
  • GitHub webhooks to capture architecture decisions and add them to Compass memory.
  • Additional ATS integrations for application submission.
  • Background execution through Nebius Serverless Jobs. Deployment manifests are already available in deploy/.

Built With

  • asyncpg
  • docker
  • fastapi
  • github-actions
  • javascript
  • nebius-token-factory
  • nemotron-3-nano
  • nemotron-3-super
  • nemotron-3-ultra
  • neon
  • nvidia-nemotron
  • openai-sdk
  • pgvector
  • postgresql
  • python
  • qwen3-embedding
  • react
  • render
  • server-sent-events
  • tavily
  • vercel
  • vite
Share this project:

Updates

Submission history