The client wants an AI employee. You can deliver an agent
What the executive pictures matches the definition of AGI, still hypothetical; the FDE's job is to turn that hope into a design without killing it.
In brief
- The 'AI employee that does everything' a client describes is really AGI. By the common definition, AGI is still hypothetical, not a product you can buy.
- What an agent can do depends on the tools the engineering team connects and how those tools are described. The model only proposes a call; the application executes it.
- Start with the simplest solution, usually a fixed workflow, and add autonomy only later, because autonomy brings higher costs and compounding errors.
In 1965 Herbert Simon predicted that within twenty years machines would be capable of doing any work a human can do. More than sixty years later the promise survives, only rephrased. Today it is called an “AI employee”.
If you work as an FDE, you will meet this scene sooner or later. A client executive has watched a few demos, read a few headlines, and asks: when do we get an AI employee that handles everything on its own? It is not a foolish question.
But it folds two very different things into one, and if you do not separate them in the first meeting, the project will be judged against a standard no system today can meet.
What the client is picturing is AGI. What you can deliver is an agent. The gap between the two is not closed by waiting for a smarter model. It is closed by a design, and the FDE draws that design together with the client.
“Does everything” already has a name, and it is still hypothetical
Wikipedia defines AGI as a hypothetical form of artificial intelligence that matches or surpasses humans at almost every cognitive task. The key word is “hypothetical”. An AI employee that handles everything on its own fits this definition almost word for word, which means it is not yet something you can buy or deploy.
What runs in companies today is narrow AI, or weak AI: it solves a specific problem but has no general cognitive ability. That is precisely the gap between the system you will deploy and the picture in the executive’s head.
Nor should you get drawn into debating when AGI will arrive. Simon’s prediction was wrong. Geoffrey Hinton once said AGI was “30 to 50 years or even longer away”, then sharply revised that figure himself. When the leading experts disagree this much, arguing about timelines only derails the meeting.
The line to use is: that does not exist yet, and here is what we can build this quarter.
What you can deliver is an agent, and agents are assembled from parts
DAIR.AI’s Prompt Engineering Guide defines an agent as an LLM-based system designed to act autonomously and solve complex tasks. The reason agents exist is practical: an LLM on its own falls short when a task needs multiple steps, planning and reasoning.
So it is given extra capabilities: planning and self-review, access to tools, and memory.
An “AI employee”, then, is not a general mind. It is an assembly put together by engineers, and each part of that assembly has its own limits.
Anthropic’s tool use documentation shows how concrete those limits are. Claude executes nothing by itself. It returns a structured call, which your application then executes (a client tool) or Anthropic executes (a server tool).
The model also calls a tool only when the request matches the capability described in the tool and the answer is not already available in context.
This sentence anchors the whole conversation. It moves the question from “is the AI smart enough?” to “which systems do we connect it to, and with what permissions?”, and the second question is one a client executive can actually decide.
From what the client says to what the FDE should ask back
The table below pairs common expectations with how the system actually works. The last column is a counter-question that turns the expectation into scope.
| Client says | What the system actually does | What the FDE should ask back |
|---|---|---|
| “It’ll know what to do” | Calls a tool only when the request matches a described capability | “What are the first three specific things you want it to do?” |
| “It’ll go into our systems by itself” | The model only proposes a call; our application executes it | “Which systems, read or write access, and who is accountable?” |
| “If information is missing, it’ll handle it” | When a required parameter is missing, the model may infer a plausible-sounding value | “Which fields must always be asked of the user?” |
| “Just let it decide” | More autonomy means higher costs and errors that compound more easily | “Which steps must have human approval?” |
| “Build the full version straight away” | Start with the simplest solution and add complexity only when needed | “Which parts of the process are already fixed and can be written as code?” |
The third column is the part you have to supply yourself: reading the technical documentation and turning it into questions that help the client decide. That is the core skill of an FDE.
A worked example: the refund agent
Imagine a retail chain that wants an “AI customer service employee” to handle refunds as well. You connect three tools to the agent: look up orders, check the returns policy, create a refund. A customer writes: “I want to return the shoes I bought last week”, without giving an order number.
Anthropic’s documentation warns that when a required parameter is missing, the model may infer a plausible-sounding value. In this example, “plausible” could be the most recent shoe order of a different customer. A human employee would ask. With an agent, do not rely on luck: design it so that it has to ask.
Now to compounding errors, which Anthropic names outright as the cost of autonomy. This is an illustrative calculation, not a measured figure: if each step an agent takes is 95% correct, a chain of 10 sequential steps is fully correct only about 60% of the time (0.95 to the power of 10 ≈ 0.599).
That number is enough for an executive to see why “just let it decide” is a risky decision.
The way out lies in how Anthropic distinguishes two kinds of system. Workflows orchestrate LLMs and tools through predefined code paths. Agents let the LLM direct its own process. For refunds, looking up the order and checking the policy are fixed steps, so writing them as a workflow makes sense.
Only understanding the customer’s message and drafting the reply need the model’s flexibility.
According to Anthropic, agentic systems often trade latency and cost for better task performance. Some cases justify the trade, but not all. In this example, the refund should require human approval until data from sandbox testing shows otherwise.
That is also what Anthropic recommends: test extensively in isolated environments and put guardrails in place.
Saying “not yet” without deflating the client
The most common mistake is a flat rebuttal: “What you want is AGI, and nobody can build it.” That is true, but it also kills the enthusiasm that got you into the room. A better approach is to acknowledge the destination, then map the route in three steps:
- Name what the client is picturing, and say honestly that it is still hypothetical.
- List concrete tasks with the client, and pick one with a clear process to build as a workflow first.
- Agree on checkpoints at which data will decide whether to grant more autonomy.
Anthropic’s advice is to find the simplest solution possible and add complexity only when it is genuinely needed. That is the line to take into the meeting. It is not a refusal but an ordered plan, something a decision-maker can approve, track and measure.
The skill worth practising is translating expectations into scope
Many developers, including many in Vietnam, are strong at code but have had little practice turning vague expectations into concrete scope, a skill FDEs use every day. Practise explaining AGI, narrow AI and agents in sentences a business executive understands on first hearing.
When reading job descriptions, look for phrases such as “translate business requirements”, “scope with stakeholders” or “customer-facing”. On your CV, do not just write “built agents with LLMs”; say where you chose a workflow over an agent, where you placed approval steps, and why.
A small personal project is enough: an agent with a few tools, plus a page documenting the missing-parameter cases and how you forced the model to ask. That page shows how you think about a system’s limits, which a demo that “does everything” cannot.
Simon’s promise missed because it bet on machines understanding by themselves what people want. The FDE’s job is not to make that bet: sit with the client, write down each task they need done, then give the agent exactly the tools to do each one.
Was this article useful?
Thanks for the feedback!