Tech Industry Macro-Trends | November 2025

SECTION 1

Introduction

The latest edition of the sector's technology radars has just come out, with 114 trends selected from the tech community's contributions. This article expands on the macro-trends that emerge from our observations of the broader technology landscape, with additional insights into these developments.

SECTION 2

AI workloads demand a shift in infrastructure orchestration

Whether the elusive "AI bubble" bursts or not, one thing is certain: AI is no longer just a buzzword, and it's a massive driver for the tech industry as a whole. Demand for infrastructure in particular has grown considerably, as training large language models or running inference for AI features often requires large fleets of GPUs, and companies are finding they have to manage these resources at scales previously seen only in supercomputing.

It's now common for teams to struggle with model sizes that don't even fit on a single GPU, forcing them to split the work across multiple accelerators. Platform engineering teams are standing up complex multi-stage pipelines and continuously tuning throughput and latency to keep these AI workloads running. A handful of tools and techniques can help with this endeavor, such as the NVIDIA DCGM Exporter, an open-source tool for monitoring distributed GPUs, and topology-aware scheduling.

An immediate challenge is cost. Cloud GPU instances are expensive and are often billed whether they're busy or idle, so maximizing the utilization of these clusters is paramount. In response, organizations are adopting smarter orchestration strategies to squeeze every last drop of performance and value out of their infrastructure.

### How Kubernetes is adapting to GPU workloads

Adapting Kubernetes for AI workloads, Kubernetes, which was born in the world of stateless web applications, has proven to be an ideal fit for these problems, adapting readily to AI, especially when paired with additional libraries like Kueue. Dynamic Resource Allocation (DRA) for GPUs, long stuck in alpha and then beta, reached general availability with Kubernetes 1.36 in early 2026: it's now the stable, production-ready way to manage hardware accelerators (GPUs, FPGAs, network cards) in a cluster, with far better awareness of hardware topology.

This evolution of Kubernetes is fascinating from an architectural standpoint. Originally designed to orchestrate stateless containers that could start and stop quickly, Kubernetes now has to manage AI workloads that are inherently stateful, long-running, and extremely sensitive to data locality and network topology.

GPU topology challenges, In a modern GPU cluster, not all GPUs are created equal. Bandwidth between two GPUs on the same motherboard is far higher than between GPUs on different servers. For tasks that require frequent communication between GPUs (such as distributed model training), placing processes on GPUs with fast connectivity can be the difference between training that takes hours versus days.

Topology-aware scheduling solves this by giving Kubernetes awareness of the cluster's physical topology. Instead of simply asking "Is a GPU available?", the scheduler can now ask more sophisticated questions like "Which GPUs are connected via NVLink?" or "Which nodes share the same network switch?". This awareness enables far more efficient placements that maximize throughput and minimize cost.

Optimizing cloud costs for AI, At Adservio, we advise our clients on GPU cost optimization, and the numbers are often striking. A poorly optimized GPU cluster can easily waste 40 to 60% of its compute capacity. That translates into hundreds of thousands of euros wasted every year for mid-sized organizations.

Optimization strategies include intelligent workload bin-packing, using spot/preemptible GPUs for non-critical tasks, and implementing preemption mechanisms to prioritize high-value workloads. We also recommend continuously monitoring GPU utilization at a granular level, not just "is the GPU in use?" but "at what percentage of its compute and memory capacity?".

@cite:bonnes-pratiques-kubernetes-en-production

SECTION 3

The rise of context engineering, MCP, and AI workflows

While infrastructure engineers on one side are looking for ways to optimize hardware utilization, on the other, developers are still searching for the best ways to integrate AI into their workflows effectively and efficiently. One notable trend is the shift from ad hoc prompting to more rigorous context engineering.

What is context engineering? At its core, context engineering refers to the practice of carefully preparing and providing structured context information to an AI model so it can perform a task reliably. It goes well beyond simply phrasing a single clever prompt, involving a set of different techniques and carefully planned steps to improve the model's reliability and accuracy.

In practice, context engineering seeks to mitigate the non-deterministic behavior of LLMs by feeding them the most essential information they need to be more accurate. It's not about giving more context, but about giving the right context, at the right time, in the right format.

### The Model Context Protocol becomes the de facto standard

The Model Context Protocol (MCP), The Model Context Protocol (MCP) is the best example of a standard evolving as an effort to "control" context effectively. Since we last mentioned MCP in volume 32 as an interesting standard, it has now become ubiquitous.

