Enterprise AI Spending Hits $177 Billion in 2026: 5 Signs Agents Are Changing the API Consumption Market

Author’s note: This article breaks down Menlo Ventures’ 2026 enterprise AI report, explaining how Agents are shifting model consumption from “humans asking questions” to “machines continuously carrying out tasks”—and what that means for API calls, concurrency, and procurement.

Menlo Ventures published its The State of Enterprise AI report on November 3, 2026. It estimates that enterprises spent approximately $177 billion on AI in 2026 (the report’s exact figure is $176.8 billion), about 5.4 times the $33 billion spent in 2025. Even more noteworthy, enterprises spent an average of roughly 2.5 times what they’d originally planned.

This isn’t another generic claim that “the AI market is huge.” The report draws on a survey of nearly 400 US enterprise decision-makers and cites OpenRouter’s token data. Its findings point to the same shift: spending growth is no longer driven primarily by “more people asking AI questions,” but by “Agents continuously working on people’s behalf.”

What you’ll learn: This article reviews key figures on enterprise AI spending and Agents, explains why Agents are changing token consumption and API usage, and examines what API developers and buyers need to prepare for.

2026 Enterprise AI Spending: Key Takeaways

First, the numbers. All figures in the table come from Menlo Ventures’ market estimates. They’re not audited totals of enterprise payments or revenue figures for any single model provider.

“Spending on using AI exceeds spending on building models” signals a turning point. In the past, discussions about the AI industry focused on training and computing power. Now, the fees businesses pay to put models to work have become the larger category. It’s also worth noting that “spending on using AI” includes infrastructure, application subscriptions, APIs, and more. It shouldn’t be treated as API market revenue.

Around the same time, OpenAI President Greg Brockman said at the WSJ Tech conference on November 4 that more than half of OpenAI’s revenue now comes from its enterprise business. That figure describes OpenAI’s own revenue mix. It’s different from Menlo’s estimate that OpenAI accounts for 31% of enterprise API spending, so the two shouldn’t be compared directly.

Why Enterprise AI Spending Far Exceeds Budgets: Depth of Use Matters More Than User Count

The Gap Between Planned and Actual AI Spending

The report’s most counterintuitive finding is the budget gap. At the start of the year, companies broadly underestimated how quickly their AI costs would grow:

The average was more than twice the median, suggesting that a small number of heavy AI users drove up overall spending. The adoption rate rose by just 10 percentage points, while average spending per company grew to nearly five times its previous level. So the main driver of growth wasn’t more companies starting to use AI—it was existing users putting AI to work more extensively.

Enterprise AI Spending Is Creating New Budget Categories

Looking at funding sources, Menlo estimates that about 55% of new AI spending came from newly allocated budgets, while about 22% came from existing software budgets. In other words, AI isn’t just replacing traditional SaaS—it’s also creating purchasing categories that didn’t exist before. For procurement leaders, AI has moved beyond an “IT tools” expense to become an operating cost that needs to be managed separately.

How Agents Are Changing API Consumption: From Questions to Execution

How Chatbots and Agents Use APIs Differently

The immediate reason budgets are getting out of control is a change in how APIs are called. A typical chatbot works on a “one question, one answer” basis: the user sends a message, the model returns a response, and Token consumption roughly tracks the number of questions people ask. An Agent works differently: it takes a goal, breaks it into tasks, calls tools, checks the results, and iterates. A single task can involve dozens of model invocations.

📊 Diagram note: The multi-model Agent workflow on the right can use different models for planning, execution, and validation. If you’d like to test this invocation structure yourself, you can use a single key with APIYI at apiyi.com to switch between models from different providers and compare them.

Token Consumption Tracks Task Execution

Using OpenRouter data, Menlo found that Agents now account for roughly 80% of the platform’s total Token consumption, or about 130.9 trillion Tokens per week. Since Agent traffic overtook human-driven traffic in February 2026, Agent traffic has grown about 37-fold, while human-driven traffic has grown only about 5-fold over the same period.

