Navo · AI That Handles Onboarding
Navo understands what's next, coordinates the work and steps in when needed.
Navo is an AI onboarding agent. Instead of handing a new joiner another checklist, it owns the onboarding journey. It tracks what's done and what's blocked across HR, IT, Facilities, a background-check vendor and the manager. It acts within clear guardrails, explains every action, and only asks the joiner for what genuinely needs them.
Halden is a fictional company. Every person, document, policy and system in this prototype is synthetic or simulated.
The narrated demo, recorded from the running app: the problem, Navo at work, HR's view, Ask Navo in English and Hindi, policy upload, the cohort radar and the architecture. Select the image to watch it on YouTube, or download the MP4 (28 MB); captions are in navo-demo.srt.
Thursday, 09:17. Navo's daily check found the Employee ID two days late with zero slack for the laptop. It reminded HR on its own and told Anand he needs to do nothing. Every tool call it made is on the right.
What Navo does
- Tracks the whole chain. 27 onboarding tasks, their owners, deadlines and dependencies, on a working-day calendar (IST, with holidays and lead times).
- Spots Day-1 risk early. It knows a laptop needs the Employee ID plus 2 working days, so a late ID on Thursday means Monday is at risk. It acts before anyone notices.
- Acts within guardrails.
- Auto: reminders, IT and HR requests, bookings and a single Day-1 pickup.
- After 24 hours of silence: escalation.
- Asks the joiner first: anything sensitive, like a loaner laptop, personal data or benefits.
- Never: decisions that belong to HR.
- Explains itself. Every action has a reason and the policy it relied on (Noticed → Decided → Acted → Planned), for the joiner and for HR.
- Reads documents. It extracts fields with Claude vision, verifies them with deterministic rules, and asks about one unclear date instead of rejecting the whole document.
- Answers questions. Ask Navo uses Claude with read-only tools over the joiner's live state and Halden's policy library. It cites only sections it actually retrieved; otherwise it says it doesn't know.
- Gives HR a queue of exceptions. HR gets exceptions, not a spreadsheet of checklists, plus a live feed of what Navo already did.
- Sees the whole cohort. A risk radar runs the real Day-1 risk engine for all 14 joiners and shows which team breaks which Day 1. What-ifs ("IT takes a week longer") show where Day 1 would break before it does.
- Learns new policies. HR pastes or uploads a policy. Navo splits it into citable sections, versions it, and cites it in answers straight away.
- Speaks Hindi. Ask Navo answers a question asked in Hindi in Hindi, with the same facts and citations.
- Keeps personal data away from the model. Aadhaar, PAN, phone, bank and email numbers are masked before chat and status-update text reaches Claude, and restored in the reply.
See it
| Document reading | Asks before an asset change | Ask Navo, grounded |
|---|
| | |
| HR owner console | Impact, computed from the run |
|---|
| |
Watch the 3-minute guided demo
Open the app and press ▶ Play guided demo. It drives the real engine end to end, from first launch to Day 30, with a caption at each step. To start partway through, click a chapter on the intro screen.
- Keys: → next, ← back, Space play or pause, H HR view, B home, Esc close. ← Back to Home, pinned to the top of every screen, goes back to the intro.
- To explore on your own, use the chapters, the HR responds / HR silent switch, Advance time ▸ and Inject IT delay.
| Route | What it is |
|---|
/ | Demo stage: presenter panel, the joiner's phone, Navo's runtime panel |
/phone | The joiner's app on its own |
/hr | The HR owner console on its own |
Architecture in one picture
flowchart LR
UI["Joiner app · HR console · Demo stage"] --> API["Next.js route handlers"]
API --> Agent["Navo agent<br/>orchestrator · playbooks"]
Agent --> Tools["Tool registry<br/>validate · permission · timeout · audit"]
Tools --> Domain["Deterministic rules<br/>state machine · dependencies · working days · risk · permissions"]
Tools --> Mocks["Simulated HR · IT · Calendar · Learning · Vendor · Facilities"]
Mocks -- "scheduled events" --> DB[("Postgres")]
Agent <--> DB
API -. "Ask Navo · document reading · update wording" .-> GW["AI gateway<br/>routing · fallbacks · guard · budget"]
GW -.-> Claude[["Claude: Haiku · Sonnet · Opus"]]
- Deterministic core, LLM at the edges. Code owns state transitions, dependencies, dates, risk thresholds and permissions. Claude understands and writes language, reads documents and plans read-only lookups, and code verifies everything it returns.
- Every action goes through the tool registry: 22 tools, each validated with Zod, permission-checked, timed out and written to an audit row.
- Event-driven world on a simulated clock. HR, IT and the others respond later, through scheduled events. Advance time runs real events through the real engine.
- Isolated workspace per visitor, so judges exploring at the same time never collide.
- One AI gateway. It routes each task to the right-sized model and falls back on overload or refusals. It also caches prompts, masks personal numbers, enforces the budget and logs usage and cost. See the enterprise architecture for what is built and what is planned.
The full design, with sequence diagrams, the state machine, the data model and deployment, is in docs/TECHNICAL_DESIGN.md.
Tech stack
| Layer | Choice |
|---|
| App | Next.js 16 (App Router), React 19, TypeScript (strict), CSS Modules |
| AI | Claude via @anthropic-ai/sdk: Haiku 5.5 for status updates, Sonnet 5.5 for Ask Navo, Opus 5.5 for documents; tool use, vision, structured output, prompt caching |
| Data | Postgres via Drizzle ORM: Neon in production, embedded PGlite locally and in tests |
| Validation | Zod at every boundary |
| Tests | Vitest (unit, integration, property-based with fast-check, components with Testing Library), Playwright with axe-core, an AI quality benchmark, a load test |
| CI and hosting | GitHub Actions, Vercel |
Quick start
Requires Node.js 22+. There is no database to set up: locally Navo uses an embedded Postgres (PGlite) stored in .data/.
git clone https://github.com/KumarAnandSingh/NAVO-Agent-that-handles-Onboarding.git navo
cd navo
npm ci
cp .env.example .env.local # optional
npm run dev # http://localhost:3000
Without an API key, Navo runs in offline mode: every Claude feature falls back to deterministic behaviour, so the demo and the full test suite work without a key. The runtime panel shows which mode is active.
Try it with live Claude
Navo never needs the deployment's own key.
- In the runtime panel, choose Try it with your own Claude key and paste an Anthropic API key.
- Test connection checks it for free, using the Models API, and lists the models it can use.
- Use this key. From then on, Ask Navo, document reading and status updates run on Claude. The panel shows each task's model, latency and estimated cost.
The key stays in your browser tab and is gone when you close it. It is sent only with your own requests to Navo's server, which uses it for that request and never stores or logs it. A full demo run costs a few US cents; see the cost model.
| Variable | Purpose |
|---|
ANTHROPIC_API_KEY | Optional: the deployment's own key, for everyone (daily caps protect it) |
NAVO_MODEL, NAVO_MODEL_ASK, NAVO_MODEL_NARRATE, NAVO_MODEL_DOCUMENTS | Optional: pin a model for every task or for one task |
NAVO_BYOK | off stops visitors connecting their own key |
DATABASE_URL | Postgres (e.g. Neon). Empty → embedded PGlite |
NAVO_DAILY_LLM_CALL_LIMIT / NAVO_WORKSPACE_DAILY_LLM_CALL_LIMIT | Daily Claude call caps (deployment key / per visitor) |
See .env.example for every option.
Testing
npm run lint # ESLint
npm run typecheck # tsc --noEmit (strict)
npm test # unit, integration, property and component tests (Vitest)
npm run test:coverage # with coverage floors enforced
npm run eval # AI quality benchmark, offline (add -- --live with a key)
npm run build
npm run test:e2e # Playwright against the production build, plus axe accessibility scans
npm run load-test -- --base http://localhost:3000 --visitors 50
Results:
- 264 unit, integration and component tests pass.
- 13 end-to-end tests pass on embedded PGlite and on real Postgres.
- Coverage, with the UI included: 90.8% of lines and 79.8% of branches. Server code alone: 85.1% of branches.
What the suites cover:
- Integration: both stories (HR responds, HR silent) through the real engine. A journey sweep checks every screen at every step for broken copy.
- Reliability: invalid input, timeouts, denials, conflicts, duplicate and failing events.
- Claude edges, against a scripted fake: unverified citations, refusals, fallbacks between models, prompt injection, the budget, and a visitor key that must never be stored or logged.
- Property-based (fast-check): working days, dependency graphs, what-ifs and the personal-data guard.
- Component: every phone screen rendered from real engine state.
- AI benchmark: 17 Ask questions (3 in Hindi), 3 documents and 6 status updates, graded by code. 16 of 17 Ask cases pass offline; the miss is a deliberate paraphrase. See AI quality.
- Load test: 50 simultaneous visitors on Postgres, 350 requests, 0 errors. See load test.
CI runs lint, typecheck, coverage floors, the AI benchmark, a dependency audit, the end-to-end suite on PGlite and on Postgres, and the load test.
Deploy
- Import the repository into Vercel. Next.js is detected; no build settings are needed.
- Add Neon Postgres from Vercel Storage, which sets
DATABASE_URL. Migrations apply automatically.
- No API key is needed: the demo runs offline, and visitors can bring their own key. Add
ANTHROPIC_API_KEY only to run live for everyone.
Details are in Deployment.
Project structure
src/
domain/ Pure business rules: time, state machine, dependencies, risk, permissions, SLA
agent/ The onboarding agent: event routing, handlers, reconcile loop, playbooks, actions, tools
services/ AI gateway, Ask Navo, document reading, policy retrieval and upload, cohort radar,
events, view models, workspaces
eval/ The AI quality benchmark
mock-systems/ Simulated HR, IT, calendar, learning, vendor, facilities
content/ Synthetic Halden data: people, task template, policies, documents, timeline
lib/db/ Drizzle schema and database client
ui/ Phone screens, demo stage, HR console, AI panel, NavoFace
app/ Routes and API handlers
tests/ unit/ · integration/ · components/ · e2e/
docs/ Technical design, enterprise architecture, security, cost, API, ADRs, specs
video/ The product video: storyboard, composer and voice-over script
scripts/ Migrations, benchmark, load test, cost model, screenshots and the video pipeline
Documentation
| Document | What's in it |
|---|
| Technical design | Overview and track, architecture and flow diagrams, setup and deployment, code walkthrough, assumptions |
| Enterprise architecture | Layer by layer: what this prototype builds and what production would add |
| Security and privacy | Data handled, built controls, DPDP Act 2023 mapping, threats |
| Cost model | Measured Claude cost per onboarding, routing and caching savings, scale |
| API reference | Every endpoint, body, response and error |
| AI quality benchmark | Golden cases, code graders, offline and live results |
| Load test | 50 concurrent visitors on Postgres: results and fixes |
| Decision records | Eight architecture decisions and their trade-offs |
| Product video | The voiceless pitch-and-demo video rendered from the real app (), with its |
Navo is a prototype built for an innovation challenge. Halden, its people, documents, policies and systems are fictional; no real employee data is used. Figures shown in the app come from the simulated run, not production measurement.
