Beyond token growth and autonomous demos, a more consequential shift is emerging: agents are becoming an infrastructure, governance, and operating-model problem.

The defining tension of agentic AI in 2026 is not that the technology is standing still.

It is that adoption, organizational readiness, and economic returns are moving at different speeds.

McKinsey’s 2026 survey found that 40% of respondents at organizations with more than $1 billion in annual revenue reported scaling agents in at least one business function, up from 27% the previous year. Among smaller organizations, the equivalent figure remained at 22%. mckinsey

But broader AI adoption has not produced an equivalent increase in reported enterprise-level financial impact. The share attributing some positive EBIT impact to AI remained essentially unchanged at 37%. That measure covers AI overall, not agents specifically—a distinction worth preserving. mckinsey

Meanwhile, Deloitte found that only 21% of respondents in its multinational survey reported mature governance for agentic AI. deloitte

Put together, these findings suggest a more useful thesis than “2026 is the year of agents”:

2026 is the year organizations began confronting the difference between deploying intelligence and operating delegated authority.

Here are the trends that matter—and what they imply for developers.

1. The Adoption Gap Is Becoming an Execution Gap

Agent adoption is not spreading uniformly.

McKinsey’s findings show growth concentrated among larger enterprises, while the proportion of smaller organizations reporting that they were scaling agents remained flat. Respondents most often reported scaling agents in IT, knowledge management, and software engineering, with substantial differences across industries. mckinsey

That does not establish that smaller organizations cannot benefit. Nor does it prove that company size causes successful adoption.

It does challenge the idea that access to capable models automatically levels the playing field.

My interpretation is that the limiting resource is increasingly the ability to connect models to usable processes:

  • Relevant data must be accessible.
  • Tools must expose the right operations.
  • Exceptions need owners.
  • Outputs need acceptance criteria.
  • The organization must be able to absorb the resulting work.

A developer can build a compelling prototype without solving all of these.

An organization cannot operate the same prototype indefinitely while ignoring them.

What this means for builders

Treat integration readiness as part of product discovery.

Before choosing an agent framework, ask:

Does this workflow have sufficiently clear inputs, accessible systems, and an accountable owner to support delegation?

A weak answer is a product risk, not merely an implementation detail.

2. Coding Agents Are Starting to Change Build-versus-Buy Decisions

One of the most consequential findings in McKinsey’s 2026 survey is not about chatbot usage.

Thirty-two percent of respondents said their organizations had decided against buying at least one software product or feature because they could build the functionality internally using agentic coding tools. mckinsey

Read that carefully.

It does not mean 32% of enterprise software spending disappeared. It does not establish that the resulting software was cheaper over its lifetime.

It does show that agentic development is entering procurement decisions.

The strategic possibility is significant: organizations may become more willing to build narrow, context-specific capabilities that previously failed the economic test for internal development.

Examples might include a specialized reconciliation interface, a workflow-specific reporting tool, or an internal application serving a small team. These are illustrative possibilities, not categories quantified by the survey.

The hidden question: who maintains the result?

My concern is that lowering the perceived cost of creating software can encourage teams to underestimate the cost of owning it.

For an internal tool, I would evaluate:

[

\text{Lifecycle cost}

\text{Creation}
+
\text{Integration}
+
\text{Maintenance}
+
\text{Security}
+
\text{Operational ownership}
]

The opportunity is not “free software.”

It is the possibility of building software that fits a particular context well enough to justify those continuing costs.

What this means for builders

If agents generate more internal applications, the valuable engineering layer may include templates, deployment controls, dependency policies, ownership records, and retirement procedures.

Producing the first version is only one part of the product.

3. Interoperability Is Moving Beyond Model APIs

The emerging agent ecosystem is not only standardizing how applications call models.

It is also standardizing how agents connect to tools, exchange work, and package reusable capabilities.

The Linux Foundation describes MCP as part of the tool-integration layer and A2A as a mechanism for communication and coordination between agents. These solve related but distinct problems. linuxfoundation

In April 2026, the A2A project reported more than 150 supporting organizations, integration across major cloud platforms, and production deployments. Supporting organizations should not be confused with 150 independently verified production customers; the announcement makes separate claims about ecosystem support and deployments. linuxfoundation

In October, the Agentic AI Foundation announced additional projects spanning reusable skills, model interfaces, training and evaluation environments, and sandboxed execution. linuxfoundation

The meaningful development is the scope of standardization.

