The comforting story is that AI is just cheaper labor, so incumbents can add it and keep their lead. Feinberg's argument is that this is a category error. Most companies have quietly filed AI into the production function as a discount on the labor term. But labor earned its own theory because humans respond to authority, meaning, incentives, and accountability. AI is stranger still: like labor in some dimensions, like capital in others, and like nothing we have priced before in the rest.

Walk an ordinary manager's day across the O*NET taxonomy: getting information, analyzing it, thinking creatively, interpreting meaning, communicating, directing people, controlling resources. Then ask which of those an AI cannot execute. On mechanics, almost none. What survives is authority, accountability, and who is answerable when it goes wrong.

Incumbents must migrate. They carry structure, people, decision rights, and an installed base into the new production function. Entrants carry none of it. So the advantage is not your product, your model access, or your shipping speed. It is arithmetic performed on somebody else's balance sheet, and it depreciates every quarter they spend migrating, on their schedule, not yours.

Then came the line that made the room quiet. Every agentic system is secretly an org chart. One agent executes, one verifies, one supervises, one routes. Almost every AI tool in the room already contained a small firm with reporting lines. We are all doing organizational design. We just call it architecture and skip the part where we ask what it means.

At ANCI we built a commit point: the moment an agent pauses before an irreversible action and hands the decision to a human. We designed it as a safety mechanism. Through Feinberg's lens it is a decision-rights boundary. Where the human sits in an agent workflow is the same question as who signs off in a company. That is not a feature. That is a constitution.

Anchor it in Coase. Firms exist because of transaction costs, and intelligence shifts which activities can be traded at all. If more activity becomes tradable across the boundary of the firm, coordination between firms goes up, not down. The scarce thing becomes the trusted, neutral connective tissue between companies.

So model two horizons separately: the transition value of adoption friction, and the steady-state value once everyone has crossed. Some businesses live entirely on migration friction that evaporates. Others look unsellable today and obvious in five years. Know which one you are building, and spend the head start on the organization that should exist.

For leaders separating signal from hype, the most useful reframe is simple: an agent is not a chatbot. A chatbot is a function. Text goes in, text comes out, and you close the loop yourself. An agent is a loop that closes itself. It gets a goal, acts against the real world, observes what happened, and decides again until it is done.

The litmus test: remove the human from the middle. If something still happens, it is an agent. And the model is maybe a fifth of the job. The rest is tools, memory, orchestration, and the evaluation layer most teams forget until it is too late.

Two habits separate builders from tourists. Treat context as a feature, not a dump: a curated 8k window beats a lazy 200k one, and costs less on every loop. And automate spans, not steps: a contiguous run that ends at a human decision, never an isolated step in the middle.

Every few months a smarter model resets the leaderboard, and every few months it matters a little less. An agent can be extremely intelligent and still be bad at its job if it does not understand the environment it works in. Ask one to manage a hospital's appointments and the polite email is the easy part. It also needs the scheduling system, the policies, the patient data, and the judgment about when to ask a human.

Picture two new hires given the same task. One is brilliant but knows nothing about your company. The other is less brilliant but has spent years learning your products, customers, policies, and systems. In most situations you would trust the second one to get the job done. Agents face exactly the same problem.

A powerful model can give a great answer, but the answer is only useful if the right information sits behind it. A bank's agent needs financial rules and company policy. A manufacturer's agent needs equipment, inventory, and production. The question is not which model scored highest on a benchmark. It is which agent knows what this job requires.

This is why specialized vertical agents keep beating brilliant generalists at real work. A general AI can answer a customer's question about returning a product. A specialized retail agent can look up the order, check the return policy, decide whether the purchase qualifies, start the return, and update the system. The difference is not that the second agent is smarter. It has better context.

Businesses already know it. Deloitte's 2026 research found that 85 percent of surveyed organizations expect to customize AI agents for their specific needs, across customer service, supply chains, cybersecurity, and knowledge management. They are not shopping for one AI that does everything. They want AI that does one thing really well.

If many companies can rent similar models, the model itself stops being the advantage. The advantage comes from everything around it: internal data, workflows, customer knowledge, software systems, and industry expertise. A healthcare agent does not need to know how to run a restaurant. A restaurant agent does not need to process a mortgage. The best AI for a specific job may simply be the one that understands that job best.

