devopsy.kinsta.cloud

Tag: MCP

SmartBear Tightens Integration Between AI Coding and Testing Tools

SmartBear this week revealed it is narrowing the divide between coding and testing by integrating its platform with artificial intelligence (AI) coding tools.

Sheryl Koenigsberg, senior vice president of product marketing at SmartBear, said integrations with AI coding tools from Anthropic, Atlassian, GitHub, and Amazon Web Services (AWS) will make it simpler for application developers to test code without having to exit the tools they use to create code.

Specific capabilities added to the SmartBear portfolio include a SmartBear Model Context Protocol (MCP) server for GitHub and connectors to ReadyAPI and Swagger for developers using Claude Code from Anthropic.

The overall goal is to reduce the level of friction that application developers might encounter as the volume of code being generated using AI coding tools continues to exponentially increase, said Koenigsberg. In the absence of that testing, the amount of technical debt that software engineering teams are accruing will soon become unsustainable, she added.

Mitch Ashley, vice president and practice lead for software lifecycle engineering at the Futurum Group, said the integrations provided by SmartBear pull testing inside the integrated development environment (IDE) where AI assistants generate code. That approach makes it possible to validate code at the cadence that code is now being created, he added.

Verification that sits outside the agent loop will otherwise accumulate as verification debt, noted Ashley.

While software engineering teams have been trying to shift more responsibility for testing further left for years, the need for application developers to test code before checking it into a DevOps pipeline has become more pressing. It’s not likely that shifting more responsibility for testing further left is going to eliminate the need for dedicated testing teams, but it should substantially reduce the number of issues that conspire to slow down the pace of application development.

It’s not clear how many DevOps teams are revisiting testing in the AI era, but a recent Futurum Group survey finds well over a third of organizations (37%) have adopted AI-assisted testing. In the absence of that testing, many of the return on investment (ROI) benefits provided by AI are negated if too much of the code being created winds up being rejected before being included in a build.

The challenge is that application developers today lack the context needed to review the code created by AI coding tools. As such, the need for AI tools to surface issues in code has become crucial at a time when developers are being asked to read massive amounts of code they personally did not create. Much of that code, in addition to containing any number of vulnerabilities, also tends to be more verbose than the code that humans would create.

The thing that DevOps teams need to remember is that asking an AI coding tool to test its own code is essentially asking it to grade its own homework. Software engineers need to make sure the AI agent that reviews code is based on a different large language model (LLM).

Regardless of the approach to testing AI code, the one thing that is certain is that shipping code faster doesn’t result in better software being deployed without testing.

July 16, 2026
Why Every DevOps Engineer is Suddenly Learning MCP

A year ago, if you mentioned MCP to a DevOps engineer, you’d probably get a blank stare. That’s changing and fast.

Engineers used to spend their days debating Kubernetes, Terraform, CI/CD, and cloud. Now, new topics keep cropping up: AI agents, smarter integrations, autonomous workflows, and this thing called Model Context Protocol, or MCP.

At first, MCP just sounds like another technical spec, nothing revolutionary. The industry’s seen plenty of those. They make a little noise, folks get excited, then everyone moves on.

But MCP feels like it’s actually landing.

Why? The game with AI isn’t just about making systems that generate convincing text anymore. It’s about getting real work done. It’s about connecting AI to the tools, services, and infrastructure engineers actually use, reliably.

That’s where MCP comes in.

Here’s What Was Broken

For years, using AI looked like this: You ask a question, you get a response, the conversation’s over. All fine until people tried putting these AI systems to use in real operations.

Let’s say you have an AI assistant that knows everything about Kubernetes. Great, but it can’t actually talk to your cluster. It might detect problems with cloud resources, but it can’t log in and see your monitoring dashboards. It can suggest infrastructure changes, but it can’t work with deployment tools directly.

Every new tool needed a custom integration, every platform asked for a special connector. You ended up with a mess, a scattered ecosystem where AI could think about what needed doing, but couldn’t actually do it.

There was a massive gap between smart recommendations and action.

So What is MCP, Really?

Model Context Protocol was built to close that gap.