The industry is building interfaces around an entire execution system, not just a text-generation endpoint.

What protocols do not solve

A common protocol can make a request understandable across systems.

It does not, by itself, establish that:

  • The receiving agent is competent.
  • The task is authorized.
  • The result is correct.
  • The business meaning of the request is shared.
  • Responsibility for failure is clear.

That is an architectural distinction, not a criticism of interoperability.

What this means for builders

Adopt interoperable interfaces where they reduce integration friction.

But keep the contracts separate:

Connectivity contract Can these systems exchange messages? Authority contract Is this action permitted? Task contract What result is required? Evidence contract How will completion be established? 

Protocol compatibility should not become a shortcut around the other three.

4. Agent Identity Is Emerging as Its Own Infrastructure Problem

An agent acting inside one application can sometimes inherit a tightly controlled execution context.

An agent moving across organizational boundaries raises harder questions:

Who does it represent? Which permissions were delegated? Can those permissions be revoked? How should another system verify its identity?

In June 2026, the Linux Foundation announced its intent to launch an Agent Name Service initiative focused on trusted agent identity infrastructure. The announcement described verification of representation, permissions, and authenticity. An announced initiative is evidence of ecosystem direction—not proof that the identity problem has been solved. linuxfoundation

My interpretation is that “agent identity” will require more than assigning a service account a friendly name.

For a hypothetical procurement agent, I would want an authorization context resembling:

principal: procurement-assistant delegated_by: purchasing-team task: id: purchase-request-4821 purpose: collect and compare supplier quotations allowed: - read approved supplier records - request quotations - prepare purchase recommendation not_allowed: - sign contracts - change payment instructions expires_at: task_deadline approval_required: - external commitments 

This is an illustrative design, not a published standard.

Its purpose is to distinguish identity from task-specific authority.

What this means for builders

Design for an agent to carry less authority than the person or organization that initiated the task.

Also design for that authority to end.

5. Governance Is Becoming a Runtime Concern

Deloitte’s 2026 survey covered 3,235 IT and business leaders across 24 countries, all directly involved in their organizations’ AI programs. Only 21% reported mature agentic AI governance. The capabilities discussed included decision boundaries, real-time monitoring, and action-level audit trails. deloitte

That is more specific than “companies need an AI policy.”

A policy document describes intended behavior.

A runtime system must determine what happens when an agent attempts an actual operation.

For example:

Agent proposes a payment-detail change ↓ Application validates the requested operation ↓ Policy determines whether the action is permitted ↓ Required approval is collected ↓ Controlled service executes the change ↓ Result and authorization are recorded 

This is a proposed control pattern.

The important separation is that the model’s recommendation is not itself the authorization.

What this means for builders

Treat guardrails as executable constraints wherever possible:

  • Validate tool arguments.
  • Separate read and write capabilities.
  • Scope credentials.
  • Bind approval to a specific action.
  • Record the resulting state.
  • Define interruption and shutdown behavior.

The practical question is not whether the agent understands a rule in its prompt.

It is whether the surrounding system still enforces that rule when the agent makes a mistake.

6. Portable Skills Are Becoming a Distribution Layer for Know-How

The Agentic AI Foundation’s October announcement described Agent Skills as an open format packaging instructions, scripts, and resources that agents can load on demand. The stated goal is to make specialized capabilities portable across agent products and platforms. linuxfoundation

This points toward an important distinction:

A model supplies general capability.

A skill package supplies a particular procedure, operating convention, or domain-specific method.

My interpretation is that some organizational know-how may increasingly be distributed as maintained executable guidance rather than repeatedly embedded in long prompts.

An illustrative package might look like this:

quarterly-report-review/ ├── instructions.md ├── examples/ ├── validation/ ├── policy/ └── tests/ 

But portability introduces a review problem.

Instructions and scripts that influence an agent’s actions should not receive trust merely because they are easy to install.

What this means for builders

I would treat skill packages as governed dependencies:

  • Identify the maintainer.
  • Pin versions.
  • Review scripts and tool requirements.
  • Test behavior before promotion.
  • Track changes to instructions.
  • Support rollback.

The opportunity is reusable expertise.

The risk is reusable mistakes—or reusable malicious behavior.

7. The Economics Are Shifting From Visibility to Predictability

Knowing what an agent cost yesterday is not the same as forecasting what it will cost tomorrow.

A SnapLogic-commissioned survey of 1,000 enterprise IT decision-makers in the United States, United Kingdom, and Germany reported that 81% believed they could accurately measure individual agent costs, but only 42% believed they could accurately forecast future AI and token spending. markets.businessinsider

