WrightyMedia Logo
Enterprise Architecture
November 19, 2026 5 min read

AI governance must move from finance to operations

AI spending is out of control because governance runs through finance instead of operations, where token costs happen in real time.

AI governance must move from finance to operations

Key Takeaways

  • Traditional annual AI budgets fail when autonomous agents can burn through quarterly spending in hours, not months.
  • By October 2026, 93% of enterprise CTOs had already exceeded their AI budgets because finance-layer controls can't match machine-speed consumption.
  • A runtime control plane enforces token budgets and routes requests to cost-appropriate models before execution, preventing overruns by 40-60%.
  • Organisations that treat AI governance as an operational discipline rather than a finance reporting process gain cost predictability and unit economics control.

By October 2026, 93% of enterprise CTOs had exceeded their AI budgets—some by 2–3×. The problem isn't demand forecasting. It's that traditional finance-driven governance can't keep pace with autonomous agents that burn through quarterly budgets in hours.

In July 2026, McKinsey surveyed 150 enterprise CTOs about their AI spending behavior. The finding was stark: 93% had exceeded their 2026 AI budgets by October, with 47% already 2–3× over forecast.

When asked why, the refrain was consistent: "Our teams can spin up new agents and models faster than we can track them. By the time Finance sees the invoice, it's too late."

The deeper pattern emerged from FinOps Foundation research: organizations managing token spend were 21% mature at cost allocation, and only 20% mature at forecasting. Meanwhile, 79% of organizations reported adoption of AI agents, and 466% year-over-year growth in AI agent deployments.

The collision was inevitable: traditional finance-driven governance cannot operate at the speed of autonomous agents.

The enterprise AI cost crisis is a governance architecture problem

Three forces have created an urgent need for operational-layer AI cost control:

Agentic workflows multiply API calls by 10–100×

A simple chatbot makes one API call per user query. An autonomous agent solving a multi-step business task—triage a customer support request, reconcile a payment, generate a campaign brief—makes 5–50 API calls internally.

Multi-step reasoning, tool use, retrieval loops, and error recovery all burn tokens. A developer naive to token economics can accidentally deploy a self-improving agent that costs $100 per user interaction.

Citizen development democratized AI deployment without democratizing cost awareness

Non-engineers can now build autonomous workflows in Zapier, Make, n8n, or enterprise automation platforms. These tools abstract away token cost implications.

A marketing team member spinning up a customer segmentation agent has no visibility into the fact that their workflow just committed the company to $500/day in token spend.

Untracked, decentralized purchasing bypasses all governance

Developers can access frontier LLM APIs in minutes with a credit card. Finance sees the invoice weeks later, after consumption. By then, it's in production serving live users.

The FinOps Foundation found that 23% of respondents have untracked AI spending across personal credit cards, team cards, and departmental accounts Finance never sees.

The old model—"Finance approves AI budget, IT allocates it, spend gets reported monthly"—cannot work when a single agent can blow through that budget in a day.

Why traditional cloud FinOps fails for AI

Challenge Cloud FinOps Maturity AI Token Economics Maturity Spend visibility Mature; resources provisioned upfront Immature; consumption unpredictable per-call variance is 10–30× Feedback loop speed Months (monthly invoices, annual budgets) Hours to minutes (token burn is real-time) Governance gate location Procurement (pre-deployment) Runtime (must block during execution) Cost unit CPU/memory (predictable, engineered) Tokens (probabilistic, LLM-determined) Anomaly detection Threshold-based (10% over forecast) Behavioral (agent in a loop, context explosion)

The control plane architecture that works

An AI Control Plane sits between users/applications and AI models/providers. It enforces three functions in real time:

Attribution & Telemetry

Every API call is tagged: user, application, workflow, business unit, cost center, model, token count, latency.

It aggregates to meaningful unit economics: cost per customer interaction, cost per task, cost per use case.

Not just "you spent $1.2M on Claude API"—instead, "you spent $30K on customer service automation, $50K on code generation, $20K on content optimization."