In plain language, MCP is a standard for connecting AI systems with the rest of your tech stack, tools, APIs, platforms, the lot. You don’t have to write unique integrations for every possible combination. Just expose your tools via MCP, and any agent that speaks that protocol can connect.

Think back to the early days of APIs. Before they were everywhere, developers spent ages stitching systems together, one by one. APIs changed everything. MCP wants to do the same for AI.

Instead of teaching every model the ins and outs of every platform, you hand them a reliable language for communicating. It’s more than just a technical tweak. It might change the playing field.

Why DevOps Teams Are Watching

Step into any DevOps shop and you’ll find a zoo of tools. Monitoring, CI/CD, multiple clouds, security scanners, container orchestration, ticketing, documentation, observability, you get the idea. The longer you wait, the more tools show up.

Usually, engineers bounce between these platforms. Sometimes, there’s automation, but often it’s just a patchwork of scripts and half-baked integrations.

AI agents offer something different. Now, instead of constantly switching tabs, you talk to your agent, and it works across your systems. Ask: “Why did deployment latency spike yesterday?” The agent fetches metrics, checks logs, reviews history, finds patterns, and even suggests solutions. All in one place.

That kind of cross-platform help only works if there’s a standard way to connect everything. That’s why DevOps teams care. MCP isn’t just about AI; it’s about making operational access smoother.

The Push Toward Agent-Driven Operations

AI agents are catching on, fast. People don’t just want chatbots anymore. They want real-world helpers: Bots that handle incidents, write infra code, manage resources, coordinate actions, and analyze what went wrong.

But agents aren’t magic. They always need context, access to data, and a clear way to use tools.

Without standards like MCP, integrating them is a pain and a maintenance nightmare. With it, you build connections that any agent can use, not just this month’s favorite chatbot.

As agent-driven ops take off, MCP, or something like it, becomes essential.

What Infrastructure Teams Need to Know

Infrastructure just keeps getting more complicated. Pieces live in the cloud, containers, vendor platforms, databases, APIs, you name it. Nobody can keep track of it all.

That complexity slows everything down. Chasing information across ten dashboards sucks up time. Knowledge stays siloed. Decision-making drags.

AI agents can help, but only if they can talk to your systems directly and safely. MCP gives them a consistent way in. For infrastructure teams, that could mean less time spent hunting for info, and more energy spent solving problems.

Security, Always a Factor

Whenever new tech hits DevOps, security worries follow. MCP’s no different.

Letting AI touch your operational systems isn’t something you do lightly. You need controls, permissions, authentication, clear audit trails, and good policies. It’s not all about features. Accountability has to be part of the conversation.

The bigger the agent’s power, the sharper your focus on what it’s allowed to do and why. That topic’s not going away.

A New Must-Have Skill

Engineers aren’t learning MCP for the trend; there’s real payoff. When containers mattered, people learned Docker. When the cloud took over, everyone learned AWS. When deployment speed became key, everyone learned CI/CD.

Now, as AI gets into the thick of real operations, knowing how these systems interact, in other words, understanding MCP, will set engineers apart. You don’t have to become an AI guru. But you do need to grasp the nuts and bolts of connecting smart agents to your infrastructure.

Looking Forward

DevOps isn’t just chasing faster releases or more automation anymore. The new era is about intelligent systems that actually work with the real world, reading context, helping you troubleshoot, and acting when you ask.

That means standardizing how agents and tools talk. MCP is getting attention because it might be the glue for the next wave of automation.

Final Thoughts

So what’s really happening? DevOps engineers are scrambling to learn MCP because AI is moving past simple Q&A, it’s getting ready to roll up its sleeves and work. Companies want tools that do things, not just talk about them. Making that happen takes a common protocol.

MCP might end up as the standard everyone uses, or maybe it won’t. But one thing’s clear: DevOps has moved beyond code generation. Now, it’s about turning intelligence into action.

And that’s why MCP is suddenly hard to ignore.

June 22, 2026
Tenet’s ‘Agentjacking’ Attack Turns Sentry Errors Into Code Execution

AI coding agents can create a new code execution risk when they treat externally influenced error data as trusted guidance and have access to command line tools, according to new research from Tenet Security.