Context is not just access to data. An agent in a finance department may see every record and still have no business making every decision. It needs to know which decisions require approval, which policies apply, and which actions it may take. Three layers carry that context.

The stakes rise the moment agents act instead of advise. A wrong answer, a person can ignore. A wrong transfer, account change, or business decision is different. Yet Deloitte found only 21 percent of organizations have a mature governance model for agentic AI. The smarter the agent, the more it matters to know what it should not be allowed to do.

Think of the model as the brain. Context is what tells that brain what it is looking at, what it is supposed to do, and which rules it must follow.

Most enterprise pilots do not die because the technology fails. They die because nothing graduates them. MIT put a number on it: 95 percent of enterprise AI pilots deliver no measurable impact. The few that cross are not the ones with the best model. They are the ones with a repeatable playbook.

Stalled projects are rarely declared dead. They linger in a permanent almost, the pilot works great, we just need to productionize it, until attention and budget drift away. No one ever decided to stop. There was simply no mechanism to graduate.

The single highest-leverage fix is a graduation gate: explicit criteria, a named owner, and an actual go or no-go decision. Passing it is an achievement. Failing it is not an embarrassment but a precise list of what is still missing.

What should the gate check? Eight practices, each answered with evidence rather than intention, and each flexing with the risk tier. A Tier 0 internal tool clears them in an afternoon. A Tier 3 system touching money or health must satisfy every line at full strength.

Even a pilot that clears the gate should never go from zero to full traffic in one step. Turn the dial; do not flip the switch.

The demo that won the budget priced exactly one thing: a single call to the model. That number is small and falling. But a trusted answer is not one call. It is a pipeline: retrieval and extra context to ground it, often a second pass to verify it, an eval suite to measure it, and a human to review the answers that matter. Together they can multiply the cost of a reliable answer several times over.

None of that argues against the layers. It argues against being surprised by them. A pilot greenlit on demo economics hits production, the true cost appears, and the tempting fix is to strip out verification and review, precisely the parts that made it trustworthy.

Trust is billed in three currencies. Money: tokens, compute, and infrastructure, where a verification pass can double the inference bill. Latency: reliability steps are serial, retrieve then generate then verify, so a half-second answer becomes several seconds. And engineering and human time, where human review is uniquely expensive because it costs in all three currencies at once and does not scale.

That produces a real trilemma. Fast, cheap, reliable: pick two, deliberately, per use case. An internal tool can be fast and cheap because a human catches the errors. A customer-facing financial answer must be reliable and fast, and you pay for it. An overnight batch can be reliable and cheap because nobody is waiting. The only wrong move is not choosing.

So budget trust like insurance. Line up the cost of the layers against the cost of the failure they prevent: the refund, the fine, the viral screenshot. Be generous where an error is ruinous and frugal where it is trivial. The question for the CFO is not why this costs more than the model call. It is whether reliability spend on each use case matches what a failure there would actually cost.

Every vendor promising zero hallucination is selling a mirage, and a dangerous one. AI systems are probabilistic, so they carry a non-zero error floor by construction. Error reduction is an asymptote: the last stretch to zero costs effectively infinite money and never arrives.

Worse, believing in zero breeds complacency. A team that thinks it eliminated hallucination stops watching for it, and complacency strips out the safeguards that keep a system safe. The inevitable error then lands with every net removed.

The mature industries never chased perfection. Aviation, medicine, and chip fabrication made error bounded, detectable, and recoverable instead. Ask any vendor three questions: what is your measured error rate, how do you detect a failure, and how do you recover from one.

Sixty-six people registered for the August 20 bootcamp, and every slide came from something one of them wrote on the form. Nineteen said they wanted to build agents, often with no further detail. Only six asked about guardrails, evaluation, and production, the part where projects actually die. So the session was built to close that gap.

Draw the two loops side by side and most arguments about what counts as an agent dissolve. A chatbot goes prompt, model, answer, then stops, because a human decides what happens next. An agent goes goal, decide, act, observe, and round again. Human in the loop becomes optional, and that word is the whole distinction.