Policy & Governance

Real-time enforcement: developer tries to call GPT-4 for a task classified as "routine extraction" → request denied, routed to Phi-4 instead.

Token budgets per application: "ChatBot X has a $5K/month budget; you've used $4.8K; next call will be denied."

Role-based access: entry-level engineers can call SLMs; senior engineers can request premium models with approval workflow.

Escalation rules: high-cost requests ($100+) trigger async approval before execution.

Routing & Optimization

Cost-aware model selection: requests automatically routed to SLMs for routine tasks, frontier models for novel reasoning.

Context optimization: agent loops are detected and constrained; retrieval window sizes are limited.

Caching enforcement: identical prompts reuse cached outputs at 50–90% discount.

Batch coalescing: non-real-time requests queued for batch API (50% cost reduction).

The control plane is not a reporting system. It doesn't just measure spend after the fact; it prevents uncontrolled spend before it happens. It operates at API-call granularity and enforces policy in milliseconds.

This is analogous to how container security works: a policy engine can reject a container that violates security rules before it starts, rather than logging a violation after the breach. Token governance needs the same pre-execution enforcement.

When you need this governance shift

This governance shift is necessary for:

  • Large enterprises (5,000+ employees) with decentralized AI adoption: Multiple teams, multiple vendors, uncoordinated purchasing. Without a control plane, spend becomes invisible across teams.
  • Organizations deploying autonomous agents at scale: Single agents can burn $100–$1,000/day. Without budgeting and escalation, one rogue agent can exceed an entire department's annual budget in a month.
  • SaaS companies embedding AI features in their product: If your B2B SaaS charges $500/month but your LLM costs are $100/user/month, you have a unit economics disaster. A control plane prevents margin erosion.
  • Regulated industries (healthcare, financial services): Governance, audit trails, and approval workflows are compliance requirements, not optional.

This is less critical for:

  • Early-stage startups with 10–30 engineers: Spend is still tractable with manual oversight and Slack monitoring
  • Organizations using only embedded AI (one model, one vendor): If you use only Claude via a SaaS product, cost is already baked into your seat cost; no need for a runtime control layer
  • Internal tools with low token consumption: If your total spend is $5K/month, elaborate governance overhead exceeds the benefit

Implementation blueprint

Phase 1: Establish visibility (Weeks 1–3)

Audit all current AI spending

Extract invoices from: direct model provider APIs (OpenAI, Anthropic, Google), cloud provider APIs (AWS Bedrock, Azure OpenAI), embedded AI in SaaS tools, open-source self-hosted (if on cloud, track GPU costs).

Tag each spend source by business unit, application, use case

Create a spreadsheet: OpenAI API (Marketing team, ChatBot X, customer segmentation) = $8K/month.

Establish a baseline for token consumption

How many tokens/month is your organization currently burning? What's the trend? (Most organizations see 10–30% month-over-month growth)

Phase 2: Implement a model router + simple policy (Weeks 4–6)

Option A (Low-lift, fastest ROI): Adopt LiteLLM or OpenRouter

Add cost-aware routing configs to your applications. Example:

routes:
  - name: "customer-service"
    model: "openrouter/mistralai/mistral-7b"  # SLM
    max_tokens_per_day: 50000
    cost_limit: $50/month
    fallback: "openrouter/claude-3.5-sonnet"  # Frontier as backup
  - name: "research-synthesis"
    model: "openrouter/claude-3.5-sonnet"  # Frontier
    max_tokens_per_day: 100000
    cost_limit: $200/month
    approval_required_if_exceeds: $100/request

Option B (Medium-lift, better control): Build a lightweight control plane layer

Use Portkey.ai (hosted) or build your own Python middleware:

# Pseudo-code for cost-aware routing
def call_model(user, task_type, prompt):
    if task_type in ["simple-qa", "tagging", "extraction"]:
        model = "phi-4"  # SLM
    elif task_type == "reasoning":
        model = "claude-3.5-sonnet"  # Frontier
    else:
        model = select_by_cost_budget(user)
    
    cost = estimate_cost(model, len(prompt))
    if cost > user_budget_remaining:
        raise BudgetExceededError(f"User {user} has $X remaining")
    
    return api_call(model, prompt)