The security company demonstrated an indirect prompt injection technique it calls “Agentjacking” in a recent report. In its proof of concept, an attacker planted malicious instructions inside a fake Sentry error report, causing an AI coding agent to execute an attacker-supplied command during a routine debugging task.

The attack began with a Sentry Data Source Name (DSN), a credential commonly embedded in a website’s frontend JavaScript. Sentry treats DSNs as public and write-only because they allow applications to submit events without granting access to the project or its existing data. But an attacker who obtains the DSN can use it to send a false error event to the project’s ingest endpoint and control fields, including the error message, stack trace, tags, context and breadcrumbs.

Tenet formatted the event so that, when retrieved through Sentry’s MCP server, it seemed like legitimate diagnostic guidance. It included headings, code blocks and a fake resolution section containing an npm command. When a developer asked the coding agent to investigate unresolved Sentry issues, the agent accepted the injected instructions as part of the debugging workflow and ran the command.

That command used npx to download and execute a Tenet-controlled package from the public npm registry with the developer’s local permissions. According to the researchers, the package checked what resources were accessible in the development environment, including environment variables, cloud configuration files, Git credentials and information about private repositories.

“What makes this attack unique is that it doesn’t target the developer directly – it targets the AI agent that the developer trusts,” the company wrote. The attacker does not need to compromise Sentry, contact the developer or access the developer’s machine directly because the malicious instructions enter through a public DSN and move through a normal debugging workflow. Because the injected content is formatted to resemble legitimate Sentry guidance, the agent cannot distinguish it from trusted diagnostic output.

Although indirect prompt injection is already a known risk for LLM applications, Tenet’s “Agentjacking” technique is notable because it shows how risk can emerge from the combination of tools available to an agent. Sentry’s MCP server retrieves error data but does not itself execute user-provided commands. In Tenet’s test, the coding agent used separate command-line access to run the instruction embedded in the event. Security teams may therefore need to assess an agent’s combined permissions and tool access rather than evaluating each integration alone.

Tenet said it identified 2,388 organizations whose Sentry DSNs accepted injected events, recorded an 85% success rate in its testing and observed more than 100 agent executions. Those figures do not represent 2,388 confirmed compromises, since exploitation still depends on an organization using an agent connected to Sentry and granting that agent command execution privileges. Also, Tenet’s claim that existing security tools cannot detect the technique is difficult to substantiate. Endpoint monitoring or controls like command approval, sandboxing, restricted network access and limited credentials could interrupt the attack or reduce its impact.

For DevOps teams, the case shows how externally influenced telemetry can become an attack channel when coding agents are connected to observability platforms, source code and command line tools. “The era of indirect prompt injection via developer tools has arrived,” the Tenet team said.

June 15, 2026
Microsoft Brings MCP to Geospatial Workflows With Planetary Computer Pro Tools for VS Code

Microsoft has added a new set of Model Context Protocol tools to the VS Code Marketplace, and they’re aimed squarely at developers and data engineers working with geospatial data. The Microsoft Planetary Computer Pro MCP Tools extension provides natural-language-driven access to geospatial workflows directly in Visual Studio Code — no context switching, no custom scripts, no specialized API knowledge required.

The extension is now available on the VS Code Marketplace, and it marks a meaningful step in how teams interact with large-scale environmental and geospatial datasets.

What It Does

The extension integrates directly with GitHub Copilot in VS Code, exposing 35+ tools that connect to both Microsoft Planetary Computer and Planetary Computer Pro. Through those tools, users can perform data ingestion, STAC search, GeoCatalog management, visualization, and ingestion monitoring — all through natural language prompts.

In practice, that means a developer can type a request like “find Sentinel-2 imagery for this region over the last 90 days,” and the MCP toolset handles the rest — querying the right catalogs, filtering results, and surfacing data without the user needing to know the underlying API structure.

Users can describe tasks conversationally, such as querying geospatial imagery, ingesting data, analyzing regions, or preparing datasets, and MCP translates those prompts into executable geospatial operations. This eliminates the need to write code or switch between tools, enabling faster iteration and tighter developer workflows.

The Problem it Addresses

Anyone who has worked with geospatial data pipelines knows the friction involved. Data lives across fragmented systems. APIs are specialized and require careful handling. Authentication flows add overhead. And stitching it all together typically requires custom code that has to be maintained over time.