The honest list of failure modes is long: hallucination, cost, context rot, silent failure, prompt injection, and uniform confidence, sounding just as sure when guessing as when certain.

Every architecture decomposes into five parts: model, tools, memory, orchestration, and evaluation, the forgotten one. Great tools beat a great model. Without evaluation, nobody can answer the only question that matters six weeks later: is it getting better or worse?

Emily Mao built the parallel agent: three research agents launched at once on Calendly, Reclaim.ai, and Motion, each gathering pricing, positioning, and hiring signals, then a merge agent and a dashboard agent turning them into one competitive view. The fan-out works only because no lookup needs another's answer. What bites is partial failure, when one branch times out and the merge quietly returns something incomplete that looks complete.

Yash Sanghvi built the router. One messy customer email hid a crash bug, a fifty-seat expansion, and a complaint about the API docs. The router classified by meaning, split the message, and dispatched each piece: engineering got the bug, product got the docs, and sales got the expansion, held for human approval because it touches revenue. Misrouting is silent, so log the routing decision apart from the answer.

Raj Lal built the dynamic agent, an orchestrator for inbound leads that classifies deal size, seniority, and urgency, writes a spawn plan, and only then decides which specialists to wake. The thresholds live in code, not in the prompt, because rules you can unit-test beat rules the model re-derives on every run.

In a chat session you are the scheduler, the input provider, the error handler, and the delivery mechanism. Replace all four and you have a product: a trigger, a data connection, validation that fails loudly, and a destination.

Before automating, label every step, including the informal ones, because "and then someone eyeballs it" is a step. MOVE steps are code. JUDGE steps, classify, extract, summarize, are what the model is for. CHECK steps are code first. DECIDE steps, approve, commit, spend, send, belong to a human or a very hard rule. Automate a contiguous span that ends at a DECIDE. That is your v1 and your human checkpoint in one.

Guardrails are four layers, not one: input constraints, execution limits, output validation, and only then a judge model for what code cannot check. If you came to understand it, learn the loop. If you came to ship it, build the test set first. If you came to govern it, write down what correct means and attach a human name to it.

You do not tier the model. You tier the use. The model that writes a throwaway summary and the one answering a patient's medication question can be literally the same model. What changed is the consequence of being wrong.

Two questions locate any use case. How bad is it if the answer is wrong? And how exposed and autonomous is the output: checked by a colleague, or sent straight to a customer? Each yes toward harm, autonomy, regulation, and irreversibility nudges a use up a tier.

Each tier prescribes how much grounding, evaluation, oversight, accountability, and disclosure a use case needs. Cheap and light at the bottom, exhaustive at the top.

Regulators reached this answer first. The EU AI Act sorts systems into unacceptable, high, limited, and minimal risk, and the NIST AI Risk Management Framework takes the same proportionate posture. Anyone who governs AI at scale arrives at tiers, because a rulebook that treats every use identically is either too strict to permit the easy wins or too loose to prevent the disasters.

Tiering is not red tape. It is how you move safely instead of blocking everything equally. Because most of your uses live in Tiers 0 and 1, where governance is cheap, you can say yes to the harmless majority right away and reserve committees for the high-stakes minority.

Blanket bans fail in both directions. They surrender the enormous, safe value of low-stakes automation, and they push employees toward unsanctioned tools in the shadows, which is worse than the risk they meant to prevent. Blanket green lights fail the other way, letting AI touch customers, contracts, and money with the casual freedom of an internal brainstorm.

The tier is also the first line of the graduation gate. It sets the bar for everything after it: how much grounding, how strict the evals, where the human sits, and how much trust to budget. Get the tier wrong and every downstream control is calibrated to the wrong stakes. Get it right and governance stops being a brake and becomes a steering wheel.

List every AI use in flight, sanctioned or not. For each, answer the two questions, consequence and exposure, and place it in a tier. Then read across: which uses are over-governed and stalled, and which are under-protected and exposed?

Ship the Tier 0 and Tier 1 backlog this month. Assign a named owner to every Tier 2 system. And pull any Tier 3 use without human sign-off back into shadow mode until it clears the full gate.