Skip to content
"How many years of experience do you have with a library released last year?"
← ← Back to Thinking AI

"How many years of experience do you have with a library released last year?"

Published

Published on the TEN INVENT blog · August 2026

Or: how the recruiting industry manages to reject exactly the people it's looking for.

This week I got a message from a UK recruitment agency. An interesting role, honestly: AI Platform Engineer, fully remote, for an enterprise client. The mission — lead the design of an Agent Development Framework, define engineering standards, build multi-agent orchestration patterns. An architect's role, through and through.

The skills list was unusually specific. Not "experience with AI" or "knowledge of LLMs", but surgical:

  • LangGraph (create_react_agent, StateGraph, ToolNode)
  • Strands Agents SDK (StrandsA2AExecutor, the @tool decorator)
  • AWS Bedrock AgentCore Runtime (BedrockAgentCoreApp, invocation lifecycle)
  • MCP / A2A protocol design
  • aws-opentelemetry-distro (ADOT traces to X-Ray and CloudWatch)

I work with half of this stack daily — Strands Agents in production, Bedrock, multi-agent orchestration with a supervisor and specialized sub-agents. I sent my CV.

Then came the interesting part.

The client rejects candidates for "lack of experience"

The consultant at the agency told me, with a candor I appreciate, that the client had already rejected the previous batch of candidates. The reason? They didn't have enough years of experience with the technologies on the list. They had answered "one year", "six months", "two years" — so, in the client's logic, they were "juniors".

Let's look at the actual dates:

  • LangGraph — first release on PyPI: January 2024. Total age: two and a half years.
  • Strands Agents SDK — open-sourced by AWS in May 2025. Age: one year and three months.
  • AWS Bedrock AgentCore — announced in preview in July 2025, general availability on October 13, 2025. Age since GA: ten months.
  • A2A protocol support in AgentCore Runtime — only added at GA, in October 2025.

In other words: the client was looking for people with "many years of experience" on a stack where the oldest component is two and a half years old and the newest isn't even a year old. Nobody on the planet — not even the people who wrote these libraries — can have more than that.

The candidates who answered "one year" weren't juniors. They were early adopters. One year of LangGraph in 2026 is the equivalent of ten years of Java in 2010. And the client rejected them all.

The detail that gives the game away

There's one more thing, a small but delicious detail: the job description explicitly required experience with create_react_agent from LangGraph.

The create_react_agent function was deprecated with LangGraph 1.0, in October 2025, replaced by the new create_agent from LangChain 1.0.

So the JD demanded years of experience with an API that isn't just young — it's already obsolete. That tells us two things. One: the requirements were written by copy-pasting from the client's existing codebase, not from the ecosystem's current documentation. Two: nobody in the chain that approved the JD — manager, HR, agency — noticed.

The adverse selection machine

I don't want to blame the recruiters here. The consultant I spoke with was doing her job properly within the system she operates in. The problem is the system.

Agency recruiting runs on a simple model: the client hands over a JD, the agency turns it into a checklist, candidates are filtered on keyword matching and on the universal metric — years of experience. That model worked decently for decades, because the technologies had decades. "How many years of Java?" was an imperfect but reasonable question.

Applied to the AI ecosystem of 2026, the same question produces something perverse: adverse selection.

The honest candidates — seniors with 15–20 years of software architecture behind them, who adopted these tools from day one — answer truthfully: "one year". And they get rejected as juniors. The candidates willing to inflate answer "four years of LangGraph" — mathematically impossible — and sail through the filter. Screening on years of experience, in AI, no longer measures competence. It measures willingness to lie.

The outcome is predictable: the process stays stuck for months, until someone shows up with a sufficiently "optimistic" CV. Six months later, the client will complain that "you just can't find good AI people". Self-inflicted, from one end to the other.

What they should be asking instead

The ultimate irony: the role called for someone to define engineering standards and lead a dual-framework strategy. Which is exactly the kind of position where architectural judgment accumulated over 20 years is worth infinitely more than the months spent with any particular library. They wrote an architect's JD and filtered it like a junior role with a checklist.

What actually differentiates candidates in a field where the tools are under two years old?

Not years on the framework, but:

  1. Have they shipped multi-agent systems to production? Not a demo, not a notebook — a system with real users, real inference costs, real failure modes.
  2. Do they understand the patterns, not just the APIs? Supervisor/sub-agent, ReAct, human-in-the-loop, tool design — these transfer across frameworks. A StateGraph in LangGraph and a Strands agent are the same mental model with different syntax. Anyone who's shipped with one picks up the other in days, not months.
  3. Do they have the engineering foundation underneath? Because an enterprise "agent framework" is, beyond the AI part, a classic distributed system: auth, observability, cost control, versioning, deployment. This is where years of experience genuinely matter — but they're years of software engineering, not years of a library.

I replied to the agency with exactly this argument and withdrew from the process. Not out of pride — but because a client who filters like this when hiring will make decisions with the same logic during the project. And that's valuable information a JD gives you for free.

A realistic optimist's disclaimer

As usual on this blog: I'm not anti-AI and I'm not anti-recruiting either. I sincerely believe AI agents are the future of software infrastructure, and I spend most of my time building them. And I believe technical recruiting is a hard job, often done by people giving their best inside a system with bad incentives.

But precisely because the field is real and important, it's worth calling things what they are: old metrics applied to new technologies don't produce rigor — they produce theater. And the first industry that should update how it evaluates people is precisely the one recruiting for the roles that automate evaluation.

Until then, if someone asks you how many years of experience you have with a library released last year, the correct answer is a counter-question: "How many years do you think it's existed?"

Ion Anghel is the founder of TEN INVENT, a software consultancy in Bucharest specializing in agentic AI platforms on AWS. He builds Bob, an open-source multi-agent AI assistant.