Working with geospatial data today often requires navigating fragmented tools, managing specialized APIs across systems, and authentication — complexity that slows down workflows and increases the operational burden on teams.

The MCP extension tackles this by consolidating the major workflows — discovery, ingestion, catalog management, and monitoring — into a single interface inside the developer’s existing environment.

Key Capabilities

The toolset covers three primary areas:

STAC Search and Discovery: Users can search for data from an area of interest through an interactive map, spanning both Planetary Computer public datasets and Planetary Computer Pro GeoCatalog private datasets, enabling fast discovery of data across space, time, and metadata.

GeoCatalog Management: Users can create, configure, and manage STAC collections, move datasets from Planetary Computer, define rendering options like natural color or NDVI, and set up mosaics or thumbnails — all through conversational prompts. This eliminates the traditional complexity of API calls and manual configuration.

Data Ingestion: Data ingestion, often one of the most complex and time-consuming steps, becomes more manageable with MCP. Users can ingest data from Planetary Computer collections using simple prompts, with MCP handling the orchestration, monitoring, and status tracking of ingestion workflows — from a single item to bulk onboarding of entire datasets.

Why it Matters for DevOps Teams

The Planetary Computer Pro MCP extension is a clear signal that the MCP ecosystem is expanding beyond general developer tooling into domain-specific workflows. For DevOps teams supporting GeoAI and data engineering pipelines, this kind of integration reduces the operational surface area — fewer scripts to maintain, fewer manual steps in the pipeline, and faster onboarding for team members who aren’t geospatial specialists.

But it also raises important questions about governance. Mitch Ashley, VP and practice lead for software lifecycle engineering and AI-native software engineering at The Futurum Group, puts it plainly: “MCP is consolidating into the connective layer between AI agents and specialized backend systems, and this release elevates the protocol for use in domain-specific workflows. The protocol is becoming infrastructure rather than a convenience for agents. Every MCP server that an agent can reach opens a new path into production systems and data. Teams adopting these integrations must govern what agents query, ingest, and act on, because the integration surface is now a control and access concern.”

That’s a critical point. As MCP servers proliferate — each one opening a new connection into production data — access controls and observability can’t be an afterthought. The ease of integration is exactly what makes governance important.

As geospatial workloads continue to grow in scale and importance, simplifying access to these capabilities becomes critical. MCP enables Planetary Computer Pro users to move faster, lower barriers to entry, and unlock the full value of the platform without needing deep expertise in underlying systems or building special connectors to access various tools.

The Microsoft Planetary Computer Pro MCP Tools extension is available now on the VS Code Marketplace. Microsoft’s documentation and a full list of available tools are included on the install page.

June 1, 2026
Embracing the MCP Suck: Taming the Wild West of AI Protocols

The Model Context Protocol (MCP) is moving faster than the developer community can keep up with, racing past its original design parameters and leaving teams scrambling to build clients that can match its pace. The result is an ecosystem where the protocol itself keeps shifting under everyone’s feet, and where the tooling, conventions and security thinking that should accompany a foundational standard are still being figured out on the fly.

Joey Stout, solutions architect at Spacelift, joins Mike Vizard to make the case that this is the price of being early. Stout describes an environment that increasingly resembles a Wild West, where rogue MCP servers get spun up inside organizations without anyone in leadership knowing they exist, let alone whether they have basic guardrails wrapped around them. The convenience of standing one up in a few minutes has outrun the discipline needed to govern them.

MCP servers can give AI agents broad reach into internal systems, data and APIs, and most of the early implementations were never designed with adversarial behavior in mind. Without authentication standards, scoped permissions and observability built in, every new server becomes another piece of shadow infrastructure that can be exploited, misconfigured or simply forgotten until it causes a problem.

Stout’s advice for developers is blunt: embrace the suck. The protocol is going to keep changing, the security story is going to keep evolving, and waiting for a stable, fully governed version before getting hands-on isn’t a realistic option. The teams that learn to wrangle MCP now — messy edges and all — will be the ones positioned to set the patterns everyone else ends up following.

April 27, 2026
SUSE Extends AI Agent Reach via MCP Server Integration