OpenRouter’s users are primarily developers and startups, so these figures aren’t representative of the entire industry. Still, they point in the same direction as other signals. OpenAI’s 2025 enterprise report shows that average inference Token consumption per organization through its enterprise API grew about 320-fold year over year. Axios also reported that more than 60% of Codex users run multiple tasks simultaneously at some point during the day. Together, these figures suggest that Token consumption is shifting from following people to following tasks.

Where Enterprise AI Spending Goes: Why Coding and Enterprise Chatbots Lead

How Spending Breaks Down Across AI Applications

Spending in the estimated $77.3 billion AI application market is highly concentrated:

The coding segment is even more concentrated. Menlo estimates that Claude Code and Codex together account for roughly $24 billion of the coding application market, or nearly 70%. Coding was the first area where the Agent model gained traction, thanks to three conditions.

Three Conditions for Successful Agent Deployment

1. An environment where actions can be taken: Agents need access to GitHub, email, calendars, Slack, enterprise documents, and databases. Reasoning alone, without tools, can’t get real work done.
2. Complete task context: Beyond the user’s question, Agents need company standards, business processes, project history, operational constraints, and success criteria.
3. Verifiable results: A compiler can check whether code builds, and tests can check whether functionality works. This is a key reason coding Agents are ahead. By contrast, the results of research and retrieval tasks are harder to verify objectively.

The third point also explains the cost risk of Agents. In areas where results are hard to verify, an Agent can consume a large number of tokens and still produce incorrect conclusions. Axios reported on Stanford professor Andrew Hall’s use of Claude Code to update an old paper. A subsequent human review found errors in both data collection and code processing.

How Agents Affect the API Market

Impact on API Developers

• Rethink your cost model: Estimating API budgets as “number of users × unit price” is no longer accurate. Instead, use “number of tasks × average number of invocation rounds × context length.”
• Set budget guardrails: Agents running continuously in the background need per-task token limits, maximum iteration counts, and circuit breakers for failures. Otherwise, costs could climb from 1.9 times the enterprise budget to 4.7 times.
• Combining models is becoming the norm: Use a powerful model for planning, a lower-cost model for batch execution, and a model from another provider for cross-checking. This can significantly reduce the cost per task.

Impact on API Providers

Agent-driven demand changes fall into five categories, each requiring different capabilities from providers:

💡 Choosing a provider: If your agent workflow combines models from multiple providers, you can prototype it using the OpenAI-compatible interface at APIYI apiyi.com. Pay-as-you-go pricing makes it easier to track the actual cost of each stage.

A Reality Check: Enterprise AI Spending Isn’t the Same as API Revenue

The claim that “more agents will inevitably mean more revenue for API providers” doesn’t necessarily hold, for three reasons:

• Much of the $176.8 billion goes toward infrastructure and application subscriptions, not API invocation fees.
• Prices continue to fall. Open-source models now account for 19% of token usage but only about 4% of spending, showing that more tokens don’t necessarily translate into proportional revenue growth.
• Caching, batch processing, and model routing reduce unit costs. Ultimately, providers compete on reliability and task success rates, not just token sales.

How to Build a Multi-Model Agent Workflow with an API

Minimal Example

This code shows the two calls in a basic Agent workflow: planning and execution. Replace the model names with models available in your platform console:

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.apiyi.com/v1")

plan = client.chat.completions.create(
    model="YOUR_PLANNER_MODEL",
    messages=[{"role": "user", "content": "把“整理本周销售周报”拆成 3 个步骤"}]
).choices[0].message.content

result = client.chat.completions.create(
    model="YOUR_EXECUTOR_MODEL",
    messages=[{"role": "user", "content": f"按以下步骤执行并输出结果：\n{plan}"}]
)
print(result.choices[0].message.content, result.usage.total_tokens)

import time
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1",
)

MODELS = {
    "planner": "YOUR_PLANNER_MODEL",    # Strong reasoning model for breaking down tasks
    "executor": "YOUR_EXECUTOR_MODEL",  # Low-cost model for batch execution
    "checker": "YOUR_CHECKER_MODEL",    # Model from another provider for cross-checking
}
TOKEN_BUDGET = 50_000   # Token limit per task
MAX_ROUNDS = 3          # Maximum iteration rounds

used_tokens = 0

