Skills for Working With AI Agents: What to Hire For Now

The skills for working with AI agents are judgment about what to delegate, the habit of writing down how work really gets done, and disciplined review of what an agent produces. Tool fluency helps, but tools change quickly, while these three skills stay valuable as models improve. Hire for them first and teach the tools afterward.

Key takeaways

• Hire for judgment about delegation before you hire for familiarity with any one AI product.
• People who can describe a process precisely, including its exceptions, make agents more useful than people who only know how to write prompts.
• Review is its own skill: sampling, spotting errors that look plausible, and knowing when to escalate.
• As agents take on execution, roles shift toward owning outcomes, so clear writing and accountability matter more.
• You can test all of this in an interview with work samples, without asking trivia about specific tools.

Which skills matter most when agents handle the execution?

When an agent drafts the reply, reconciles the records or prepares the report, the person next to it is no longer the one typing. They are the one who decides what the agent should attempt, checks whether the result is right, and answers for the outcome. That changes what a good hire looks like.

Three groups of skills carry most of the weight:

• Judgment: deciding which tasks are safe to hand over, which need approval, and which should stay with a person.
• Process: describing the real steps, rules, exceptions and sources of truth behind a piece of work in plain language.
• Review: examining output efficiently, catching confident mistakes, and feeding corrections back into how the agent works.

Notice what is not on the list. Knowing a particular chat interface, memorizing prompt tricks or being able to build a model from scratch will not decide whether an agent helps your company. Those can be learned in weeks, or handled by a specialist partner. The three skills above are habits of mind, and they are much harder to teach later.

They are also not new. Good managers, editors, auditors and operations leads already have them. The difference is that agents make them scarce and valuable, because the volume of work passing through a single person's review goes up sharply.

Judgment: deciding what an agent should and should not do

The most expensive mistake in an agent rollout is not a technical failure. It is handing an agent a task that was never well suited to delegation, or withholding one that clearly was. Someone with good judgment sees the difference early.

A useful way to think about it is to ask four questions about any task:

• What happens if the output is wrong and nobody notices for a week?
• Can the result be checked quickly against a source or a rule?
• Does the task touch money, contracts, personal data or customer promises?
• Is the work repeated often enough, with enough similarity, to be worth setting up properly?

People with strong judgment answer these without much prompting. They also tend to ask a fifth question that others skip: who is the named human accountable for this outcome? Frameworks such as the NIST AI Risk Management Framework put heavy emphasis on defined roles and accountability for the same reason. A system without an owner drifts.

Judgment also covers permissions. A hire who understands that an agent should have only the access its role requires, and that access should be reviewed on a schedule, will prevent problems that no amount of clever configuration can fix afterward. If you want the mechanics, the piece on a quarterly permission review shows what that routine looks like.

An agent can do the task, but only a person can own the outcome.

When you assess candidates, look for people who volunteer limits. Someone who says where they would not use an agent, and why, is more trustworthy than someone who sees every task as automatable.

Process: turning tacit work into something an agent can follow

Most company knowledge is unwritten. Experienced staff know that a certain customer always needs a call, that one field in the system is unreliable, or that a particular approval is a formality except in one month of the year. A human colleague absorbs this over time. An agent only has what it has been given.

So the second skill is process articulation: the ability to take work that lives in someone's head and express it as steps, rules, exceptions and examples. It looks like documentation, but it is closer to teaching. The people who do this well tend to share a few traits:

• They notice their own shortcuts and explain them instead of skipping over them.
• They separate the rule from the exception, and write both down.
• They name the source of truth for each fact, so the agent knows where to look.
• They give examples of good and bad output, not only descriptions.

This skill matters because the quality of an agent's context is mostly the quality of the written material behind it. Anthropic's engineering notes on building effective agents and on context engineering make the same point from the technical side: simple, well-specified workflows and carefully chosen information usually beat elaborate machinery.

Process skill is also the one you can grow inside your existing team. Training should focus on this before the agent starts, and the guide on what to teach employees before the agent starts covers the content in more detail. A team that can explain its work clearly is ready for an agent. A team that cannot will find out quickly, and that discovery is useful in itself.

Review: the skill that keeps quality honest

Reviewing agent output is not the same as proofreading. Agents are fluent, so their errors rarely look like errors. A wrong figure sits inside a confident paragraph. A summary leaves out the one clause that mattered. A reviewer who skims will approve it.

Good reviewers have several habits:

• They check against the source, not against how convincing the text sounds.
• They sample deliberately, including awkward cases, instead of only reading the first few results.
• They keep a short list of failure patterns they have seen before and look for them.
• They record corrections in a form someone can act on, instead of fixing the output silently.
• They know the escalation path and use it without embarrassment.