Originally published as an open-source standard by Anthropic in late 2024, it defines how an AI client (such as an agent or a coding assistant) can query an MCP server for information or actions. The server might sit in front of a company wiki, a database, or an external SaaS API. It provides the server with what it needs in a standardized way, and the server fetches or executes on its behalf. In late 2025, Anthropic transferred MCP's governance to the Agentic AI Foundation, a neutral foundation under the Linux Foundation also co-founded by Block and OpenAI: MCP is no longer a single-vendor Anthropic project but a community-governed standard with open working groups.

This decoupling is powerful: it means AI developers can integrate new tools or data sources much faster, and it's vendor-neutral by design. The industry has adopted MCP remarkably quickly. In under a year, we've seen thousands of MCP servers spring up, providing bridges to everything from GitHub to SAP systems.

The MCP architecture in practice, The MCP architecture looks like this: you have an AI client (perhaps Claude, ChatGPT, or your own custom agent) that needs information. Instead of hardcoding integrations for every data source, the client speaks MCP. It sends a standardized request: "Give me the latest Jira tickets assigned to team X" or "Fetch document Y from Confluence".

The MCP server, which understands how to talk to Jira or Confluence, receives this request, fetches the data, and returns it in a structured format the client can understand. The client never needs to know the specifics of the Jira API or Confluence authentication, that's the MCP server's job.

This abstraction is revolutionary for the same reasons REST and GraphQL were: it standardizes integration, reduces code duplication, and creates an ecosystem where reusable MCP servers can be shared and improved by the community.

@cite:le-protocole-model-context-au-dela-de-la-tendance

SECTION 4

AI agents and interaction protocols

It's safe to assume that a major contributor to MCP usage is AI agents, which, in addition to MCP, have amassed a plethora of protocols to support their workflows, such as Agent-to-Agent (A2A) and AG-UI. Unlike MCP, which connects an agent to tools and data, A2A connects agents to each other, letting one agent hand off a task to another without exposing its internal state. Started by Google and then handed to the Linux Foundation in 2025, A2A reached a stable 1.0 release in early 2026 and already claims more than 150 organizations running it in production.

The shift toward AI agents, AI agents represent both some of the most exciting and most hyped developments in AI. This shift from chatbots to agentic workflows represents a major step for organizations, which have now realized the limits of static LLMs.

A model cannot see beyond its training data cutoff date, requiring careful use of context and prompting techniques to achieve a goal. By contrast, an agent can draw on real-time information and react to changes. An agent can call APIs, read databases, execute code, and even delegate tasks to other agents.

The risks of poorly configured agents, Our concern about complacency with AI-generated code remains, and new practices are emerging to mitigate the potential for an agent to go off the rails. These practices range from simple file patterns, such as having an AGENTS.md file, to more complex setups, such as anchoring coding agents to a reference application and spec-driven development.

### Governing agents with AGENTS.md

The AGENTS.md file is a simple but powerful concept: it's a markdown file at the root of your project that documents what AI agents are and aren't allowed to do. For example, it might specify "Agents may modify files in /src/ but never in /config/" or "Agents must always run tests before committing".

This declarative approach to agent governance is far more maintainable than trying to control agent behavior through complex prompts. The AGENTS.md file becomes the single source of truth that both humans and agents can consult.

Team-level AI workflows, These new techniques aren't limited to agents, by the way. Full AI workflows have grown in importance, serving entire teams, whether functional or cross-functional. Most code editors now provide a set of options for sharing instructions to be reused by multiple individuals.

This essentially lets teams share best practices and utilities like a one-click extension for AI, helping standardize AI usage, ensuring every code review follows the same checklist, or giving every developer a quick command to fetch up-to-date library docs, for example.

At Adservio, we've developed curated prompt libraries for different types of teams: backend teams, frontend teams, data teams, DevOps teams. Each library contains dozens of prompts tested and optimized for common tasks specific to that discipline.

For example, our backend library includes prompts for generating unit tests, writing database migrations, creating RESTful API endpoints, and optimizing SQL queries. These prompts aren't simple one-liners; they include context on the company's coding standards, preferred architectural patterns, and security considerations.

SECTION 5

Avoiding the iceberg: emerging AI antipatterns

As AI techniques spread across the industry, we're beginning to see the emergence of certain antipatterns. Bad practices aren't new in software development, but new problems are being enabled by AI adoption. While most of them can be mitigated through strong use of fundamental practices, it's valuable to recognize antipatterns early so we can correct course.

### Shadow IT and Text-to-SQL: two concrete traps

