Nori

Nori is a job agent that cannot lie about you. It finds roles, tailors your resume from facts it can prove, fills the application, and waits for your yes.

Comment

Inspiration

Auto-apply tools have a trust problem. They add skills to your resume that you never listed, apply to roles you are ineligible for, and fill forms with defaults nobody checked.

We wanted to build a job agent whose every claim is provable — one that can do real work for you without inventing a better version of you.

That became Nori.

What it does

Nori is an AI job agent that cannot lie about you.

Upload your resume once and Nori turns it into a career graph of your roles, projects, skills, achievements, and results.

From there, it can:

  • find relevant jobs across company boards and the web
  • score each role against your actual background and explain why it matches
  • identify skills or requirements you are missing
  • tailor a one-page resume for the role
  • trace every changed resume line back to the fact that supports it
  • fill the real application form
  • stop before submission and ask for your approval

If Nori cannot prove something from your career graph, it is marked "not claimed" and left out.

At the hackathon, we turned Nori into an agent you can talk to through Omnara.

Ask:

"Find remote AI roles and tell me what I'm missing."

The agent can call Nori's live tools, search company career pages along with sources such as X, Hacker News, Wellfound, Y Combinator, and public LinkedIn pages, then return ranked opportunities with evidence for every recommendation.

How we used Omnara

Omnara is the runtime behind Nori's conversational agent and gave us a clean way to connect reasoning, tools, approvals, and observability.

Managed agent

The agent is defined through a compact YAML profile containing its instructions, model, and available tools.

Omnara runs the agent loop, maintains the conversation, and streams its tool calls, giving us a visible audit trail of what the agent is doing.

MCP instead of glue code

Nori exposes seven tools through MCP:

  • find jobs
  • research a company
  • tailor a resume
  • apply
  • check application status
  • add a career fact
  • analyze skill gaps

We connected the MCP endpoint to Omnara using a bearer secret stored in its secret manager.

This lets the conversational agent operate directly on Nori's live system instead of duplicating the job-search workflow inside the agent.

On its first message, for example, the agent could query Nori and report applications currently waiting for action.

Human approval

Some actions should never happen silently.

The apply and add_fact tools are configured to always require approval.

Nori can independently search, research, compare, and explain. But before it starts an application or changes the facts it knows about you, it needs a human yes.

That approval boundary is central to the product:

the agent can act for you, but it cannot redefine you.

Models through Omnara

The conversational agent runs using a model provided through Omnara, allowing us to use the hackathon credits without managing an additional model API key.

Sandboxes — intentionally unnecessary

Omnara also provides machine pools for agents that need to execute code.

Nori did not need one.

Its tools call the Nori API, where the job discovery, evidence checking, resume generation, application logic, and other workflows live.

Keeping that execution in one place avoided creating a second copy of the pipeline.

How we built it

Nori is TypeScript throughout.

The system uses:

  • Hono for the API and worker
  • Fly.io for backend deployment
  • Next.js for the dashboard
  • Vercel for the frontend
  • Postgres on Neon for persistent data
  • Playwright for application-form automation
  • Exa for web and social job discovery
  • Resend for email
  • Telegram for mobile interaction
  • Sentry for error monitoring
  • Omnara for the conversational agent runtime and MCP tool orchestration

The product includes a career graph, evidence-backed matching, job discovery, company research, skill-gap analysis, resume tailoring, browser-based application filling, application tracking, email confirmation, Telegram linking, and human approval gates.

We also built a parser-safe one-page resume format, per-user model usage limits, social-source discovery, error reporting, and the current product interface.

More than 560 automated tests and browser journeys, running across two databases, protect the workflow before changes are merged.

Challenges

One of the most useful constraints came directly from the agent runtime.

Omnara gives a tool 30 seconds to return.

Our initial job search took about 52 seconds, so the tool timed out. Importantly, the agent reported the failure instead of inventing results.

We redesigned the search around a strict time budget.

Discovery receives roughly:

0.6 × 22 seconds = 13.2 seconds

Sources are processed as their results arrive, while job scoring runs in parallel under a deadline.

That turned an infrastructure limitation into part of the search architecture.

We also hit an Exa API change on the day of the build when one of the options we were using disappeared. Separately, a stalled test run held several local ports open and caused unrelated browser tests to fail.

Both problems were visible through the logs and were fixed without weakening the agent's correctness rules.

What we learned

The biggest lesson was that another platform's limits are not just infrastructure constraints — they become product-design inputs.

Omnara's 30-second tool timeout influenced the architecture of our job-search pipeline more than the choice of model did.

We also learned that honesty works surprisingly well as a systems-design rule.

Once every recommendation, resume line, skill, and action had to trace back to evidence, many product decisions became simpler.

Instead of asking:

"Can the model make this application stronger?"

we ask:

"Can Nori prove this?"

If the answer is no, it does not say it.

What's next

The live application workflow currently runs in dry-run mode.

Nori can navigate a real application, fill the fields, and show the completed result, but the final submission step remains disabled while we validate the workflow.

Next we want to add:

  • a hosted browser session so users can handle CAPTCHAs or unusual form steps from their phone
  • a dedicated inbox for each user to receive verification codes
  • deeper Workday support
  • more application-platform drivers
  • better cross-source job discovery
  • richer skill-gap planning
  • plans and billing

The long-term goal is simple:

A job agent that can search, reason, tailor, and act for you — while never claiming something about you that it cannot prove.

Built With

Share this project:

Updates

Submission history