Anthropic Is Giving Away $10 Million. Here's How Companies Will Waste It.

Anthropic is running a real offer right now. Every first-time Claude Code or Cowork user your organization invites gets $1,000 in credits, valid for 90 days. The cap is 10,000 seats, meaning up to $10 million in total credits per organization. The activation window closes July 2. The offer is available on usage-based Claude Enterprise plans only. Legacy seat-based Enterprise plans and Team plans are not eligible.

One detail worth noting before you get excited about the math: credits apply to Claude Code and Cowork usage only, not to Claude chat. And they expire 90 days after issuance with no notification. There is no warning email when the clock runs out. Unused credits are forfeited silently.

It's a genuinely good offer. And if history is any guide, a meaningful portion of organizations that accept it will have nothing useful to show for it by day 91.

The Pattern That Keeps Repeating

Three companies learned this the hard way in the past year.

Microsoft's Experiences and Devices division, the team behind Windows, Microsoft 365, and Teams, rolled out Claude Code to thousands of engineers in late 2025. By June 2026 they were shutting it down, steering engineers back to GitHub Copilot CLI. The cause wasn't that Claude Code didn't work. It worked well enough that engineers used it at a scale that consumed the annual AI budget ahead of schedule.

Uber's story is faster. After rolling Claude Code out to 5,000 engineers, adoption climbed from 32 percent to 95 percent in roughly three months. The entire 2026 AI tools budget was gone by April.

Then there's the unnamed enterprise that an AI consultant described to Axios: roughly $500 million in a single month. They had given employees unlimited access with no usage caps. The resulting pattern has a name: tokenmaxxing. Employees maximizing AI consumption to hit internal leaderboards, not to create value.

None of these are flukes. They're the default outcome when you deploy AI access the way you deploy a software license: purchase seats, send invites, let it scale without guardrails.

The difference between these companies and the ones getting real ROI comes down to one thing: governance built before the invites go out.

The credits are real. The risk is just as real. Here's how to take the offer without becoming a cautionary tale.

Five Personas, Five Different Problems

The single biggest mistake in enterprise AI rollouts is treating all users as interchangeable. They're not. After managing deployments across different organizations, I've found that almost every company has the same five personas, each with a distinct spend profile, a distinct set of appropriate tools, and a distinct failure mode if left ungoverned.

Casual users

This is most of your headcount. Email drafts. Meeting summaries. Quick lookups. Occasional document reviews. These users don't need Claude Opus 4. A mid-tier model handles their workload at a fraction of the cost, with no quality difference for the tasks they're actually running. M365 Copilot shines for these users.

The cost gap between frontier models and efficient mid-tier models is 17 to 25 times at current pricing. A routing policy that sends casual users to the appropriate tier cuts your AI spend by 70 to 80 percent for this cohort alone. This is the largest cost lever you have, and it requires no sacrifice in output quality. A real question to consider is whether they need Claude if your organization also has access to M365 Copilot.

Knowledge workers and citizen developers

More on this persona in the next section because it deserves its own treatment. The short version: this is your highest-ROI cohort, and most organizations are leaving it entirely at chat, but with the right enablement they'll build automations, run agent-based workflows and more without touching a terminal.

Power users

Legal teams. Strategy groups. Research analysts. These users are running long documents through complex reasoning chains, and they actually need frontier model access. Expect monthly spend of $150 to $500 per person. Set spend alerts at 80 percent of their monthly limit so they don't hit a wall mid-project. They're generating real value; you want them to be able to finish the work. Value gained is a huge trade off against the old way of doing things.

Developers and engineers

This is where several organizations got burned. Claude Code is no longer just an assistant. It's an agentic platform. Claude Code Routines, launched in April 2026, let developers schedule autonomous tasks that run on Anthropic's infrastructure without a local machine. Subagents, parallel workstreams, scheduled jobs triggered by GitHub events. The productivity gain is real. So is the spend.

Monthly cost per engineer ranges from $150 for light use to $2,000 or more for engineers running complex agentic workflows. Uber's 5,000 engineers averaged $150 to $250 per month, with power users hitting $500 to $2,000. Hard monthly caps for this persona are not a nice-to-have. They're the difference between a productive rollout and a budget emergency.

Executives

Executives are usually the most over-provisioned persona in any AI deployment. They may use AI infrequently in some organizations, often for high-stakes but relatively simple tasks: document reviews, brief preparation, email drafts. Most of what they do doesn't require a frontier model. Without an explicit routing policy, they default to the most capable model available because that's what the interface presents.

Set model access controls before the invites go out if possible. Route them to an appropriate tier for standard tasks. They'll get the same quality result, and you'll stop paying frontier prices for queries a mid-tier model handles just as well.

Getting Knowledge Workers Past Chat

The citizen developer persona deserves its own section because it's where the highest ROI lives, and it's the most consistently under-served persona in enterprise AI deployments.

These are your operations managers, finance analysts, project coordinators, and HR business partners. They won't write code. They don't need to. But they can build things that used to require a developer, and most of them don't know it yet.

The beyond-chat capability set available to this persona right now:

Cowork automations. A finance analyst can connect Cowork to their SharePoint data and build an automation that generates a weekly budget variance report, formats it, and drops it into the right Teams channel. No code. No IT ticket. Setup time: under an hour with a basic enablement session.

Agent-based workflows. An operations manager can configure a Cowork agent to pull data from a project tracker, identify tasks past their due date, cross-reference with the responsible team member's calendar, and draft a status update for the project lead. What used to take 30 minutes of manual work runs on a schedule.

Scheduled report generation. Connect Cowork to SharePoint lists, Excel data exports, or Teams channels. Set a trigger. The agent runs, compiles, and delivers. The operations person moves from report-runner to report-reviewer.

Supply chain and operations triage. An operations agent can monitor predefined signals, update a system of record, file a remediation ticket, and notify stakeholders with context. The kind of workflow that previously required a custom Power Automate build with developer involvement.

The reason most organizations leave this persona at chat is not the technology. The capability exists today. It's that nobody runs an enablement session showing them what's possible. Chat is the default surface because it's familiar. Nobody demonstrates the Cowork canvas, the agent builder, or the connector library. So knowledge workers use the AI the way they used Google: ask a question, get an answer, close the tab.

The governance implication matters here: citizen developers need a different tier than casual users. Their sessions run longer, their agents generate more tokens, and their automations can run repeatedly without anyone in the loop. They belong in a distinct cost bucket with their own monthly budget and their own spend visibility. Most rollouts collapse this persona into the casual user tier. That's both a cost error and a capability error.

The $1K credit is genuinely enough runway to discover what this persona can do. The question is whether anyone invests 30 minutes in an enablement session before handing them access.

The Governance Layer You Have to Build Yourself (For Now)

Four controls keep AI spend from becoming a budget emergency.

Per-user monthly token limits

Every user account needs a ceiling, and the mechanism matters. When users can see their own consumption in real time, a visible progress indicator rather than an invisible hard stop, they make different choices. They route routine queries to lighter models to preserve budget for high-value work. Research from Sphere Partners on enterprise AI cost governance found that the top 5 percent of users in most deployments account for 40 to 50 percent of total AI costs. Visible limits create a cost-aware culture. Invisible limits just enforce a wall.

Per-team monthly budgets

Teams need independent monthly budgets tracked in real time. The goal is to turn AI spend from a centralized IT line item into a per-department operational cost with accountability attached.

When the finance team can see their own AI spend alongside their output metrics, ROI conversations become grounded in data rather than estimates. Chargeback reporting, showing each department exactly what they spent, is one of the more effective cultural levers available. It changes the question from "why is AI expensive?" to "what did we get for what we spent?"

Model access controls by role

The governance decision about which model tier(s) are appropriate for each persona should be made once, by whoever owns your AI policy, and then enforced automatically. Individual employees shouldn't need to think about cost governance. The appropriate model range for their role should be their available option set.

For standard Claude Enterprise, the admin console is your starting point: usage dashboards, per-seat activation tracking, and team-level controls. For BYOK deployments, segment API keys by team and set hard spending caps at the provider level directly in the Anthropic console. For organizations that need true per-persona model routing before Anthropic ships native controls, third-party governance wrappers sit between users and the API and enforce routing rules per team or role. The configuration is not trivial, but whether it's worth the effort depends heavily on how quickly Anthropic ships native persona controls, and based on the trajectory, that may not be far off.

Automated alerts at 50, 80, and 100 percent

Alerts should fire at three thresholds, not just at the limit. A 50 percent alert gives department heads time to make decisions. An 80 percent alert is the last practical intervention point before the budget runs out. A 100 percent alert means the window has closed.

Wire these to Slack or Teams via webhook. Route them to the department head, not just to IT. The person who can act on a budget decision should be the one who gets the notification.

The tokenmaxxing fix

Technical controls solve the financial problem. They don't solve the cultural one. Amazon found this out when it discovered workers inflating AI consumption to hit internal leaderboards, chasing metrics instead of creating work product. The company eventually scrapped its AI usage tracking system entirely.

The fix isn't restriction. It's transparency. Show users what they're consuming, in context, alongside what they're producing. Frame AI spend as a resource to be invested, not a tap to be left running. This requires an enablement session at onboarding and periodic review, not a policy document that nobody reads.

The Product Gap Anthropic Needs to Close

Here's the honest state of Anthropic's Enterprise admin console right now: it gives you useful visibility, but it doesn't yet give you governance.

What it does today: usage dashboards per seat, seat activation tracking so you can see who has triggered their $1K credit, API key management for BYOK deployments, and spending caps at the key level.

What it doesn't do: you can't currently set "casual users get Haiku at standard effort, engineers get Opus at extended thinking" from a single policy panel. There's no native per-persona model routing. There are no effort controls by role. If you want to enforce different model tiers for different user types, you're either segmenting API keys manually or deploying a third-party governance wrapper. You're building the governance layer yourself. For now. There are hints of this coming based on what is happening in the 'Claude for Government' space.

This isn't a criticism so much as an observation about where the product is in its maturity curve. The enterprise admin tooling is clearly being developed, and the trajectory is readable. The pieces exist: prompt caching controls, extended thinking on or off at the API level, model selection per API key. What's missing is a unified policy layer that connects these controls to user roles without requiring an SA to stitch it together.