That last habit connects review to improvement. If a reviewer fixes the same issue five times and never reports it, the agent never learns and the cost stays hidden. Reporting well is a skill too, and the guide to reporting an AI agent problem describes what a useful report contains.

Review also needs a standard to review against. Someone has to define what good output looks like and how it will be observed over time. Evaluation practice is maturing quickly, and the OpenAI evals guide and Anthropic's writing on evaluating agents both describe the idea of written test cases that are run repeatedly. You do not need every employee to build those. You do need a few people who understand why they exist, and who can contribute cases from real work. The article on success criteria for an agent pilot is a practical companion here.

An illustrative scenario: filling a finance operations role

The following is an illustrative scenario, not a description of a real company.

A mid-sized distributor is hiring into its finance operations team. An agent already prepares first drafts of supplier reconciliations. The team has two finalists.

Candidate one has extensive experience with several AI tools and talks fluently about prompts. Candidate two has less tool exposure but has spent years as a reconciliation lead, and has a reputation for clear handover notes.

The hiring manager gives both the same exercise: a short, messy description of how reconciliations are done, plus a sample of agent output containing a few quiet errors. The task is to improve the written process and review the output.

Candidate one rewrites the instructions to be more elaborate but misses two of the errors, because the text reads well. Candidate two adds three exceptions the description had skipped, finds every error by checking against the ledger, and proposes that any supplier with a payment dispute be routed to a person instead of the agent.

The hiring manager chooses candidate two, and plans to teach the tools in the first weeks. The decision rested on the work sample, not on the résumé.

How do you test for these skills in an interview?

Structured exercises reveal more than conversation. Here is a practical set you can adapt for most operational roles:

• Delegation exercise: give five real tasks and ask the candidate to sort them into hand over, hand over with approval, and keep. Ask them to explain the borderline ones.
• Process exercise: ask them to explain a task they know well to a colleague who has never done it, in writing, and include at least two exceptions.
• Review exercise: provide agent output with a few subtle errors and ask what they would check, in what order, and what they would report.
• Failure story: ask about a time a process they owned went wrong, how they found out, and what changed afterward.
• Boundary question: ask where they would refuse to use an agent in the role, and why.

Score for specificity. Strong candidates name the source they would check, the person they would tell and the condition that would make them stop. Weak answers lean on general confidence in the technology or on general suspicion of it.

A few warning signs are worth knowing. Be cautious of candidates who describe agents as replacing judgment instead of extending it, and equally of those who insist on rechecking every line, since that defeats the purpose. You want calibrated trust: more review where risk is high, less where it is low.

Finally, look at your own organization. These hires succeed only if someone senior owns the program and makes decisions quickly. The note on the executive sponsor role explains what that person needs to provide.

Where to start, and what the managed approach covers

You do not need to restructure your hiring plan at once. A sensible order is to pick one role that is already being reshaped, rewrite its job description around outcomes and review responsibilities, add the work-sample exercises above, and run the process with one or two hires. Adjust after you see what the exercises reveal.

Be Human handles the technical and operating side of this so that new hires can concentrate on judgment, process and review. In a first engagement, we define one useful role for the agent, the memory and tools it needs, the approval boundaries and an observable success criterion. Managed operations can then include monitoring, recurring evaluations, integration maintenance, permission review and controlled improvements, with the work done remotely in English and Portuguese. Your people stay in charge of decisions and outcomes, and the agent's identity, memory, channels, tools and permissions remain under human control.

If you want to find the first task worth handing to an agent, take the free Be Human AI diagnostic.

Frequently asked questions

Do we need to hire technical specialists to work with AI agents? Not for most roles. Operational staff with strong judgment, clear writing and careful review habits can work well alongside agents, provided someone handles the technical setup and maintenance. A specialist or managed partner can cover that part, so your hiring can focus on the people who own the outcomes.

Can we develop these skills in our existing employees instead of hiring? Yes, and often that is the better route. Process description and review are extensions of skills many experienced employees already have, and short practice exercises on real work help them transfer. Hire externally when a role has no one who can own the outcome or when the volume of review exceeds current capacity.

Which of the three skills should come first? Judgment about delegation, because it determines which tasks the agent receives at all. Process skill comes next, since it shapes the quality of the agent's instructions and context. Review follows closely, and in practice all three develop together once real work is flowing.

How do we know a hire is working out? Look for observable signs: tasks are delegated with written boundaries, errors are caught and reported with specifics, and the written process improves over time. If you set a success criterion for the agent's role at the start, the hire's contribution shows up in whether that criterion is being met and whether the corrections are being fed back.

Be Human editorial guidance. Examples are illustrative unless explicitly attributed. Sources provide background; implementation choices depend on your workflow.