SUSE today revealed it is collaborating with multiple providers of artificial intelligence (AI) agents with the ability to manage IT infrastructure resources via integrations with the Model Context Protocol (MCP) server embedded in its platforms.

Announced at the SUSECON 2026 conference, AI agents from Fsas Technologies, n8n and Revenium, Stacklock and Amazon Web Services (AWS) can invoke the MCP server that SUSE has embedded in its Rancher Prime and SUSE Multi-Linux Manager offerings.

Rick Spencer, general manager, engineering at SUSE, said that capability makes it possible, for example, for the Amazon Quick AI agent that AWS developed to automate workflows for managing IT infrastructure resources such as Linux servers and Kubernetes clusters.

Ultimately, any AI agent that can access the SUSE MCP server should be able to, for example, identify system faults in Kubernetes clusters or Linux servers, correlate system logs, and submit a pull request (PR) or a patch to restart a service or apply updates.

The goal is to provide a secure way for AI agents to monitor, troubleshoot and optimize infrastructure across any distribution of Linux or Kubernetes using SUSE Multi-Linux Manager or the Rancher Prime management platform, said Spencer. Included in the MCP servers developed by SUSE are a set of AI engineering skills that make it possible to manage Linux servers and Kubernetes clusters, he added.

Mitch Ashley, vice president and practice lead for software lifecycle engineering at the Futurum Group, said infrastructure platforms are evolving into agent-accessible substrates. Platform evaluations must now weigh MCP surface depth alongside management features because every action exposed through MCP becomes a potential autonomous change made to a production environment, he added.

The degree to which organizations will enable AI agents to manage IT infrastructure will naturally vary by use case but it’s clear that with the advent of MCP, not every platform is going to require its own dedicated AI agent. In some instances, an AI agent developed by a third-party will simply invoke MCP to automate a task. In other instances, however, an AI agent might communicate with another AI agent that has been specifically trained to perform IT infrastructure tasks.

Regardless of approach, the days when IT teams relied on graphical tools to manage IT environments are coming to an end, said Spencer. Instead, IT teams will use natural language interfaces to instruct AI agents to perform specific tasks, he added.

In the meantime, MCP itself remains a work in progress. The next iteration of MCP will enable IT teams to deploy stateless servers that will make it easier to deploy AI tools and applications at higher levels of scale. The technical oversight committee for MCP, now being advanced under the auspices of the Agentic AI Foundation (AAIF), is also working on a task capability that will make it easier to run long-running autonomous workflows versus continuing to rely on a request and response mechanism that would otherwise need to be re-invoked multiple times.

Additionally, maintainers of the MCP project are working on adding a triggers capability that will enable servers to initiate an action, rather than always having to rely on an MCP client. Support for retry semantics, expiration policies, native streaming and reusable skills that are based on domain knowledge are additional capabilities that are expected to be added in 2026.

Finally, updates to the Python and TypeScript software development kits (SDKs) will provide access to more efficient MCP clients and servers.

In the meantime, DevOps teams should expect the number of AI agents that can manage IT infrastructure to rapidly proliferate in the days and months ahead.

April 22, 2026
DBmaestro Introduces Agentic Database DevOps with MCP Server
Transforming Natural Language into Governed Platform Workflows

Orlando, FL, April 7, 2026 – DBmaestro, the leading database DevSecOps platform, today announced the launch of its Model Context Protocol (MCP) server, making DBmaestro the first database DevOps platform purpose-built for agentic AI workflows.

The DBmaestro MCP server exposes the company’s industry-leading database release automation, source control, CI/CD orchestration, and compliance capabilities to AI agents and enterprise copilots. Teams can now use natural language to trigger real DBmaestro workflows – automating project creation, multi-environment deployments, package management, and release orchestration – while preserving enterprise governance, role-based access control, and full auditability.

“DBmaestro MCP turns our enterprise-grade database DevOps platform into an agentic operational layer for AI,” said Gil Nizri, CEO of DBmaestro. “DBAs and DevOps engineers can now interact in natural language to accelerate repetitive tasks, while AI becomes the interface to deterministic, governed workflows. This is not replacing database expertise – it’s amplifying it with enterprise-grade control.”

