NextRole Now Hosted: Try the Multi-Agent Job Search Assistant for Free

From Local Script to Hosted Service: The Evolution of Multi-Agent Job Search Assistant NextRole

If you're job hunting, or just curious about how multi-agent systems get deployed in practice, NextRole is worth a look. The author announced on Reddit that this job search assistant, built on LangGraph and DeepAgents, is now hosted and ready to try without cloning the repo.

At the core of NextRole is a supervisor agent that orchestrates three sub-agents responsible for: recruiting intelligence reconnaissance, resume customization, and interview coaching. Users simply upload their resume and provide a job description or link, and they receive a resume PDF optimized for that role, a research report on the company and position, STAR stories prepared for each interview round, and a one-page cheat sheet to use on interview day.

This "one orchestrator + multiple specialized sub-agents" architecture is the mainstream paradigm for multi-agent applications today. Rather than having a single large model handle everything, splitting into sub-agents lets each maintain its own context and toolset, going deeper on specific tasks.

How the Three Sub-Agents Divide the Work

The recruiting reconnaissance agent gathers company and job information, providing the factual foundation for resume customization. The resume customization agent then adjusts wording and keywords to match the job requirements, outputting a PDF. The interview coaching agent generates STAR stories for each interview round and compiles them into a one-page cheat sheet.

These three stages cover the information gathering, material preparation, and on-the-spot preparation phases of the job search process, with clear data handoffs between them. The supervisor's role is to decide when to call which sub-agent and how to pass the output from one stage to the next.

What's the relationship between LangGraph and DeepAgents?

LangGraph is an orchestration framework from the LangChain team for building stateful, multi-agent workflows. Its core abstraction is the "graph": nodes represent computation steps (like calling a model or tool), edges represent state transitions, and it supports loops, conditional branching, and persistent checkpoints. The supervisor pattern is a typical LangGraph use case—a dispatch node decides which sub-agent to hand off to next based on current state.

DeepAgents is a higher-level wrapper built on top of LangGraph, aimed at "deep" tasks (like multi-step research and long document processing), with built-in planning, sub-agent delegation, and file system capabilities. You can think of it this way: LangGraph provides the low-level orchestration skeleton, while DeepAgents provides out-of-the-box agent behavior patterns. NextRole uses DeepAgents to implement the sub-agents' specific capabilities and LangGraph's graph structure to manage the dispatch relationship between the supervisor and sub-agents—a combination that reduces the work of rebuilding infrastructure.

The Key Change from Hosting: Multi-User Isolation

Moving from local to hosted, the biggest engineering challenge isn't deployment itself but data isolation in multi-user scenarios. The author highlights this in the post and is seeking feedback.

Authentication and File Storage Scoped by User

The hosted version integrates Better Auth, supporting Google or email login. Each user's files and memory are stored under their own prefix in object storage. The underlying backend is still the same composite file system, just scoped by user. This means resumes, job information, and agent memory don't cross-contaminate between users.

Object Storage Prefix Isolation and Better Auth

Object storage (like S3, R2, MinIO) uses "keys" to locate files, typically in the form bucket/prefix/path. "Scoping by user prefix" means adding a uniform prefix to each user's file keys, e.g., users/{userId}/resume.pdf. This allows a single bucket to hold all users' data, while access control only needs to verify whether the requester is authorized for that prefix—cheap to implement and easy to audit. Note that prefix isolation alone isn't a security boundary; the server must still verify user identity on every read and write to prevent unauthorized access.

Better Auth is an open-source TypeScript authentication library supporting email/password, OAuth providers like Google, session management, and plugin extensions. Integrating it into the hosted service means login state and user ID can directly serve as the basis for scoping files and memory, saving the effort of building a custom auth system.

Three Layers of Memory, Each Independent

NextRole's memory design is divided into three types: semantic memory (AGENTS.md), procedural memory (SKILL.md, loaded on demand), and episodic memory (MEMORY.md). In the hosted version, these three types are now stored separately per user.

This layered memory approach is worth noting. Semantic memory carries long-term stable knowledge, procedural memory loads only when needed, and episodic memory records interaction history. Managing them separately controls context length and facilitates personalization per user. The author specifically seeks community feedback on "how to keep each user's agent memory and files isolated from one another," indicating this is still an area needing refinement.

Semantic, Procedural, and Episodic Memory

These three types borrow from cognitive science classifications. Semantic memory refers to stable knowledge unrelated to specific experiences—here, the role definitions, domain knowledge, and long-term preferences described in AGENTS.md. Procedural memory refers to "how-to" skills, corresponding to SKILL.md, loaded on demand to avoid stuffing all skill descriptions into context. Episodic memory refers to "what happened," corresponding to MEMORY.md, recording interaction history for later retrieval.

The practical value of layering lies in context budget management: large models have limited context windows, and mixing all information in one file wastes tokens and makes it hard for the model to focus. With separate management, the system can load only the layers relevant to the current task. In multi-user scenarios, each layer must be namespaced by user, otherwise different users' memories will interfere—this is the core engineering challenge the author is asking the community to weigh in on.

Self-Hosting and Local Operation Remain

Hosting doesn't abandon the local route. The author explicitly states that self-hosting is still available, including fully local operation with Ollama or LM Studio. For users concerned about data privacy who don't want resume information leaving their machine, this is a necessary fallback.

This also reflects a broader trend in AI tools: hosted services lower the barrier to entry, while local operation meets privacy and customization needs—both paths coexist. NextRole provides both the project repository and a demo video for developers to study or build upon.

The Role of Ollama and LM Studio

Ollama and LM Studio are both tools for running large models locally, letting users download and infer open-source models on their own machines without calling cloud APIs. Ollama focuses on command-line and local HTTP services, making it easy for applications to call directly; LM Studio offers a graphical interface, suitable for non-developers to manually load models and enable an OpenAI-compatible local endpoint.

For applications like NextRole that handle sensitive information such as resumes, local inference means data never leaves the machine, at the cost of typically weaker model capabilities than cloud flagship models and hardware requirements (especially VRAM). Multi-agent workflows involve many model inferences, so latency and stability of local operation will noticeably affect the experience—making the local route more suitable for privacy-conscious users willing to compromise on performance.

Who Should Try It

If you're actively job hunting, NextRole can serve as a structured preparation tool, connecting scattered information gathering and material revision processes. If you're interested in multi-agent architecture, this project demonstrates how the supervisor pattern organizes real tasks and how to handle engineering issues like multi-user isolation.

What the author most wants to know is where things first break when users run it with their own resumes. This kind of real-world feedback often says more about whether an AI product holds up than a feature list.

The project is now open for free trial, with the repository and demo video accessible—worth trying out hands-on.

One-line Summary

Multi-agent job search assistant NextRole is now hosted, focusing on multi-user data and memory isolation.

Paragraph Summary

NextRole is a job search assistant built on LangGraph and DeepAgents, using a supervisor to orchestrate three sub-agents for recruiting reconnaissance, resume customization, and interview coaching, outputting customized resume PDFs, company/job research, STAR interview stories, and a one-page cheat sheet. The article covers its evolution from local script to hosted service: integrating Better Auth for login, isolating user files by object storage prefix, and storing three layers of memory (semantic AGENTS.md, procedural SKILL.md, episodic MEMORY.md) separately per user. It also retains self-hosting and fully local operation with Ollama and LM Studio. The author is most interested in feedback from users running it with real resumes, especially the still-refining engineering challenge of memory isolation.