This is vendor-sponsored, self-reported research distributed through a press release. It should be treated as directional evidence, not a neutral census of the market.

The distinction it raises is nevertheless useful.

An agent’s execution path can vary: some tasks resolve quickly, while others trigger additional searches, retries, or escalations. Multi-agent architectures add coordination overhead as well; Anthropic’s engineering account explicitly discusses their higher resource requirements. anthropic

What this means for builders

I would monitor a cost distribution, not just an average:

  • Median cost per accepted task.
  • High-percentile cost.
  • Failed-task spend.
  • Retry and escalation frequency.
  • Human review time.
  • Budget-limit events.

A hypothetical dashboard might report:

Typical task: inexpensive Tail tasks: disproportionately expensive Primary cause: repeated tool failure Recommended response: fail earlier and escalate 

That tells an operator more than a single monthly token total.

The objective is not always to minimize computation. It is to make additional computation earn its place.

8. Workflow Redesign Is Becoming More Important Than Tool Adoption

McKinsey found that nearly three-quarters of its defined AI high performers reported fundamentally redesigning workflows because of AI, compared with one-quarter of other respondents. Its high-performer category required both at least 5% attributed EBIT impact and a description of significant value. These are survey associations, not proof that workflow redesign caused the performance difference. mckinsey

Still, the distinction is revealing.

Adding an agent to an existing process asks:

Which step can we accelerate?

Redesigning the process asks:

If some research, drafting, or checking can now happen differently, which handoffs are still necessary?

Consider an illustrative reporting workflow.

The old process might be:

Collect data → Build report → Review report → Discover missing evidence 

A redesigned process might be:

Define decision and evidence requirements ↓ Collect and validate supporting material ↓ Escalate unresolved gaps ↓ Produce a reviewable recommendation 

The second design does not merely generate the report faster.

It moves uncertainty detection earlier.

What this means for builders

Instrument the workflow around the agent, not just the model call.

A faster drafting step has limited value if the same work accumulates in a review queue.

What I Would Not Yet Call a Settled 2026 Trend

A serious trend analysis should also identify claims that exceed the evidence.

“Enterprise adoption proves broad financial returns”

Not established. McKinsey reports increased adoption alongside essentially unchanged shares reporting enterprise-level EBIT impact from AI overall. mckinsey

“Having an AI policy means governance is mature”

Not established. A vendor survey reporting broad policy coverage and Deloitte reporting limited governance maturity are not necessarily contradictory: they ask different populations different questions about different levels of capability. Their percentages should not be combined into one market estimate. deloitte

“Interoperability makes agent collaboration trustworthy”

Not established. Ecosystem announcements demonstrate protocol development and adoption claims, not universal assurance of authorization or task correctness. linuxfoundation

“Expected workforce reductions have already happened”

Not established. In McKinsey’s survey, 14% reported an AI-related workforce decline over the previous year, compared with 32% who had expected one in the preceding survey. Thirty-nine percent now expected declines in the coming year. Expectations, reported outcomes, and causal employment effects are different categories. mckinsey

My Outlook Beyond 2026

The following is interpretation, not a quantified forecast.

I expect the next phase of competition to center on three capabilities.

Cheaper acceptance

Systems that make output easier to verify may create more value than systems that merely produce more output.

Safer delegation

Identity, scoped authority, approvals, and controlled execution may become prerequisites for expanding autonomy.

Better organizational absorption

Teams that redesign review, ownership, and exception handling may capture more value than teams that only increase generation capacity.

These expectations follow from the tensions visible in the evidence: increasing deployment, uneven financial impact, incomplete governance, and growing infrastructure around agent execution. mckinsey

The Bottom Line

The most useful way to read the agent trends of 2026 is not as a race toward unlimited autonomy.

It is as the construction of a new operating layer between human intent and software execution.

Models supply capability. Protocols make connections possible. Skills package procedures. Identity establishes representation. Governance constrains authority. Evaluation determines whether the result deserves acceptance.

Those layers are developing at different speeds.

For developers, that creates a clear opportunity: build agents whose work can be understood, bounded, verified, and economically justified.

The impressive demo asks:

Can the agent do the work?

The durable product asks:

Can we afford to trust the way it does the work—and can we prove when that trust was justified?
Author:Seyed Alireza Alhosseini Almodarresieh
my site :https://almodarresieh.github.io/