Key capabilities include:
- Agentic Database DevOps: AI agents execute complex database operations across dev, QA, and production environments
- Natural Language Workflows: Prompts such as “Create an MsSQL release pipeline with Dev/QA/Prod environments, and update Dev and QA to the latest version” become real platform execution
- Enterprise Governance: Role-based permissions, compliance tracking, and full audit trails remain intact
- Deterministic Reliability: AI accelerates setup and self-service while engineers retain control over critical paths
As IBM’s strategic OEM partner for database release automation, DBmaestro MCP extends this leadership into the agentic era, enabling organizations to scale database delivery while maintaining the security and compliance standards enterprises demand.

“Every enterprise adopting AI agents needs secure, governed access to their core platforms,” said Yaniv Yehuda, DBmaestro Founder & CPO. “DBmaestro’s MCP implementation shows how database DevOps can evolve from manual processes to agent-driven automation without sacrificing control.”

The DBmaestro MCP server is available immediately to all customers and partners. For more information, visit https://www.dbmaestro.com/ai/dbmaestro-mcp-server

About DBmaestro

DBmaestro is a leading provider of Agent-Governed database DevOps and release automation, enabling CI/CD for databases with controlled, auditable change management. The platform extends DevOps to the database layer with built-in compliance, observability, and governed AI execution, including MCP-based workflows for natural-language operations and intelligent troubleshooting under enterprise control. As IBM’s strategic OEM partner, DBmaestro powers database release automation in some of the world’s most complex and regulated environments and augments DevOps, automation, and governance solutions. Learn more at www.dbmaestro.com.

###
Media contact
Ben Gross
+972-50-8452086
beng@dbmaestro.com
April 7, 2026
Anthropic Extends Claude Code Into Messaging Apps, Challenging OpenClaw’s Lead

Anthropic has debuted a new capability for its Claude Code platform, called Channels, that enables a number of key improvements. Notably, it allows users to communicate with the coding assistant through messaging platforms like Telegram and Discord. More important, Channels is continuously available, so it is closer to an active collaborator.

Clearly, Anthropic’s release of Channels is competitive move to keep pace with OpenClaw, an open-source project that has gained massive traction since its launch in late 2025. OpenClaw popularized the concept of persistent AI agents, systems that remain active and responsive, capable of receiving instructions and completing tasks asynchronously through familiar chat applications. With Channels, Anthropic is adopting a similar model while emphasizing tighter controls and a more structured user experience.

Using MCP

With Channels, developers can send instructions to Claude Code from a mobile device and receive updates when tasks, such as debugging or code compilation, are completed. This reduces reliance on fixed workstations and allows for a more continuous workflow. The change also moves from traditional prompt-and-response interactions toward a more ongoing relationship between user and system.

Underlying this shift is Anthropic’s MCP, an open standard designed to connect AI models with external tools and data sources. Within the Channels framework, MCP acts as a bridge, enabling messages from external platforms to feed directly into an active coding session. Once a request is received, Claude Code performs tasks and returns results through the same messaging channel.

This architecture enables persistence, a feature that has been central to OpenClaw’s appeal. Instead of requiring users to initiate each session manually, the system can remain active in the background, waiting for new instructions. For developers, this means the AI assistant functions less like a tool and more like a continuous collaborator.

Anthropic’s approach also addresses concerns about autonomous agents. OpenClaw and similar tools often require extensive access to local systems, raising worries about data security and system integrity. In some regions, these concerns have prompted restrictions on their use in government or business environments. Anthropic, by contrast, is positioning Claude Code as a more controlled alternative, with admin oversight and safeguards like approved communication channels and restricted sender lists.

Intense Competition

The competitive landscape is evolving faster than you can say AI agent. OpenClaw’s open-source model has led to a swarm of variants, including projects aimed at improving usability and reducing risk. At the same time, major tech firms are exploring similar agent-based systems, so persistent AI assistants will become a standard interface for software development.

Anthropic’s release also highlights a major trend: the blending of proprietary AI systems with open standards. While Claude Code itself remains a commercial product, the use of MCP allows external developers to build integrations and extend functionality. This hybrid approach enables ecosystem growth without giving up control over the core technology.

