HireIQ — The Hiring Signal Agent

The first recruiting agent that gets smarter every hire you make.

HireIQ is a hiring intelligence system that remembers every candidate interaction across your entire recruiting pipeline. It learns your company's hiring patterns over time — what profiles succeed, what red flags precede early churn, what questions reveal the best signal — so every recruiter, even one who joined yesterday, can make decisions backed by your organisation's full hiring history.

---

Screenshots

Login	Pipeline

Candidates	Intelligence

Memory-Derived Insights	Interview Workspace

AI Pre-Brief	Notes Workspace

---

The problem in plain English

When a company hires:

1. Recruiter A interviews 40 candidates over 3 months, builds intuition, then leaves
2. Every note lives in a scattered ATS nobody reads properly
3. Recruiter B starts fresh — same mistakes, same blind spots
4. A candidate rejected for a clear red flag gets through again, for the same reason

HireIQ fixes this by maintaining a persistent memory layer that every recruiter reads from and writes to — automatically.

---

How it works

Candidate Applied
      │
      ▼
  Supabase ──── structured record (name, role, stage, decision)
      │
      ▼
  Hindsight ─── semantic memory (background, interview notes, outcome, what we missed)
      │
      ▼
  recall() ──── before each interview: "here's who this candidate reminds us of, and how those hires went"
  reflect() ─── across all hires: "here are the patterns we've learned as an organisation"

Every meaningful event — application, interview notes, hiring decision, 90-day outcome — is written to both Supabase (for structured queries) and Hindsight (for semantic memory). The two reads that drive the product are recall() per-candidate and reflect() org-wide.

---

Features

• Active Pipeline (Kanban) — drag candidates through Applied → Screening → Interview → Decision
• AI Pre-Brief — before each interview, Hindsight recalls similar past candidates and their outcomes; Groq synthesises a recruiter brief with key probe areas and suggested questions
• Memory-Derived Insights — the Intelligence panel runs reflect() across your entire hiring history to surface patterns: which profiles retain, which churn, which red flags you keep ignoring
• Interview Workspace — structured notes with auto-save, logging red flags and green flags back into the memory bank
• Candidate Profiles — full history view with Hindsight recall of past interactions
• Add Candidate — adds to both Supabase and Hindsight in one step

---

Tech stack

Layer	Tech
Frontend	React, Vite, Tailwind CSS
Backend	FastAPI (Python)
Database	Supabase (PostgreSQL)
Memory	Hindsight
LLM	Groq (qwen-qwq-32b)

---

Project structure

HireIq/
├── backend/
│   ├── main.py          # FastAPI app — 6 endpoints + Hindsight/Groq/Supabase integration
│   ├── seed.py          # Seeds Supabase + Hindsight with 15 historical candidates
│   └── requirements.txt
├── frontend/
│   └── app/
│       └── src/
│           ├── pages/   # Pipeline, Candidates, Intelligence, InterviewWorkspace, ...
│           ├── components/
│           ├── services/
│           │   └── api.js   # Service layer — mock/real toggle via VITE_USE_MOCK
│           └── data/        # Mock seed data (used in dev)
├── screenshots/         # Feature screenshots
└── article.md           # Technical write-up

---

Getting started

Prerequisites

• Python 3.10+
• Node.js 18+
• Docker (for Hindsight)
• A Supabase project
• A Groq API key

1. Start Hindsight

docker run --rm -it --pull always -p 8888:8888 -p 9999:9999 \
  -e HINDSIGHT_API_LLM_API_KEY=your_openai_or_groq_key \
  -v $HOME/.hindsight-docker:/home/hindsight/.pg0 \
  ghcr.io/vectorize-io/hindsight:latest

Hindsight will be available at http://localhost:8888.

2. Backend setup

cd backend
python -m venv venv
venv\Scripts\activate        # Windows
# source venv/bin/activate   # Mac/Linux

pip install -r requirements.txt

Create a .env file in backend/:

GROQ_API_KEY=your_groq_api_key
SUPABASE_URL=https://your-project.supabase.co
SUPABASE_KEY=your_supabase_anon_key
HINDSIGHT_URL=http://localhost:8888

Supabase tables

Run this SQL in your Supabase project:

create table candidates (
  id uuid primary key default gen_random_uuid(),
  name text, role text, background text,
  years_exp int, source text, education text, notes text,
  status text default 'Applied',
  decision text, reasoning text, ninety_day_result text,
  created_at timestamptz default now()
);

create table interviews (
  id uuid primary key default gen_random_uuid(),
  candidate_id uuid references candidates(id),
  stage text, interviewer text, notes text,
  red_flags text, green_flags text, impression text,
  created_at timestamptz default now()
);

Seed the memory bank

python seed.py
# Wait ~30 seconds for Hindsight to process memories before testing recall/reflect

Start the backend

python -m uvicorn main:app --host 0.0.0.0 --port 8001

3. Frontend setup

cd frontend/app
npm install

Create a .env file in frontend/app/:

VITE_USE_MOCK=false
VITE_API_BASE_URL=http://localhost:8001
VITE_APP_NAME=HireIQ

npx vite --host 0.0.0.0
# App available at http://localhost:5173

---

API endpoints

Method	Endpoint	Description
GET	/api/candidates	List all candidates
POST	/api/candidate/add	Add candidate → Supabase + Hindsight
POST	/api/interview/log	Log interview notes → Supabase + Hindsight
GET	/api/candidate/brief/{id}	Pre-brief via recall() + Groq
GET	/api/candidate/lookup/{id}	Candidate + Hindsight history
POST	/api/outcome/log	Log decision/outcome → Hindsight
GET	/api/insights/patterns	Org-wide patterns via reflect() + Groq

---

Development mode (mock data)

Set VITE_USE_MOCK=true in frontend/app/.env to run the frontend entirely on mock data — no backend required. Useful for UI development.

---

Read more

• Technical write-up: What we learned routing hiring signal through Hindsight instead of SQL
• Hindsight documentation
• Hindsight on GitHub