The Agentic Shift

When the Model Stops Asking Permission

In late 2024, Anthropic shipped an internal tool called Claude Code. On paper, it was simple: a command-line assistant for software developers. A developer types a request -- "fix the authentication bug in the login module" -- and the AI helps.

But the team that built Claude Code made a design choice that separated it from every coding assistant that came before it. They didn't write a workflow. There was no fixed sequence of steps. Instead, they gave the model access to tools -- file reading, file writing, terminal commands, web search -- and let the model decide what to do next.

The model looked at the request. It decided to read the authentication module. It found a suspicious function. It decided to check the test file. It discovered a failing test case. It decided to read the dependency configuration. It found a version mismatch. It decided to fix the dependency, update the code, and run the tests. Seven decisions, each contingent on what the model learned from the previous one.

No engineer coded that seven-step workflow. The model reasoned its way through the problem. That's the shift. Not a smarter chatbot. Not a faster assistant. A fundamentally different architecture where the AI doesn't follow a script -- it writes the script as it goes.

What Actually Changes When Agency Moves to the Model

For the first twenty topics of this deep dive, code controlled the workflow. The PM designed what information the model would see. The harness assembled that information automatically. The model generated a response within the boundaries the harness defined.

But there's a class of problems where code can't control the workflow because the workflow isn't known in advance. A developer debugging a production issue doesn't follow a fixed procedure. They form a hypothesis, check a log file, revise the hypothesis, search the codebase, find something unexpected, pivot to a different approach. The workflow emerges from the problem.

Think of it like the difference between a GPS that gives turn-by-turn directions (code-controlled -- the route is planned before you start driving) and an experienced taxi driver who knows the city (agent -- they decide the route in real-time based on traffic, construction, and shortcuts they've discovered).

Three breakthroughs made this practical. Function calling (2023) gave models the ability to act on the world, not just talk about it. Large context windows (2024) gave agents enough working memory to sustain extended reasoning chains. Reliable reasoning (2025) gave models judgment good enough that letting them decide outperformed hardcoding the workflow.

All three were required. Function calling alone gives you a model that can invoke tools but only when told. Large context windows alone give you a model that processes lots of information within a fixed workflow. Reliable reasoning alone gives you good decisions with nothing to decide about. Together, they give you a model that can observe its environment, decide what to do, and execute that decision -- repeatedly, in a loop, until the task is done.

The First Production Symptom: Drifted Plans

The false binary: "everything should be an agent." A customer FAQ bot that retrieves answers from a knowledge base doesn't need agency. The workflow is fixed, the answer space is bounded, and code-controlled routing is cheaper, faster, and more reliable. The PM's first question should always be: does this problem REQUIRE the model to decide the workflow?

The testing problem. Code-controlled systems are deterministic. Agentic systems are stochastic -- the same input might produce different action sequences. Quality assurance shifts from testing workflows to testing outcomes and boundaries.

The cost reality. An agent making seven tool calls costs 7x the tokens and 7x the wall-clock time of a single model call. For 10,000 queries per day at 7 calls each, that's $700/day in inference costs. The economics of agency are fundamentally different from single-shot generation.

The PM Role Shift

In a code-controlled system, the PM designs workflows: "when the user asks about billing, retrieve the FAQ, generate a response, apply the compliance filter." In an agentic system, the PM designs boundaries: "the agent can access the billing database and the FAQ. It must never modify billing records. It must escalate disputed charges to a human."

The PM stops designing what happens and starts designing what's allowed to happen. That's the shift from Context Designer to System Architect to Constraint Architect.

Remember This

1. An agent is a system where the model decides what to do next -- selecting tools, retrieving information, and determining when to stop. If the code controls the workflow, it's not an agent, and that's often the right architecture.

2. Three breakthroughs made agency practical: function calling (2023) gave models the ability to act, large context windows (2024) gave them working memory, and reliable reasoning (2025) gave them judgment. All three were required.

3. The PM's role shifts from designing workflows (what should happen) to designing boundaries (what's allowed to happen). This is the transition from System Architect to Constraint Architect.