def call(role: str, prompt: str, retries: int = 3) -> str:
    global used_tokens
    if used_tokens >= TOKEN_BUDGET:
        raise RuntimeError("超出单任务 Token 预算，熔断")
    for i in range(retries):
        try:
            resp = client.chat.completions.create(
                model=MODELS[role],
                messages=[{"role": "user", "content": prompt}],
            )
            used_tokens += resp.usage.total_tokens
            return resp.choices[0].message.content
        except Exception as e:
            time.sleep(2 ** i)  # Exponential backoff
            last_err = e
    raise last_err

def run_agent(goal: str) -> str:
    plan = call("planner", f"将目标拆成可执行步骤：{goal}")
    output = call("executor", f"按步骤执行：\n{plan}")
    for _ in range(MAX_ROUNDS):
        verdict = call("checker", f"检查结果是否满足目标“{goal}”，"
                                  f"合格只回复 PASS，否则指出问题：\n{output}")
        if verdict.strip().startswith("PASS"):
            break
        output = call("executor", f"根据反馈修正：\n{verdict}\n原结果：\n{output}")
    print(f"本任务共消耗 Token：{used_tokens}")
    return output

print(run_agent("整理本周销售数据并写一份 300 字摘要"))

This code puts several earlier points into practice: each task takes at least three calls, the three roles use different models, and a token budget and iteration limit help keep costs under control.

🚀 Quick start: Get free test credits at APIYI apiyi.com, try different models for each of the three roles, and record the usage data before choosing your production model combination.

Frequently Asked Questions

Enterprise AI Spending and Agents: Key Takeaways

• Scale: Menlo estimates that enterprise AI usage spending reached $176.8 billion in 2026, about 5.4 times the previous year’s level.
• Budget gap: Actual spending averaged 4.7 times the previous year’s level, compared with a planned increase of just 1.9 times.
• Source of growth: Most growth came from deeper usage among enterprises that had already adopted AI, not from higher adoption rates.
• How usage scales: Agents tie token consumption to task volume, concurrency, and runtime.
• Requirements for deployment: Agents need an execution environment, complete context, and verifiable results—which is why coding is leading the way.
• Keep the distinction clear: Enterprise AI spending isn’t the same as API revenue, and token growth doesn’t equal year-over-year revenue growth.
• Getting started: Use a single key through APIYI at apiyi.com to combine models from multiple providers and measure real-world task costs.

Summary

Three shifts define enterprise AI spending in 2026:

1. From human-driven to task-driven: Model usage is shifting from people asking questions to agents carrying out tasks continuously.
2. From tool fees to dedicated budgets: More than half of new spending comes from new budgets. AI is becoming an operating cost managed in its own right.
3. From selling tokens to selling reliability: API services will increasingly compete on stability, concurrency, multi-model switching, and usage monitoring.

For developers and procurement teams, the best next step is to measure cost per task using real workloads, rather than budgeting by headcount. Try building a multi-model agent prototype with APIYI at apiyi.com, then use actual usage data to inform next year’s AI budget.

📚 References

1. Menlo Ventures – 2026 The State of Enterprise AI: The primary data source for this article
2. Link: menlovc.com/perspective/2026-the-state-of-enterprise-ai

3. Details: Covers enterprise AI spending, API market share, OpenRouter Agent data, and research methodology

4. Reuters – Brockman on OpenAI’s enterprise revenue: Enterprise revenue accounts for more than half of OpenAI’s revenue

5. Link: reuters.com/legal/transactional

6. Details: Reported on November 5, 2026. Note that this uses a different metric from Menlo’s API market share figures.

7. OpenAI – The State of Enterprise AI 2025: Baseline data on enterprise usage

8. Link: openai.com/business/guides-and-resources/the-state-of-enterprise-ai-2025-report

9. Details: Includes historical data, such as an approximately 320-fold year-over-year increase in reasoning token consumption per organization

10. Axios – Office workers drive OpenAI’s Codex growth: Parallel Agent tasks and supervision challenges

11. Link: axios.com/2026/06/02/openai-codex-knowledge-workers
12. Details: Based on June 2026 data; useful for understanding how knowledge workers use Agents

Author: APIYI Technical Team
Technical discussions: Have practical questions about Agent workflows or multi-model invocation? Contact us through the APIYI homepage at apiyi.com.