LinkedIn built a hiring agent that helps small-business hiring managers write a job post, find candidates and screen applicants, according to a conference talk by Tracy He and Shang Liu, engineers on LinkedIn's hiring team, published on July 22, 2026.
TL;DR: LinkedIn treats hiring as a loop: post a job, see who applies, adjust the requirements, and search again. The hiring agent runs that loop with one central planner that plans, acts and replans. The team moved from hard-coded workflows to sequential chains and then to the planner. The speakers report that the agent cuts time to interview by 60% for small businesses (00:19), and that hiring managers spent an average of 9.5 hours a week on candidate review before (00:57). They also describe a light, stateless form of human review and a set of rules that make the agent more predictable. The talk does not explain how LinkedIn measured the 60% figure (00:19).
| Fact | Detail |
|---|---|
| Source | View source |
| Source type | YouTube talk (LangChain Interrupt 2026), 18 min |
| Source published | 2026-07-22 |
| Speakers | Tracy He and Shang Liu, engineers, LinkedIn hiring team |
| Industry | Professional network and recruiting |
| Function | HR and recruiting |
| Techniques | Plan-execute-replan loop, single planner, memory layers, human review, LLM judge, deterministic guards |
| Tools named | LangChain, LangGraph, LangSmith, an internal LinkedIn agent platform |
Independent summary of public material. LinkedIn is not affiliated with Taskade.
The system LinkedIn built
The hiring agent serves hiring managers at small businesses. Tracy He reports that these managers spent 9.5 hours a week on average to review candidates and decide whom to contact (00:57). For a small team, that time comes before any interview takes place.
The agent covers the whole hiring flow:
- A guided intake collects the hiring requirements, starting with the job title.
- The agent writes the job description. After the manager confirms and posts the job, it finds strong-fit candidates to review.
- The manager invites candidates to apply or gives feedback, and the agent adjusts to that feedback.
- When applications arrive, the agent evaluates applicants against the qualifications the manager set, and it can send an AI screening interview.
- At any time, the manager can ask the agent a hiring question or ask it to take an action.
Architecture of the system
The team rebuilt the control logic twice (03:21). The first version was a static workflow with hard-coded branches. The second used two chains that ran in sequence (03:35), which still did not make decisions on the fly. The current version is one agent with a central planner. The planner uses the model for decisions and runs a plan, execute and replan loop. Closed-loop feedback and tracing feed improvements back into the agent.
Shang Liu reports that LinkedIn picked its agent framework from 89 candidates (05:40), mainly because the framework builds on primitives that LinkedIn's agents already used, so the move needed no rewrite.
The agent runs on an internal LinkedIn agent platform with these parts:
- Conversational memory, which stores chat history and connects to LinkedIn's messaging platform.
- Experiential memory, which stores state checkpoints. Episodic and semantic memory sit on top of it.
- Skill registration, so that each team registers its own skills. The hiring agent uses skills for hiring intent, profile evaluation and applicants.
- Middleware and hooks for PII detection, context summarization and persistence, plus hooks that check the format before and after a step.
The speakers describe these lessons:
- Stateless human review. The agent watches recruiter actions and suggests changes, for example removing a degree requirement. A user can answer, ignore the question or change the subject. A pause-and-resume design did not fit that behavior. Each message now runs the whole graph, and only a small piece of context (the open suggestion) carries over to the next turn. The planner then confirms, rejects or drops the suggestion. The speakers report stateless scaling, full request tracing and small checkpoints as the gains.
- Rules that make the agent predictable. Shang Liu says: "models are probabilistic, as you know, but agents need to be more deterministic." (14:53) The team trims checkpoints and summarizes history, assembles some responses from templates in code instead of model output, and fixes the order of some actions with state flags, tools that run only once, and tools that only another tool can call.
Results the source reports
- The speakers report that the agent cuts time to interview by 60% for small businesses (00:19).
- Tracy He reports the baseline problem: an average of 9.5 hours a week of candidate review for small-business hiring managers (00:57).
- The team captures the full trace of each interaction and sends it to human annotators and an LLM judge. Today the team retunes prompts and models by hand. LinkedIn policy keeps some production data out of the outside tracing tool, so the team built a similar internal tool.
Critical assessment
The 60% figure appears in the talk title and the opening (00:19), but the talk gives no baseline period, sample size or method. The 9.5-hour figure (00:57) comes from conversations with hiring managers, not from a stated study. The talk took place at a conference run by the vendor of the framework that the team chose, and the speakers praise that vendor's tools. No outside party checked the numbers. The engineering lessons are specific and concrete, and they are the most reusable part of the source.
Build this in Taskade
- Build an AI agent with persistent memory and file analysis that screens applicants against your criteria. Start at AI agents.
- Start from a template in recruiting agents.
- Run the steps around the agent, such as intake forms and status updates, with HR automations.
- Post updates to your hiring channel with the Slack integration, one of 100+ integrations.