The benchmark for what this should look like is Microsoft's Copilot admin center. It's not perfect, but it gives an IT admin the ability to configure which Copilot capabilities are available to which users, set usage policies by group, and review consumption by department from a single panel. That's the target state for Anthropic's enterprise tooling, and it's clearly coming.

When native per-persona controls ship, the governance architecture you're building today should be replaceable cleanly. Design your role segments in your identity provider, not hardcoded in a governance wrapper. Use BYOK with clearly named per-team API keys so the transition to native controls doesn't require rebuilding your user taxonomy. The work you do now should become the foundation, not technical debt.

The Counter-Arguments (Taking Them Seriously)

Three objections come up regularly when this framework gets presented. They deserve real responses.

"Just give everyone access and see what happens."

This is the move-fast argument, and it has genuine merit. Organizations that deploy broadly learn faster. They surface unexpected use cases. They find their citizen developer candidates organically rather than trying to predict them in advance.

The problem isn't the broad deployment. The problem is deploying broadly without a baseline. If you have no usage data, no model routing, and no per-team visibility, you can't tell the difference between productive use and tokenmaxxing. You can't identify which teams are generating real value. By day 91, when the credits expire and usage-based billing kicks in, you have no data to defend the budget you're about to be asked to justify.

Deploy broadly. But set up the measurement layer first, even if you keep the access controls loose. You'll learn faster and know what you're learning.

"The credits make governance irrelevant for 90 days."

The credits do absorb the cost shock. If you're going to burn $10 million learning how your organization uses AI, doing it on Anthropic's budget is clearly better than doing it on yours. That's a legitimate point.

This matters more than it sounds, because of a fact buried in the support documentation: credits apply only to Claude Code and Cowork usage, not to chat. A knowledge worker who spends 90 days in chat never activates their credit at all. The $1,000 per seat sits unearned and expires. The promo is structurally designed to push users into Code and Cowork; organizations that don't build the enablement layer to make that happen are leaving the credits on the table as much as leaving the value on the table.

For engineers, the 90-day framing holds a different lesson. Engineers who use Claude Code without spend visibility for 90 days develop usage habits with no cost intuition. Those habits carry directly into day 91 when they're paying for it themselves. The governance layer is worth building during the credit window because it shapes the behavior you inherit after the window closes.

"Token prices are falling, so this will solve itself."

Token prices are falling. The cost per million output tokens has dropped significantly over the past two years, and the trajectory continues. But falling unit prices don't reduce total spend when consumption grows proportionally.

Google's API was processing 16 billion tokens per minute in Q1 2026, up from 10 billion the prior quarter. That's a 60 percent increase in consumption during a period of continued price deflation. Economists call this the Jevons paradox: making a resource cheaper tends to increase total consumption rather than reduce total cost. Cheaper tokens make AI more accessible, which drives more usage, which increases total spend. Governance doesn't become less relevant as prices fall. It becomes more relevant as the number of users who can afford to over-consume goes up.

The 90-Day Pilot That Actually Works

The $1,000 per seat is enough runway to run a real pilot with governance built in. Here's what a structured rollout looks like.

Before July 2

Segment your users into at least three groups in your identity provider before invites go out: casual users, knowledge workers and citizen developers, and technical users. This taxonomy drives every governance decision downstream.

Set spending limits through the admin console before the first user activates. If you're running BYOK, set a hard cap on your API key at the provider level as an additional backstop. Either way, configure this before invites go out, not after the first invoice.

Put a calendar reminder for day 80 after your first activation. Credits expire 90 days after issuance with no notification from Anthropic. If you activated your first seats on June 30 and do nothing, the credits disappear quietly in late September with no warning.

Schedule a 30-minute cohort-specific enablement session for each group. Not a generic "here's how to use Claude" session. Show casual users the three things that will save them time this week. Show knowledge workers the Cowork canvas and one end-to-end automation they can build right now. Show engineers the Claude Code Routines setup and one example of an autonomous workflow. The session pays for itself on day two.

Configure per-team budget alerts wired to Slack or Teams. Even if you set generous limits, you want the data flowing before anyone asks for it.

Weeks 1 to 4

Watch the top-users-by-consumption dashboard. Identify your heaviest users and ask whether their spend corresponds to output. Identify the knowledge workers who haven't moved past chat and run a targeted enablement session for them specifically.

Day 60 review

Pull the usage vs. credit balance. Check model routing effectiveness: what percentage of casual user queries went to frontier models, and can that number be reduced? Check citizen developer activation: how many knowledge workers have built at least one automation? These numbers tell you whether the rollout is on track before the billing transition hits.

Day 91 and beyond

The credits expire. Usage-based billing begins. If you've built the governance layer, you have a baseline, a model routing policy, and a per-team budget framework that was validated on someone else's money. The pilot becomes the playbook.

The companies getting real value from enterprise AI didn't move fastest. They moved most deliberately. This offer is an unusually good opportunity to do that deliberately, at scale, without the financial risk that normally comes with it.

Use it like one.