In 1776, Adam Smith walked through a small pin manufactory and watched ten people make 48,000 pins in a single day. Working alone, none of them could have produced twenty. That 240-fold gap is also the gap between a chatbot and a useful AI system.
Same forces. Same constraint. Two and a half centuries apart.
Summary
- Smith’s three forces still compound - dexterity from repetition, time saved by skipping context switches, and specialized tools. They explain the pin factory in 1776 and they explain why specialist AI agents beat monolithic chatbots in 2026.
- There is a hidden fourth force Smith took for granted - coordination. The pin factory had a workshop layout, a foreman, and physical handoffs. Most AI rollouts have none of those, which is why smart agents end up producing nicely-formatted nonsense in parallel.
- Process matters more than ever - AI runs whatever process you give it. Without a solid process underneath, the constraint on AI ROI is not model intelligence; it is the design of the workflow the agent is asked to run.
- One concrete move - pick one recurring process this week, name the handoffs, then decide where an agent’s specialization beats a human’s generalization. Start with a Tallyfy template.
The pin factory is the most cited example in the history of economics. It’s also the most under-read. People remember the productivity number, forget the mechanism, and almost never notice the part Smith took for granted. That last part is the one that matters for anyone trying to put AI agents into a real workflow today.
Tallyfy is Process Improvement Made Easy
The 240-fold miracle that nobody actually built
Smith opens The Wealth of Nations by describing a place he had actually visited. Ten people working on what Smith counted as “about eighteen distinct operations.” Drawing wire, straightening it, cutting it to length, pointing one end, grinding the other, fitting the head, whitening the pin, packing it.
Together they made 48,000 pins a day.
That’s 4,800 per worker. Working alone, none of them could have done it. Smith was direct: a worker “not educated to this business” might “with his utmost industry, make one pin in a day, and certainly could not make twenty.” Twenty pins against 4,800. Call it 240 times, or 4,800 times if you want the upper bound. Either way it’s the most consequential productivity gap ever documented.
Here’s the part most retellings skip. Smith didn’t invent the factory. He didn’t design the bench layout. He didn’t engineer the wire-drawing plate. He showed up, watched, and codified what he saw. The mechanism was already there, embedded in the way the workshop was organized. His real contribution was naming the forces underneath.
That’s worth pausing on. If the factory already existed, what did Smith actually discover? Three things, listed in order in Book I, Chapter 1, and the order isn’t accidental. First, that repetition turns hands into specialized instruments. Second, that staying on one task removes the dead time that task-switching imposes. Third, that specialization makes specialized tools worth building. Each force depends on the one before it.
Stop there and the obvious question is this: does any of this apply when the work is not making pins? When the output is a marketing email, a code review, a customer onboarding sequence, a financial reconciliation? When the workers are not humans but AI agents?
Mostly yes, with one critical addition. The way process excellence frameworks like Lean and Six Sigma extended Smith’s logic into knowledge work is the same way modern workflow design extends it into agentic systems. The forces compound. Same three. Same order. Same dependency on something Smith assumed without saying.
Smith’s three forces, line by line
Smith named the three forces explicitly: dexterity from doing one thing repeatedly, time saved by not switching tasks, and the use of specialized machinery that specialization itself makes worth building. Each maps onto the engineering reality of AI agents in 2026 with almost embarrassing precision.
| Pin factory (1776) | AI today (2026) | What the gap is |
|---|---|---|
| Dexterity from repetition | Prompt tuning and fine-tuning of specialist agents | Without targeted training each agent is a generalist that is mediocre at everything |
| Time saved by skipping context switches | One agent per workflow step, no flipping between tasks | Single-agent “do everything” chains burn tokens and lose state partway through |
| Specialized tools | Foundation models plus tool-use APIs plus retrieval | The model is the lathe. The workflow tells the lathe what to make. |
| Workshop layout (Smith assumed) | Workflow orchestration (most teams skip) | No orchestration means smart agents producing garbage in parallel |
| Foreman watching (Smith assumed) | Human checkpoints plus an audit trail | Set-it-and-forget-it agents fail silently in regulated contexts |
Take the rows one at a time. Dexterity from repetition is what fine-tuning and prompt engineering do to an agent. Drop the same agent into the same step 10,000 times and the prompt converges on language that just works. The same way a pin-pointer’s wrist learned the exact angle for the grindstone, a procurement-approval agent learns the shape of a clean approval message.
That’s not magic. It’s repetition shaping the tool.
Time saved by skipping context switches is the one most AI projects waste. A single agent told to do five things in sequence pays a context tax on every transition. It re-reads the brief, re-loads the relevant policy, re-confirms what step it is on, and burns tokens on housekeeping that adds nothing to the output. Specialized agents in a real workflow skip all of that. Each one shows up, does its job, and hands off. The Lean management people have been arguing this for thirty years; the AI engineering community is rediscovering it now.
Specialized tools is the row that already lands cleanly. A foundation model is the lathe of 2026. The vector store is the wire-drawing plate. The tool-use API is the file. Each one took years of focused engineering to make, and none of them is worth building unless someone is going to use them often enough to justify the cost. That economic logic, that tools follow specialization, is Smith’s third force.
The fourth row is where everyone trips.
The fifth row is where the trouble shows up.
Where the analogy breaks
Pins are interchangeable. Knowledge work is not. Two correct marketing emails can read completely differently and still both be correct. A correct legal review is judgment plus citation plus a bit of taste. The output isn’t uniform, and “quality” isn’t binary. So the pin factory analogy starts to leak the moment you push it past the table above.
Coordination has to be explicit because the handoffs aren’t physical. A pin factory worker can see the pile of half-finished pins on the bench in front of him and know what to do next. An AI agent sees a JSON object. If the JSON is wrong, the agent silently produces something wrong, and the next agent silently consumes the wrong thing, and twenty steps later somebody opens a ticket. That’s a class of failure Smith’s workers literally couldn’t have. It’s what good business process redesign and good AI governance work prevents.
Smith saw one other thing that almost nobody quotes today. Late in The Wealth of Nations, in Book V Chapter 1, he warns that specialization has a cost: the worker “whose whole life is spent in performing a few simple operations” eventually loses “the habit of such exertion, and generally becomes as stupid and ignorant as it is possible for a human creature to become.”
That’s the AI deskilling debate, 250 years early. Smith’s answer wasn’t to abandon specialization. It was to insist on public education so that the workers had a life of the mind alongside the bench. The modern version is the same shape: design the workflow so that humans keep the judgment work and agents do the repetition, not the other way around.
That’s the version Tallyfy was built around. Agents specialize. People decide. The handoffs are explicit, the audit trail is visible, and the process is the thing you change when you want a different outcome.
Coordination, the hidden fourth force
Smith took the workshop for granted because the workers were standing in one room with a foreman watching. He didn’t have to write down “and somebody has to coordinate them” because that was already true of every workshop he had ever seen. AI agents don’t have a foreman. They have JSON, and they have whatever workflow somebody bothered to design.
Workflow orchestration is the workshop. Without it, specialization scales chaos. With it, specialization compounds productivity exactly the way Smith said it would.
The process matters here more than the model does, because every weak handoff multiplies through the chain. Anthropic’s own engineering team has written about this directly, describing six common workflow patterns that real teams use: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer loops, and fully autonomous agents. Those aren’t academic categories. They are the operating layouts of the modern workshop, and which one you pick is a design decision that has to be made deliberately.
Most teams don’t make it deliberately. They start with a single big agent, ask it to do everything, and then spend three months trying to figure out why the output is unreliable. A mistake we made early on at Tallyfy was assuming the agent was the unit of intelligence. It isn’t. The workflow is. The agent is the worker. The workflow is the workshop. If you have spent any time around the workflow patterns every AI agent needs or read the case for why your AI agent needs a workflow engine, this will sound familiar; the pin factory just makes it 250 years older.
What does that look like in practice? Sequential is the obvious one: agent A finishes, agent B starts, the way wire-drawing precedes cutting. Parallel is what the pin factory was actually doing across its ten workers at once. Evaluator-optimizer is the foreman walking the bench and rejecting bad work. Each pattern exists because Smith’s bench layout existed first. The technology is new. The operating logic is not.
What to do Monday morning
If you take one thing from any of this, take this: agents aren’t your bottleneck. Process design is.
Pick one recurring thing your team does that currently feels like a mess. Onboarding a new client. Reviewing a vendor for compliance. Closing the books. Handling a refund. Anything that happens more than once a month and currently lives in someone’s head or somebody’s inbox.
Then do three things, in order. First, name the handoffs out loud. Write down who does what, what data leaves their desk, who picks it up next, and what they need to start. Most of the wins are sitting in the gaps you find while doing this. Second, look at each handoff and ask whether the work in front of it is repetition (good candidate for an agent) or judgment (keep a human in the loop). Third, decide where the foreman lives. A checkpoint, an approval gate, an audit trail, a person whose job is to spot the agent producing nicely-formatted nonsense before it reaches the customer.
That is it. That is the entire move. You don’t need a model upgrade. You need a workshop layout.
The biggest lesson we’ve learned building Tallyfy is that the teams who get value out of AI aren’t the ones with the smartest models. They’re the ones who’ve already done the boring work of writing the process down. Document it once, run it many times, watch what breaks, fix it. The pin factory ran on that same loop. So does every useful AI workflow.
Smith would recognize the move instantly. He would also probably ask why it took us 250 years to take his coordination assumption seriously. Fair question.
The fastest way to test this on a real process is to try it inside a process documentation tool that treats the workflow as the unit of work, not the agent. Pick the messy one. Run it as a Tallyfy template for two weeks. See what falls out.