Early reactions from the developer community suggest that the update could reduce the need for complex, self-hosted solutions that have been required to run persistent agents. By integrating these capabilities directly into a managed platform, Anthropic is lowering the barrier to entry for less technical users while retaining appeal for experienced developers.

March 23, 2026
MCP-Powered Agentic AI in DevOps: Building Secure, Scalable Multi-Agent Pipelines for Autonomous SRE and Observability
The next evolution in DevOps isn’t just about automation, it’s about autonomous intelligence. As organizations scale their cloud-native infrastructure, traditional monitoring and incident response approaches are reaching their breaking point. Enter model context protocol (MCP) powered agentic AI: A paradigm shift that transforms how we build, deploy and maintain resilient systems through collaborative AI agents.

The Challenge: Complexity Outpacing Human Capacity

Modern DevOps teams manage thousands of microservices across multiple clouds, each generating terabytes of telemetry data daily. Traditional site reliability engineering (SRE) practices, while valuable, struggle with:
- Alert fatigue from thousands of non-actionable notifications
- Context switching between dozens of monitoring tools
- Manual investigation during critical incidents
- Knowledge silos when senior engineers are unavailable
The result? Mean time to resolution (MTTR) continues climbing even as organizations invest heavily in observability tools.

Enter MCP: The Foundation for Agentic DevOps

MCP emerged as the ‘USB-C for AI’, a standardized way for AI models to securely interact with external tools and data sources. Unlike traditional API integrations requiring custom code for each connection, MCP provides a universal protocol that any AI agent can use to:
- Access infrastructure APIs without exposing credentials
- Execute predefined operations within security boundaries
- Share context across multiple specialized agents
- Maintain audit trails for compliance requirements
This protocol enables what was previously impossible: Multiple AI agents working together as a coordinated team, each specializing in various aspects of the DevOps life cycle.

Building Multi-Agent SRE Teams

An MCP-powered agentic architecture creates specialized AI agents that collaborate like expert team members:

The Orchestrator Agent

It serves as the team lead, receiving high-level objectives such as ‘maintain 99.9% availability for payment services’. It breaks these goals into specific tasks, delegates to specialized agents and coordinates their activities while maintaining situational awareness across the entire system.

The Observability Agent

It specializes in telemetry analysis, connecting to your existing monitoring stack through MCP servers. Instead of drowning engineers in raw metrics, it provides contextual insights: ‘CPU utilization spike correlates with increased database connection pool usage, suggesting a connection leak in microservice X’.

The Remediation Agent

It focuses on safe, automated responses to common issues. Through MCP, it accesses your runbook library and executes predefined remediation actions, rolling back deployments, scaling resources or restarting services, while maintaining human oversight for critical changes.

The Security Agent

It monitors for anomalous behavior patterns that might indicate security incidents. Using MCP to access vulnerability databases and security scanning tools, it can automatically patch low-risk vulnerabilities or escalate high-risk findings to human security teams.

Real-World Implementation Patterns

Organizations implementing MCP-powered agentic systems report dramatic improvements:

Incident Response: A fintech company reduced MTTR from 45 minutes to under 5 minutes by deploying agents that automatically correlate alerts, identify root causes and execute remediation playbooks, all while keeping humans in the loop for approval on production changes.

Capacity Planning: E-commerce platforms use prediction agents that continuously analyze traffic patterns and automatically scale infrastructure hours before predicted demand spikes, reducing costs while maintaining performance.

Security Posture: SaaS companies deploy agents that continuously scan for vulnerabilities, automatically apply low-risk patches during maintenance windows and coordinate with security teams for complex remediation efforts.

Security and Governance Considerations

The autonomous nature of agentic AI requires robust security frameworks:

Principle of Least Privilege: Each agent receives only the MCP permissions necessary for its specific role. The remediation agent cannot access customer data; the observability agent cannot modify infrastructure.

Human-in-the-Loop Design: Critical operations require human approval. Agents present recommended actions with confidence scores and potential impact analysis before execution.

Audit and Compliance: MCP maintains detailed logs of all agent activities, creating audit trails that satisfy regulatory requirements while providing transparency into autonomous operations.