AI-accelerated shadow IT, We've previously mentioned AI-accelerated shadow IT, which remains a concern. As the name implies, it's analogous to classic shadow IT, but turbocharged by AI's ability to connect systems in unconventional ways.

For example, some no-code automation platforms now let users integrate directly with OpenAI or Anthropic APIs, making it tempting to use AI as "duct tape" to join systems together in ways IT never sanctioned. While this can deliver quick wins, it poses maintainability and security risks (for example, data leaks or unmonitored processes).

At Adservio, we've observed several cases where well-intentioned employees built "agents" connecting Slack to production databases via ChatGPT, completely bypassing access controls and audits. These wild integrations may seem convenient in the short term but create enormous security vulnerabilities and compliance nightmares.

The Text-to-SQL failure, Other examples include overly optimistic use of current AI tech. Text-to-SQL solutions, for instance, haven't lived up to initial expectations in practice. Simply trusting an LLM to reliably generate complex SQL queries can backfire; they often require human validation and struggle with edge cases.

We've tested numerous Text-to-SQL tools against real client database schemas, and the results were disappointing. For simple queries (SELECT with a few WHERE clauses), the tools work well. But as soon as you need complex JOINs, subqueries, window functions, or domain-specific business logic, error rates spike.

The fundamental problem is that SQL isn't just a query language; it's a domain modeling language. An effective SQL query requires deep understanding of the data schema, table relationships, performance constraints, and business logic. Current LLMs simply don't have that deep contextual understanding.

This doesn't mean the idea is dead, but teams have learned to keep a human in the loop or use these tools within limited scopes. We recommend Text-to-SQL for exploration and rapid prototyping, but always with human validation before running in production.

Finding the balance, By staying aware of emerging antipatterns, technology leaders can avoid the pitfalls that come with the hype. The overarching message is one of balance, enthusiastically leveraging AI's accelerating capabilities, while pairing that with thoughtful engineering practices, open ecosystems, and a healthy dose of human judgment.

This ensures AI genuinely elevates team productivity and creativity, rather than driving it into a maze of quick fixes and hidden risks.

@cite:les-agents-ia-ne-doivent-pas-etre-un-cauchemar-de-securite

SECTION 6

Facing challenges with a flexible, informed strategy

The tech industry is no stranger to revolutions. Cloud computing transformed how we work and live, and multiple waves have followed since. And with each new thing, we discover new pitfalls and realize our processes and mindsets need to evolve alongside the tech. It's no different with AI.

Beyond all the hype and doomposting, AI is just another part of our toolbox, albeit one that makes a lot of noise. The companies that successfully ride this wave will be the ones that invest in core fundamentals with a pragmatic eye.

The importance of controlled experimentation, At Adservio, we encourage our clients to take a controlled-experimentation approach to AI. Rather than deploying AI at scale immediately, start with well-defined pilot projects with clear success metrics. Learn from these pilots, iterate, and scale progressively.

This approach allows for fast, low-cost failure in controlled environments, rather than catastrophic failure in production. It also allows internal expertise to develop progressively, ensuring your organization has the skills needed to maintain and evolve AI systems over time.

Investing in skills and training, The shift to AI requires new skills, not just for data scientists but for the whole organization. Developers need to learn context engineering and prompt engineering. Infrastructure engineers need to master GPU orchestration. Product managers need to understand the capabilities and limits of LLMs.

We recommend that organizations invest heavily in training and skills development. Teams that succeed with AI aren't necessarily the ones with the best models, but the ones with the best-trained people who know how to use those models effectively.

Governance as a competitive advantage, Finally, organizations that treat AI governance not as a compliance burden but as a competitive advantage will be the ones that win in the long run. Strong governance builds customer trust, reduces risk, and enables responsible innovation.

This includes clear data-usage policies, transparency and explainability mechanisms, robust audit processes, and ethical guardrails. At Adservio, we help our clients put in place AI governance frameworks that are robust enough to guard against risk, yet flexible enough not to stifle innovation.

SECTION 7

Conclusion: understanding to decide better

By understanding the meaning and implications of these trends, we can make better decisions today, rather than simply waiting to react to the future. AI isn't a destination; it's an ongoing journey of learning, experimentation, and adaptation.

The organizations that succeed will be the ones that combine technological enthusiasm with operational pragmatism, that invest as much in people as in technology, and that treat governance as an enabler rather than an obstacle.

The future of AI in the enterprise will be shaped not by those who adopt fastest, but by those who adopt smartest.

Note: The statements and opinions expressed in this article are those of the author and do not necessarily reflect the positions of Adservio.

FAQ

Frequently asked questions