Option C (High-lift, enterprise-grade): Evaluate an enterprise AI governance platform

Consider Workato, Collibra, ServiceNow AI Control Tower. These integrate with your existing IT governance workflows.

Phase 3: Instrument attribution & establish feedback (Weeks 7–9)

Set up telemetry collection

Every API call logs: timestamp, user, application, model, tokens, cost, latency. Route into a Postgres database or Snowflake for analysis.

Create dashboards for business units

Each team sees: "You spent $X this month, up from $Y last month. Your cost per customer interaction is $Z. Your top use cases are [list]."

Set up alerts

If an application's spend exceeds forecast by 20%, page the owner. If a single request costs >$50, trigger an approval workflow.

Phase 4: Optimize & enforce policy (Ongoing)

Monthly review: Which applications are costing more than expected? Which are underutilized? Which could migrate to SLMs?

Quarterly governance updates: As new models release, re-evaluate routing decisions. Update policies.

Annual budgeting: Forecast next year based on current trajectory, but build in constraints: "We will not permit any new autonomous agent deployments without IT approval and a cost model."

Concrete example: n8n workflow automation governance

If you're building n8n automations that call Claude or GPT-4, add governance:

[n8n automation trigger]
  ↓
[Middleware: Check cost budget for this workflow]
  - If budget remaining > estimated cost → proceed
  - If budget remaining < estimated cost → notify owner, escalate to approval
  ↓
[Call model via LiteLLM (cost-aware router)]
  - Router selects Phi-4 for routine tasks, Claude for novel ones
  ↓
[Log execution: user, workflow, model, tokens, cost]
  ↓
[Add to aggregated spend dashboard]

Integration points:

  • n8n: Add a "Cost Policy Check" node before every AI model call. Query your control plane (or LiteLLM API) for routing and budget validation.
  • APIs: Wrap OpenAI/Anthropic SDK calls with middleware that enforces cost policies and routes based on task type
  • Airtable/CRM: Create a "Token Cost Budget" table per client, per application. Sync with your control plane; export actual spend for client reporting
  • Zapier: For clients using Zapier, recommend Zapier's native "OpenRouter" integration (cost-aware routing built in)

From cost crisis to cost confidence

The transition from finance-driven to operations-driven AI governance mirrors the evolution of cloud computing.

In 2010, companies managed cloud costs using annual budgets and quarterly reviews. By 2015, organizations with mature FinOps implemented real-time cost monitoring, automated shutdowns of unused resources, and reserved-capacity optimization. Those organizations paid 30–40% less for equivalent cloud consumption.

Today, the same leverage applies to AI. Organizations that implement real-time policy enforcement in their AI stack will operate with dramatically better unit economics. They will catch cost anomalies in hours, not weeks. They will prevent rogue agents from bankrupting departments. They will have auditable governance for compliance.

This is not a cost-optimization project. It's a risk management imperative. The companies that move fastest will have an unfair advantage.

Ready to gain control of your AI costs? Download our AI Cost Governance Toolkit—includes a cost audit template, sample LiteLLM config for cost-aware routing, SQL schema for token cost attribution, and dashboard template. Get visibility into AI spend in one day.

[Download the toolkit →]

Need hands-on help? Our AI Cost Governance Design Engagement is a 3-week sprint: spend audit and baselining, policy framework design, control plane setup (hosted or self-hosted), team training, and governance playbook handoff. From cost crisis to cost confidence.

[Schedule a consultation →]

Custom Feed

Want more on
Enterprise Architecture?

Add this topic to your Custom Digest. Drop your email to get our deepest insights on this exact topic.

No spam. Just high-signal intelligence.

Ready to fast-track your business?

We combine enterprise-level technical strategy with your existing business to solve complex blockers and accelerate your growth. Let's build something remarkable.

Partner With Us