Circuit Breakers: Automatic fail-safes prevent agents from taking actions that could cascade into larger outages. If an agent’s remediation attempts fail repeatedly, the system automatically escalates to human engineers.

Getting Started: Practical Implementation

Organizations need not rebuild their entire DevOps stack to benefit from agentic AI. Start with these proven approaches:

Phase 1 – Observability Enhancement: Deploy a single observability agent to analyze existing monitoring data and provide contextual insights. This low-risk introduction demonstrates value while building organizational confidence.

Phase 2 – Automated Remediation: Add remediation capabilities for well-understood, low-risk issues such as certificate renewals, service restarts or configuration updates. Maintain human approval gates for all production changes.

Phase 3 – Multi-Agent Orchestration: Introduce specialized agents for security, performance and capacity planning of different domains, coordinated through an orchestrator agent that manages complex workflows.

Phase 4 – Predictive Operations: Deploy agents that learn from historical patterns to prevent issues before they occur, moving from reactive to proactive operations management.

The Future of Autonomous DevOps

As MCP adoption grows, we’re witnessing the emergence of truly autonomous operations — where human engineers focus on innovation while AI agents manage routine operations. Early adopters report 70% reductions in manual interventions and 50% improvements in system reliability.

The key to success lies not in replacing human expertise but in augmenting it, creating human-AI teams that combine the creativity and strategic thinking of experienced engineers with the tireless precision of autonomous agents. Organizations that embrace this paradigm shift today will gain significant competitive advantages in tomorrow’s digital landscape.

The future of DevOps isn’t just automated — it’s intelligent, collaborative and autonomous. MCP-powered agentic AI makes that future accessible today.
February 4, 2026
Perforce Adds MCP Support Across Entire DevOps Portfolio

Perforce Software is making the Model Context Protocol (MCP) that artificial intelligence (AI) tools and agents invoke to access data available across its entire portfolio of DevOps platforms.

Jake Hookom, executive vice president of product for Perforce, said the code management, application testing and infrastructure management tools and platforms the company provides will now all be accessible to any AI tool or agent.

The overall goal is to make it simpler for DevOps teams to safely incorporate AI into their existing DevOps workflows, he added. That approach makes it possible to extend existing controls, traceability, and security into workflows that are being augmented by AI in a way that minimizes any additional risks that might be created, said Hookom.

Originally developed by Anthropic, MCP is now being advanced under the auspices of the Agentic AI Foundation, a newly created arm of the Linux Foundation. It is rapidly becoming a de facto open source standard for connecting AI applications to external systems to enable an AI agent to, for example, perform actions using current data rather than only data that the large language model (LLM) they depend on was trained on.

Additionally, MCP also makes it simpler for organizations to swap out AI agents and large language models (LLMs) as they best see fit, noted Hookom.

It’s not clear how pervasively AI tools and agents are being embedded into DevOps workflows, but a recent Futurum Group survey finds 60% of respondents said their organization is now actively using AI to build and deploy software. Overall, top areas of investment are AI Copilot/AI code tools (38%), AI agent development (37%), AI-assisted testing (37%) followed closely by DevOps (37%), automated deployment (34%), software security testing (31%).

Each DevOps team is, of course, adopting AI tools as they best see fit depending on the level of trust they have in the output being generated. In fact, the latest generation of AI tools are already taking advantage of more advanced reasoning capabilities to significantly improve the quality of the code being generated, noted Hookom. As the cost of using those tools inexorably declines, the next challenge will then be determining to what degree to enable an AI agent to autonomously perform an action either on behalf of an individual developer, engineer or the entire DevOps team, added Hookom.

The most important thing is to develop an overall strategy now versus randomly adding AI coding tools that lack the context enabled by, for example, providing access to the most relevant data via an MCP server, he added.

While adoption of AI currently remains uneven, the one thing that is certain is that as the number of silos that make up the software development lifecycle (SDLC) is reduced or outright eliminated using AI the more collaboration there will inevitably be, said Hookom.

Ultimately, it won’t be too long before every DevOps tool and platform becomes accessible via a, hopefully, secure implementation of an MCP server or client. The challenge and the opportunity might then become determining how best to organize a DevOps team when many of the silos that led to the creation of one bottleneck or another are finally eliminated.

February 3, 2026