Getting approval for a conference is easier when the conversation is not about attending sessions, but about what the team gets back from the investment.
That is especially true for DevOpsCon New York 2026. This year’s program comes at a point when many engineering organizations are deciding how AI agents should interact with delivery pipelines, internal developer platforms, infrastructure, security controls, and production environments.
The question is no longer simply whether AI belongs in DevOps. It is how to introduce agentic systems without adding security risk, cloud cost, unstable automation, or a new layer of DevOps debt.
That is the business case for attending DevOpsCon New York 2026.
Want to make that case internally? Download the DevOpsCon New York 2026 Participation Business Case and forward it to your team lead.
Why attend DevOpsCon New York 2026?
DevOpsCon New York 2026 focuses on a practical challenge engineering teams are facing now: how to integrate AI agents into platforms and delivery workflows while keeping those systems governed, observable, secure, and reliable. The program connects agentic AI with the existing disciplines of DevOps, platform engineering, DevSecOps, CI/CD, Kubernetes, software supply chains, and observability.
For an attendee, the goal is therefore more concrete than simply “learning about AI.”
The takeaway should be a governed approach for deciding where agents belong in the delivery lifecycle, what controls they need, and which parts of the platform need to be fixed before agentic automation is introduced.
For the wider engineering team, that knowledge can support a deliberate adoption path instead of allowing isolated AI experiments to spread independently across pipelines and platforms.
What makes the 2026 edition different?
DevOpsCon New York 2026 introduces a dedicated AI Platform Engineering Day, focused on the shift from adding individual AI features to operating platforms in which humans and AI agents both become participants.
The day includes The Leader’s Role in Orchestrating AI-Native Platforms, a practitioner roundtable on responsible scaling, Moonwalking the DevOps: When Every Step Forward Slides You Back, and Every Eng a CTO: Technical Leverage in the Agentic Organization.
Together, these sessions address an important engineering question: what needs to be true about a platform before AI agents are allowed to operate on it?
The emerging principle is straightforward. A platform should be deterministic, observable, and governed before non-deterministic agents are added on top of it.
Otherwise, more automation can create the appearance of progress while quietly increasing fragility.
Why should teams finish the platform before they “agentify” it?
AI agents can amplify both good automation and bad automation. If the underlying platform has unclear workflows, weak observability, inconsistent controls, or unresolved manual processes, adding autonomous behavior can make those weaknesses propagate faster.
That is the problem behind the “moonwalking” metaphor in the program: a team may appear to be moving forward while accumulated fragility causes it to slide backward.
The takeaway is not to avoid AI. It is to establish the platform fundamentals that allow agents to operate safely.
That means understanding existing platform state, making actions observable, defining deterministic controls around non-deterministic behavior, and deciding which decisions an agent may make independently.
The business value: AI adoption becomes an engineering decision with defined prerequisites rather than another layer of automation added to unfinished foundations.
How does an internal developer platform need to change for AI agents?
An internal developer platform designed for humans may not automatically be safe for software agents. Humans pause, interpret warnings, ask questions, and recognize when a workflow produces an unexpected result; agents may continue acting on a response that appears to indicate success.
The DevOpsCon session Your IDP Has a New User. It Wasn’t Designed for Them examines these failure modes and the controls required to address them.
The program points toward machine-checkable contracts, explicit state machines, intent tokens, and full lineage so that actions can be understood and traced rather than inferred.
The End of Documentation: An MCP-Based “Living” Platform approaches the same problem from another direction. Instead of forcing agents to infer operational context from static documentation, an MCP-based platform can expose machine-readable context together with an intent trace for actions.
The implication is significant: AI agents are becoming a new class of platform user.
They need interfaces, permissions, context, and controls designed for machine behavior rather than human assumptions.
What security risks do AI agents and MCP servers introduce?
AI agents and MCP servers create additional interfaces through which credentials, tools, workloads, and production resources may be accessed. If an autonomous agent has excessive permissions or long-lived credentials, errors can propagate much faster than they would through a manual workflow.
Several DevOpsCon New York sessions approach this problem as a zero-trust and software-supply-chain challenge.
Agents and MCP Servers: Are the Electric Sheep Safe? explores MCP endpoints as potential supply-chain pivots and covers controls including mTLS, isolation, and provenance checks.
When AI Loses Context: A Zero Trust Blueprint for AI Agents in Kubernetes looks at just-in-time ephemeral credentials and a “Two-Brain” pattern in which destructive writes are routed through human approval.
AI Broke AppSec — Rethinking Security in the Mythos Era addresses risk-based triage for AI-amplified code churn and the use of provenance metadata for generated artifacts, while Zero to AI-Ready in One Day: Securing Citizen Development & Agentic AI covers tiered profiles, sandboxing, and prompt-injection prevention.
The common principle is simple: the faster an agent can act, the more important its boundaries become.
How can teams use AI in the delivery pipeline without creating DevOps debt?
AI can increase the volume and speed of software changes, but faster code generation does not automatically mean faster or safer delivery. As change volume increases, validation, release-risk assessment, provenance, and testing can become the new bottlenecks.
DevOpsCon New York approaches this problem through controlled automation rather than unrestricted acceleration.
AI-Accelerated Delivery: Predicting Release Risk Before Production examines scoring releases using commit, churn, and test signals, then routing higher-risk releases into canary rollout and human review.
The Bottleneck in AI-Driven Delivery: Scaling Validation focuses on keeping validation inside the sprint through masked production data, synthetic data, and agentic testing.
And Don’t Let AI Become Your Next Source of DevOps Debt brings software-composition and provenance checks closer to the point where AI-generated code is created.
The message for engineering leaders is important: AI-generated velocity only creates value when validation and risk controls can operate at the same speed.
Otherwise, increased development output can simply move the cost downstream into failures and rollbacks.
What should teams expect from AIOps?
DevOpsCon New York also looks critically at the gap between AIOps promises and operational reality. The session What 105 Research Papers Got Wrong About AIOps presents a five-level maturity model and a vendor-vetting checklist, including the recommendation to test auto-remediation in shadow mode before allowing it to act autonomously.
That provides a useful principle for wider agentic DevOps adoption.
Teams do not need to move directly from manual operations to autonomous execution. They can introduce agents progressively: first in a sandbox, then in shadow mode where recommendations can be observed, and finally behind defined gates when the behavior has proved reliable.
In other words, autonomy can be earned rather than assumed.
Can governance actually make delivery faster?
Governance is often treated as something that slows software delivery down. The sessions at DevOpsCon New York show a different model: controls can be embedded directly into delivery systems so that governance becomes part of the normal workflow instead of a separate approval process.
The session Governed by Design presents a regulated Microsoft data-platform case in which embedded CI/CD controls and observability were associated with a 55% reduction in release time and a 40% reduction in compute cost.
Compliance-Driven CI/CD Pipelines for Cloud-Native Delivery covers policy-as-code gates, artifact lineage, and content-addressable storage. Endless Runner — Agentic Pipelines for an OS Supply Chain adds Sigstore signing, SLSA Level 3 verification, and human-in-the-loop escape hatches.
Meanwhile, Seeing the Invisible — Microservices Observability looks at OpenTelemetry and Linkerd tracing to help ensure agent-driven changes remain debuggable and reversible.
The broader lesson is that governance does not have to sit outside the delivery pipeline. When controls, lineage, and observability are built into the platform, engineering teams can gain speed and control at the same time.
What does the rest of the team get from one person attending?
The value of attending DevOpsCon should not end when the conference closes. The strongest business case is one that turns an individual ticket into reusable knowledge for the wider engineering organization.
A practical post-conference commitment could include:
- A prioritized recap mapped to the team’s existing pipelines, platform, and clusters.
- An internal technical session covering agent safety, governance, observability, and delivery patterns.
- A shared agentic DevOps adoption plan following a sandbox → shadow → gated progression.
- Continued use of available session recordings in the months after the event when relevant projects and architectural decisions arise.
This changes the ROI calculation.
The organization is not only paying for one engineer to attend a conference. It is investing in a structured transfer of current platform-engineering and agentic-DevOps practices back into the team.
What else is covered at DevOpsCon New York 2026?
Agentic AI is a major theme of the 2026 program, but it sits inside a broader DevOps and platform-engineering agenda.
The program also includes hands-on Kubernetes content, Open-Source AI bootcamps, and DevOps and DevSecOps workshops, giving attendees opportunities to go deeper in areas that connect directly to their current responsibilities.
That matters because introducing AI agents safely is not an isolated AI problem.
It depends on the quality of the systems underneath them: CI/CD, Kubernetes, security, platform engineering, software supply chains, governance, and observability.
So, what is the business case for DevOpsCon New York 2026?
The case is not simply that AI is changing software development.
It is that engineering teams now have to make concrete architectural decisions about where agents can act, what they can access, how their actions are validated, how generated artifacts are traced, and when humans must remain in the loop.
DevOpsCon New York 2026 brings those questions together across platform engineering, DevOps, security, delivery, governance, and observability.
For the attendee, the goal is to return with a clearer framework for integrating agents into the delivery pipeline and platform safely.
For the team, the goal is to capture the benefits of agentic DevOps without discovering the security, reliability, cloud-cost, and technical-debt consequences after those agents are already operating in production.
And for the team lead deciding whether to approve the trip, that is the most useful question to ask:
Would we rather develop our approach to agentic DevOps deliberately — or work it out after the risks have already reached our production systems?
Ready to make the case to your team lead?
Download the DevOpsCon New York 2026 Participation Business Case and use it to start the conversation about your ticket, travel, and accommodation.
