LinkedIn's hiring team built an AI-powered hiring agent using LangChain and LangGraph to address the challenge small businesses face with time-intensive candidate review processes, where hiring managers spend an average of 9.5 hours per week on recruitment tasks. The team evolved from static workflows to a sophisticated agentic system with a centralized LLM-powered planner operating on a plan-execute-replan pattern, supporting the full hiring lifecycle from job description generation to candidate sourcing, applicant evaluation, and AI-powered screening interviews. The solution achieved a 60% reduction in time to interview for small businesses while maintaining consistency and compliance through careful architecture decisions including context-driven human-in-the-loop mechanisms, deterministic output formatting, and integration with LinkedIn's existing infrastructure and LangSmith for observability.
LinkedIn’s hiring team developed a comprehensive AI hiring agent system designed specifically for small businesses struggling with time-intensive recruitment processes. The use case centers on a critical business problem: small business hiring managers were spending an average of 9.5 hours per week simply reviewing candidates and deciding who to contact, representing significant lost productivity before any interviews even occurred. The engineering team recognized hiring as fundamentally an agentic problem rather than a one-shot task, involving iterative cycles of planning, acting, observing, and adapting as requirements evolve through the hiring process.
The solution automates the entire hiring workflow, from guided intake and job description generation through candidate sourcing, applicant evaluation, AI-powered screening interviews, and ongoing conversational assistance. The system achieved a reported 60% reduction in time to interview for small businesses, representing a substantial operational improvement. The presentation was delivered by two engineers from LinkedIn’s hiring team and provides detailed insights into their architectural evolution, implementation decisions, and production deployment considerations.
The LinkedIn team’s journey demonstrates a thoughtful progression through three distinct architectural phases. They began with static workflows using scenario branches with hard-coded transitions in an “if this, then that” pattern. This approach worked initially but lacked the flexibility needed as the system became more dynamic. They then adopted LangChain, implementing two chains with sequential execution, which provided some abstraction but still lacked the dynamic decision-making capabilities they needed.
Their breakthrough came with adopting LangGraph, which enabled a true agentic control model with a central planner driving a plan-execute-replan loop. The critical difference was using an LLM for decision-making rather than hard-coded logic, making the system significantly more robust and adaptive. This evolution reflects a common pattern in production LLM systems where initial rule-based approaches give way to more flexible, LLM-driven architectures as complexity and requirements increase.
The framework selection process was notably rigorous. LinkedIn evaluated 89 different agent frameworks before selecting LangGraph. Their selection criteria reveal important considerations for production LLMOps deployments. They rejected frameworks that didn’t provide sufficient low-level primitives, as well as those that focused on areas where LinkedIn’s existing infrastructure already had capabilities. LangGraph was selected specifically because it complemented rather than duplicated their existing infrastructure.
A crucial factor was that LinkedIn’s agents already used LangChain primitives including runnables, tools, and callbacks. LangGraph builds on these primitives rather than around them, meaning adoption required zero rewriting of existing code. Additionally, LangSmith had already been deeply integrated into their troubleshooting practices, and the broader ecosystem around LangGraph made it the natural choice. This decision highlights the importance of ecosystem fit and integration costs in production LLMOps tooling decisions.
The production system employs three key design principles. First, it uses a single agent with centralized reasoning rather than multiple specialized agents. Instead of a rigid chained process, one core LLM-powered planner handles all high-level decision-making. This “main brain” ensures coherence and enables complex multi-step problem-solving. Second, the entire workflow operates on the plan-execute-replan pattern that forms the dynamic core of LangGraph. Third, the system ensures continuous improvement through closed-loop feedback and observability, which proved essential for production reliability.
The architecture integrates deeply with LinkedIn’s existing agent platform infrastructure. The platform provides two types of memory persistence mechanisms: conversational memory, which stores chat histories and integrates deeply with LinkedIn’s messaging platform, and experiential memory, which stores state checkpoints. Additional memory applications built on top include episodic and semantic memory to enhance the memory experience.
The platform allows different teams to register their own skills based on team needs or business requirements. The hiring agent specifically leverages hiring intent skills, profile evaluation skills, and applicant skills to achieve its functionality. This modular skill registration approach enables flexible composition while maintaining consistency across the platform.
LinkedIn has integrated extensively with LangChain’s middleware and hooks capabilities. They utilize PII detection, context summarization, and persistence mechanisms. Pre-hooks and post-format hooks are particularly important for ensuring determinism, which proved critical for their agent’s reliability in production. These hooks allow the team to enforce consistent behavior while still leveraging the flexibility of LLM-based decision-making.
The LangGraph checkpoint schema they actively use includes not just input and output (with suggested prompts as part of outputs) but extensive context-related parameters. These parameters fall into two categories: global parameters that should be passed through the entire conversation or thread, such as current intent, job ID, applicant list, and applicant ID; and conditional parameters that are only activated case by case, such as pending learnings and formatted pending learnings that are generated from previous nodes and passed to subsequent nodes within the context view.
LangSmith plays a central role in the team’s day-to-day operations. They leverage the LangSmith trace skill to integrate with Claude Code, using it continuously for troubleshooting. The practical experience involves working with trace IDs and root cause outputs, which they describe as powerful, straightforward, and convenient. This integration captures the full trace of every user interaction with the agent, including not just final answers but the complete trace of context retrieval, tool calls, and every decision step.
However, the team faced constraints due to LinkedIn’s data policies, which prevent sending all production data to LangSmith. To address this, they built something similar internally that mirrors what LangSmith does, enabling them to maintain observability while respecting policy constraints. This dual approach represents a pragmatic solution common in large enterprise environments where external data sharing faces restrictions.
The evaluation process demonstrates a comprehensive approach to quality assurance in production. It begins with capturing full traces through LangSmith and their internal equivalent. This data feeds into both human annotation and LLM-as-judge evaluation. The human annotation component captures nuances that the model might miss, providing essential ground truth for quality assessment.
The current optimization step involves manually refining and retuning prompts and models based on what the annotation surfaces. However, the team is looking forward to implementing online optimization to close the continuous learning loop with less human intervention. This evolution from human-driven to continuous automated optimization represents a maturity path for production LLM systems, moving from manual iteration to more automated improvement cycles.
One of the most valuable lessons shared concerns how product constraints determine real architecture despite framework capabilities. The team provides a concrete example: their agent watches recruiter workflows and makes suggestions, such as noting when a recruiter moves a candidate without a computer science degree to “top fit” and asking whether the education requirement is truly a must-have. Users can respond yes or no, but they might also walk away or completely change the topic.
Their initial instinct was to use LangGraph’s interrupt primitive, which pauses execution mid-node, checkpoints the graph, waits for user input, and resumes from the same spot. This worked beautifully for long-lived graphs and clean yes-or-no flows, but it didn’t fit their use case where users might abandon or pivot from suggested actions.
Instead, they built a context-driven human-in-the-loop mechanism. Every input runs the graph end to end, and at the end, they persist minimum cross-turn context. In the example described, they store something like “suggest removing education requirement and waiting for user’s confirmation.” When the next message arrives, the planner determines whether it’s relevant to the suggestion, whether to confirm, reject, or pivot to something else, allowing the context to expire naturally.
This approach provides several advantages: stateless scalability, full request tracing, and flexible conversations. Most importantly, it controls checkpoint size. Rather than storing the full graph state, they persist only the minimum necessary context. This design decision reflects deep understanding of production constraints around state management, scalability, and user experience flexibility.
The team emphasizes that while models are inherently probabilistic, agents often need to be more deterministic, especially for hiring use cases. They believe that while model capability improvements will eventually replace much harness engineering work, some aspects involving customization and differentiation can never be fully replaced, and these are what make agents succeed.
They share several specific harness engineering lessons. Different agent types have different priorities: coding agents focus on code correctness and need exploration capabilities; shopping agents need source grounding and safe purchasing action boundaries; and the LinkedIn hiring agent needs consistency in recruiter-facing action paths along with trust and compliance.
Their context management approaches include checkpoint trimming, history summarization, and context conflict management to handle cases where different context providers have conflicts. This tells the agent what needs to be remembered. For output format determinism, they use template confirmation and fallbacks to structured output rather than LLM reformulation, along with programmatic response assembly. These techniques ensure the agent knows what the user sees.
For node-change determinism, they employ state flag chaining to guide transitions, one-shot tool guards to ensure certain tools are called only once or a specified number of times, and signal-only tools that can only be called from within another tool rather than by the agent itself. Rather than encoding all this logic in prompts, they use architectural patterns and parameters to ensure deterministic behavior where needed.
The integration with LinkedIn’s broader agent platform enables sophisticated skill composition. The platform’s skill registration system allows teams to contribute capabilities that can be leveraged across different agents. For the hiring agent, the team makes specific use of hiring intent skills for understanding user goals, profile evaluation skills for assessing candidate fit, and applicant skills for managing the applicant lifecycle.
This modular approach to skill management represents a mature approach to production LLM systems, where different teams can contribute specialized capabilities while maintaining consistency through shared infrastructure. The middleware layer provides consistent cross-cutting concerns like PII detection and persistence while individual skills provide domain-specific functionality.
The hiring agent covers the complete hiring lifecycle for small businesses. It begins with guided intake, collecting hiring requirements starting with the job title. The agent then generates job descriptions for review and confirmation. Once posted, it immediately sources strong-fit candidates for review, allowing recruiters to either invite them to apply or provide feedback to align the agent with their expectations from day one.
As applications arrive, the agent evaluates applicants based on defined qualifications. It can send AI-powered screening interviews, saving time for meaningful conversations with the right talent. Throughout the process, users can chat with the agent to ask hiring-related questions or request actions on their behalf. This comprehensive coverage addresses the time-intensive pain points that were consuming 9.5 hours per week for small business hiring managers.
The case study offers several valuable lessons for production LLMOps deployments. Framework selection should consider not just the framework itself but the entire ecosystem, including integration with existing infrastructure, developer tooling, and observability platforms. The zero-rewrite adoption path that LangGraph offered proved crucial for practical deployment.
Product constraints should drive architectural decisions even when framework primitives offer different approaches. The team’s decision to build context-driven human-in-the-loop rather than using interrupt primitives demonstrates how real-world usage patterns and scalability requirements can necessitate custom solutions built on framework foundations.
Determinism in probabilistic systems requires careful harness engineering that goes beyond prompt engineering alone. Architectural patterns including state management, tool guards, and output formatting mechanisms provide essential control while preserving the flexibility of LLM-based reasoning.
Observability and evaluation must be comprehensive, capturing full traces rather than just final outputs. The combination of automated evaluation through LLM-as-judge and human annotation provides balanced quality assessment, while the path toward online optimization represents the evolution from manual to automated improvement cycles.
Finally, the case demonstrates that successful production LLM systems require balancing multiple concerns: user experience flexibility, operational scalability, compliance and trust requirements, and continuous improvement mechanisms. The hiring agent’s architecture reflects thoughtful tradeoffs across all these dimensions while delivering measurable business value through the reported 60% reduction in time to interview.
Notion, a knowledge work platform serving enterprise customers, spent multiple years (2022-2026) iterating through four to five complete rebuilds of their agent infrastructure before shipping Custom Agents to production. The core problem was enabling users to automate complex workflows across their workspaces while maintaining enterprise-grade reliability, security, and cost efficiency. Their solution involved building a sophisticated agent harness with progressive tool disclosure, SQL-like database abstractions, markdown-based interfaces optimized for LLM consumption, and a comprehensive evaluation framework. The result was a production system handling over 100 tools, serving majority-agent traffic for search, and enabling workflows like automated bug triaging, email processing, and meeting notes capture that fundamentally changed how their company and customers operate.
Sierra has built a comprehensive platform for deploying customer experience agents across sales, service, and loyalty touchpoints for Fortune 20 companies. The platform addresses the challenge of building reliable, low-latency conversational AI at enterprise scale by developing a modular architecture that orchestrates 10-15 different models per conversation turn, supports voice and multimodal experiences with sub-2-second latency requirements, and implements outcome-based pricing models tied to business results like sales conversions and customer satisfaction. Sierra serves most of the Fortune 20, handling use cases from airline booking and flight disruptions to retail product discovery and payment processing, with agents operating across 60+ languages and processing conversation volumes that would represent billions of annual interactions.
Sierra has built an enterprise agent platform serving most of the Fortune 20 companies, focusing on customer experience across sales, service, and loyalty touchpoints. The platform addresses the challenge of building reliable, low-latency conversational agents that can handle complex customer interactions across voice and chat modalities in dozens of languages. Sierra's approach combines a constellation of 10-15 models per conversation turn, custom infrastructure for sensitive operations like payments (achieving PCI DSS level one certification), and a no-code journey builder that compiles to their Agent SDK. The company has achieved notable success with outcome-based pricing models where agents earn commissions on sales, demonstrating measurable business value through improved resolution rates, conversion rates, and customer satisfaction metrics across retail, airline, and other enterprise verticals.
