Why a Cautious Agentic AI Pilot Can Still Create a Very Large Commercial Commitment: Start Small. Negotiate Big.

A read-only agentic pilot can remove a fifth of your risk exposure and still leave every major commercial decision on the table. That is true whether your pilot is about to start or already running.

The advice on agentic AI has become remarkably consistent: pick a contained use case, limit autonomy, keep the agent read-only, put a human in the loop and learn before you scale. It is good advice. With so much still unsettled in the technology, economics, delivery models and governance of agentic AI, it may be the best advice available.

But it is only half the advice. Start small. Negotiate big.

That sounds contradictory until you separate what you are deploying from what you are committing to. The deployment may be a single agent doing a single job. The commercial relationships you create to deliver it are a different matter, and in agentic transformation it is a mistake to treat them one at a time. If your pilot is already underway, this is not a warning that arrives too late. For most enterprises, the negotiation that matters most is the next one.

Why a Smaller Agent Does Not Mean Fewer Decisions

We have been testing this with UpperEdge’s Agentic Transformation Atlas, which maps agentic scope against a standing set of risks, decisions, delivery activities and contractual controls. We modeled a fairly sophisticated adaptive agent, then stripped it back to a constrained, read-only observer. The read-only version retired 29 of the 139 risks we had identified, about 21%. Starting small really does reduce exposure.

The decision count did not move. Both agents required the same 44 key decisions.

That is because many of the most important decisions were never about autonomy. They were about the relationship: what consumption will cost and how it will be audited, who owns a failure when several providers are involved, how portable the solution is, what happens when capability changes and who owns the methods created along the way. A read-only agent limits what can go wrong. It does not settle what the relationship will cost, who controls it or how you get out of it.

This is where buyers get into trouble. They rightly decide that a small pilot deserves a small implementation, then let the same logic shrink the commercial conversation around it. Right-sizing the implementation is discipline. Shrinking the negotiation to match it is a concession.

The Agent You Pilot Is Not the Agent You Will Run

“Read-only” is also rarely permanent. The agent reads, then produces something durable, then writes to a system of record, recommends decisions, acts with approval and eventually acts on its own or directs other agents. None of that has to happen recklessly. It usually happens because the pilot worked.

Every step changes the risk profile. The contract often stays the same.

At signing, it is hard to justify spending negotiating capital on behavior-change protections, version controls or liability for autonomous actions when the agent can only read. Then the capability expands, the protections are suddenly necessary and the provider is already embedded.

That is why the agreement should state what the agent is allowed to do, not just the use case, and define what happens commercially when that boundary moves. Capability expansion should be a commercial event, with risk, liability, governance and economics reopened on terms agreed in advance, not absorbed into a routine change order.

One Pilot, Three Relationships: A Case Study on Hidden Leverage in Vendor Consolidation

You may think you are negotiating a small engagement with one provider. You probably are not.

Take an example I have started calling the Big A. Suppose Accenture is implementing a limited Claude use case through Amazon Bedrock. On paper it looks clean: one SI, one cloud platform, one model. Commercially, you are already shaping relationships with Accenture, AWS and Anthropic at once, and their roles are blurring.

AWS is moving from infrastructure into agent tooling, orchestration and governance. Anthropic is building deeper enterprise relationships and its own capabilities for managing its models. Accenture is building methods, tooling and managed services for agentic environments.

That overlap is one of the buyer’s main sources of leverage. When several providers can credibly deliver a capability, you have a choice. When that capability gets bundled into one relationship early, the choice disappears.

A tooling decision with the SI changes how replaceable the cloud platform is. An architecture decision on the platform shapes the model-provider relationship. Letting the SI become the default orchestration layer makes alternatives harder to use. These are not three negotiations. They are one commercial architecture.

Consolidation is not always wrong. One provider may ultimately deserve a much larger role. But choosing consolidation after you have learned something is very different from letting a small pilot choose it for you.

The Provider Lock-In Nobody Is Designing For

Most CIOs know to protect against cloud concentration, model dependence, proprietary tooling and weak exit rights. The less visible risk is an operating model that does not exist yet: the processes for approving and testing models, introducing and retiring agents, handling exceptions, and governing prompts, tools, permissions and memory.

Most enterprises have not built this, so someone will build it for them. Often that will be the SI, and the SI may be very good at it. But its governance methods become part of the environment, its tooling gets embedded, its monitoring becomes how you measure performance and its people fill roles you have not yet staffed. In the Big A, Accenture is no longer just implementing Claude on AWS. It is becoming the operating glue between the providers and the enterprise.

You may still have technical portability on paper. The practical question is what happens to your operating model if you replace one of the providers. The deepest lock-in may not be where the model runs. It may be how your enterprise learns to run it. A CIO can protect everything the architecture advice says to protect and still lose the leverage through an operating model that quietly works around someone else.

Already in Pilot? Your Biggest Negotiation Leverage Is Still Ahead

Many enterprises started months ago. The pilot is running, the SI is on site, and the platform and model are chosen. That does not mean the window has closed. It has moved.

A pilot agreement rarely defines the relationship. The production SOW, the expanded cloud commit, the model provider’s enterprise agreement and the managed service that follows do. The move from pilot to production is usually the last point at which the buyer holds meaningful leverage across the whole network.

Buyers in pilot also hold something buyers just starting out do not: evidence. You know what consumption actually looks like, where the agent fails and whose tools are becoming part of how you operate.

Use that before the scale decision. Compare what the agent does today with what the contract allows, see which processes now run on the SI’s methods, and protect the provider overlaps that still exist. The risk for programs in flight is not that the pilot was signed small. It is that the production commitment inherits the pilot’s small commercial conversation.

What “Negotiate Big” Means in Practice

It does not mean buying a big program or writing a contract for every imaginable scenario. It means not letting the size of the implementation set the size of the commercial conversation, whether you are at the pilot contract or the production decision. Four moves sit behind the approach.

Know the Unknowns.

Discover unresolved decisions about technology, economics, provider roles, operating model and capability path. An unknown you have named can be negotiated. One you have not named will be resolved for you.

Preserve Your Options.                                             

Keep architecture, model, provider and operating-model choices open until you can make them deliberately, including ownership of the methods and runbooks built for you.

Accelerate and Plan Learning.

Use the pilot to answer the questions that will change your commercial decisions, not just the ones that prove the use case works.

Generate, Exercise, and Preserve Leverage.

Use competition while it exists, negotiate related relationships in parallel and carry credible alternatives into the contract.

The Buyer Is the Only One Looking at the Whole Picture

Each provider will negotiate its own piece, and each will be perfectly rational about it. The buyer is the only party responsible for understanding what those relationships become once they are combined.

So start small, because there is a lot you do not know yet, and learn aggressively. Just do not wait for the unknowns to resolve, only to find the provider network, the commercial terms and the operating model have already settled around you. And if you have already started small, remember that the pilot does not set the size of the negotiation. The decision to scale does. Negotiate that one as if it were the first.

Start small describes how you deploy. Negotiate big describes how you shape the relationships forming while you do.

A Complete-Looking Proposal Can Still Leave the Biggest Decisions Open
The agent may be the cheap part. Identity, controls, monitoring and governance can be the larger commitment, and someone will settle those choices for you if you do not. Join us Wednesday, October 7th at 11am ET to learn which decisions to surface before you sign and the 13 critical principles to buying agentic AI. Save your seat here.