Should you grow your FDEs in-house or hire them from outside? Let’s talk straight.

First, when your factory does production scheduling, that judgment call of “can this batch of orders be squeezed in?” — who can explain it in one sentence? Second, that twelve-year-old system in your warehouse — do you still have the API docs? Third, when the line stopped for two hours last week, what was the real reason, and is the version written in the report actually correct?

He froze for a while, then said: “All that stuff… it’s in people’s heads.”

I said, exactly. The person you’re looking for has to be someone who has “that stuff in their head.” The guy you poach from outside will definitely be better at tech than your veteran foremen, but he doesn’t have those three things in his head.

It’s not that hiring externally doesn’t work. It’s that I’ve seen too many factories spend the money, bring the person in, get the solution built — and then that AI agent sits on a server for a year and nobody ever opens it.

The problem isn’t technical. It’s that “he doesn’t know what he should be asking.”

Here’s an example that stuck with me. A factory paid big money to bring in an engineer with a solid algorithms background. He built a production scheduling optimization model — elegant logic, great-looking results. Three months after launch, usage was basically zero.

Why?

Because the most critical rule in scheduling is called “hidden mold-change loss” — how long it takes each machine to change molds, how far the first few dozen parts’ pass rate drops after a change. None of this exists as a field in the system. It only lives in the planning manager’s experience. The engineer asked plenty of questions, and he asked them diligently. But he didn’t know to ask about this one.

Is that his fault? No. Anyone coming in from outside would miss the same thing. Because he didn’t know it existed.

Let me put this more bluntly.

Here’s a point that might matter even more: the barrier to entry for AI tools is dropping fast.

In the past, building any kind of automation meant writing code. Now on many platforms, you just describe the workflow in plain language, drag a few nodes, connect a few lines, and it runs. That means the scarcest FDE skill is no longer “can write code” — it’s “knowing what to let the machine do, and what not to.”

And that’s something only someone who’s been at the factory long enough can do best.

This is the part I most want to hash out with you. Pick the wrong person, and everything after is wasted effort.

From what I’ve seen, the profile of someone worth developing looks roughly like this:

Now a few counterexamples—all pitfalls I’ve seen firsthand:

So which positions should you recruit from? Production planning, process engineering, quality, equipment, IT—the core people in these areas are usually a good pool. On a side note, second-generation factory owners are actually an underrated group—they have both a business perspective and the authority to push things through, and they genuinely want to make the factory different. They’re often the first ones to break out.

No grand theories here—just a few things I’ve found genuinely work.

Their first agent must be something they build for themselves.Don’t start with a “company-wide platform” or “factory-wide rollout.” Have them start with the thing that annoys them most every day—say, spending forty minutes every morning reconciling three spreadsheets. Once that’s done, they’re their own first user and their own first believer. No amount of persuasion from others works; saving those forty minutes yourself is what works.

Skip the training classes—learn by doing.A “study for two weeks, then start using it” format is basically wasted effort. A more reliable rhythm: pick one small scenario per week, do a retrospective every two weeks, and after each one spell out what worked well, what didn’t, and what to change next time. What you learn has to be used immediately, or you’ll forget it.

Practice “saying it clearly.”Most people get stuck not because they can’t click a mouse, but because they can’t articulate their requirements. Have them practice one exercise: turn a verbal request into four sentences—what result do I want, what materials do I have, what are the decision rules, and what happens when something goes wrong. Once those four sentences are clear, the agent can basically run correctly. And this skill benefits far more than just AI work.

Someone must have their back.The most common way this dies: a person starts enthusiastically, gets stuck at step two, asks around and gets no help, gets stuck again the second time—and there’s no third time. So either assign an external coach or designate an internal mentor, and make sure that when they’re stuck, someone can lend a hand within two hours.

What they build must go into the cabinet.Agents, knowledge bases, prompts, templates—all of it needs to be archived, reusable, and editable by the next person. Skip this, and ten builds are ten isolated islands—the moment the person leaves, it all falls apart. On this point, choosing the right tool makes a huge difference.

Give them time, and give them recognition.Set aside a fixed half-day each week—don’t make people do this on their own time after hours, or they won’t last a month. Those who produce results should present them at meetings and let the whole factory know. Many factories can’t get this off the ground not for lack of talent, but because nobody wants to be the person who “does extra work and gets no credit.”

The starting point behind AgentSteamer is really just one sentence: let a company’s own people build and nurture agents themselves.

It’s built around the Harness Engineering methodology of engineered governance, covering the full lifecycle of an agent—from creation, visual orchestration, testing, and publishing to operational governance. It’s not a tool we hand you and walk away from; it’s about enabling standardized production and continuous operation.

In terms of concrete capabilities, several are directly relevant to “developing your own FDEs”:

On deployment, it’s fully private—the knowledge base and artifacts stay within the enterprise’s own domain, and data never leaves the premises. This looks like a technical detail, but it’s actually crucial: only when data never leaves the factory will veteran workers dare to put the real stuff in.

In terms of scenarios, the ones we run most often are intelligent office work (documents, PPT), intelligent operations (process automation), intelligent customer service (knowledge Q&A), intelligent review (rule-based judgment plus AI review), intelligent research (multi-source retrieval and analysis), and intelligent O&M (monitoring plus automated handling). We’ve also left flexibility in billing—License subscription or a one-time package, choose at your own pace.

As for our role, I’d rather call it a sparring partner than a stand-in. We hand you the platform and the methodology, you pick the people from your own team, and together we get the first batch of scenarios running. Once they’re running, you can push forward on your own.

Having said so much about the benefits of developing people in-house, I should be fair: hiring externally isn’t wrong in itself—the mistake is treating it as your main force.

If you must hire externally, the advice is few and excellent—one or two, positioned as seeds, as coaches. Their job isn’t to do all the work, but to bring out five of your own people. After a year, their value becomes “yours.”

Conversely, if you expect external hires to carry the load—then when the day comes that they leave, you’ll find the agent is still on the server, but no one knows why it was designed that way. That’s more trouble than not having it at all.

FDE isn’t really a new position—it’s more like a capability: thinking the business through clearly, then telling the machine what to do.

This capability can’t be parachuted in; it can only grow. It grows in the noise of the workshop, in the arguments of the planning department, in all those sayings of “this is how we’ve always done it.”

Those three are the real foundation of your factory’s future.