5 terms to settle before committing to an AI agent vendor

On June 1, GitHub switched every Copilot plan to usage-based billing. Not a price increase. A change in what gets counted. The official changelog said it in one flat sentence: “As of June 1, all Copilot plans bill based on GitHub AI Credits consumed.” A seat used to be the unit. Now a token is. By June 2, developers were posting their receipts.

That is a coding tool, not a fleet of autonomous agents, and most early-stage teams do not live or die by Copilot. So why does it matter for the vendor a founder is about to sign with this quarter? Because the same meter is coming for the whole category, and it arrives quietly. The pricing page that looks reasonable against a five-person pilot is not the pricing page the company pays once agents run thousands of steps unattended. A seat never ran a thousand-step job at 2 a.m. An agent will, cheerfully, and bill for every token of it.

The five terms, in the order that protects you

Here is what to lock in writing before committing, ranked by how much grief each one saves later.

1. 1. Pin the unit of billing, then price one real workflow at production volume

   Ask the vendor exactly what meters: tokens, credits, agent-runs, resolved outcomes, or some blend. Then take one workflow the team will actually run, estimate its volume at real scale, and make the vendor quote that number. A demo costs nothing to run. A production loop with retries, long context, and multi-step planning is a different animal, and the gap between the two is where budgets break.

2. 2. Set a hard spend ceiling that stops, not one that warns

   Insist on a control that halts spend at a number, rather than emailing an alert after the money is gone. GitHub's own safeguard is the model to copy: set the additional-spend budget to zero and the tool simply stops when included credits run out. Push for the same hard stop, plus per-user and per-agent caps, so one enthusiastic engineer running agents overnight cannot drain the month.

3. 3. Separate the model from the workflow, and ask who owns the exit

   Swapping the underlying model is easy. Swapping the place that stores your agent definitions, memory, and embeddings is a rewrite. Get it in writing: on exit, who hands back the agent configs, the conversation memory, and the vector data, and in what format. That is the portability that actually matters, and it is rarely in the standard clause.

4. 4. Get a renewal guardrail in the contract, not the sales call

   Metered pricing makes renewal the moment the bill resets to reality. Lock an annual price-protection cap, a per-unit rate lock, and a consumption ceiling now, while the vendor still wants the logo. Verbal reassurance about "fair pricing" at renewal is not a term. A number in the contract is.

5. 5. Name an owner and confirm the kill switch before go-live

   One person owns this agent: its cost line, its behavior, and the authority to stop it. Confirm the vendor gives you a real off switch that takes effect in seconds, not a support ticket. If no name goes next to the agent before launch, the answer to "who owns this" becomes "everyone," which means no one.

Why most teams get this wrong

The common mistake is negotiating the cheap layer. Founders haggle over the model and the sticker price, because those are the parts a demo shows. Then they sign, build six months of workflows on top, and discover the expensive lock-in was never the model at all.

Look at where the industry put its money this week. In the first three days of June, Palo Alto Networks acquired Portkey, an AI gateway for routing and runtime policy, and Asana acquired StackAI, a no-code agent builder, while Microsoft used its Build keynote to publish an end-to-end agent trust stack. None of those moves are about the model. They are about the control plane: the layer that holds the agents, the routing, and the governance. That is the layer that hardens around a company, and it is the one most procurement checklists never mention.

Founders haggle over the model and the price because those are what the demo shows. The lock-in that actually hurts is the layer the demo never opens.

So the reframe is simple. The vendor decision is not “which agent looks best in the demo.” It is “which terms protect me when the meter, the model, and the renewal all move.” Settle the terms above and the demo becomes what it should be: a tiebreaker, not the whole decision.

The numbers

The reason to do this now, rather than at renewal, is that the new model bites on day one. Here is what GitHub’s flip looked like within 24 hours, reported by gHacks the day after.

Another developer in the same coverage reported spending more than $6 on a single change request and called the consumption “impossible to predict.” Unpredictable is the operative word. The bill did not double; the way it accrues changed, and the old mental model stopped working overnight.

This is not one vendor having a bad week. Anthropic moves programmatic Claude usage onto a separate metered credit pool on June 15, two weeks after GitHub. And the broader pattern was already visible: a SoftwareSeni analysis of the per-seat-to-usage shift earlier this year pegged the typical price uplift at renewal at 20 to 37 percent, which is exactly the number a price-protection cap is meant to contain. The metering trend is the context. The renewal cap is the response.

Ship it

Monday morning, before the next vendor call, do two things. Write down the one workflow the team will run most, with a real volume estimate, and make every vendor quote that exact number. Then add the five terms above to the evaluation doc as pass-or-fail line items, not nice-to-haves.

None of this slows a team down. It does the opposite. A founder who knows the billing unit, the spend ceiling, the exit, the renewal cap, and the owner can sign quickly and sleep fine, because the surprises got priced in before the meter started. The teams that move fastest with AI are not the ones who skipped the contract. They are the ones who read the part everyone else signed without opening.