Building the future: Core concepts of Red Hat’s agentic software development life cycle

When integrating AI into your software development processes, the methodology you use to build software is as important as the models themselves. At Red Hat, we believe the true value of AI emerges when it is integrated into transparent, scalable, and reliable enterprise workflows. We're moving beyond traditional development practices toward a new agentic software development life cycle (SDLC). 

Within Red Hat AI Engineering, this approach treats AI agents not as isolated, automated tools, but as active, collaborative participants in the development lifecycle—helping drive progress from the initial request for feature enhancement (RFE) to final shipment. Grounded in our commitment to operational excellence, this blog post introduces the fundamental principles behind our agentic SDLC, creating a robust framework for the management, monitoring, and expansion of agent-driven development. 

The central management layer: Org Pulse

Built on Red Hat OpenShift AI, Org Pulse serves as the "source of truth" for the AI Engineering organization. Using Red Hat OpenShift's reliable infrastructure allows the dashboard to provide live visibility into what the system is doing, so we can track baselines and measure improvements in real time. 

Org Pulse serves several critical functions within our engineering workflows:

• Metric tracking: Org Pulse aggregates historical data directly from Jira to measure the impact of agentic SDLC performance. This data is contextualized with additional contribution activity pulled from GitHub and GitLab to provide a comprehensive throughput baseline. This baseline compares planned story points against the team's past throughput. This helps us spot overcommitment early, sharpen release accuracy, and track how AI affects team velocity.
• Release and team visibility: It allows leaders and teams to see exactly where a feature stands, identify bottlenecks, and understand the status of releases without searching through different reports.
• Steering infrastructure: As part of our "on the loop" approach, Org Pulse provides the dashboarding needed for humans to effectively steer the system. It surfaces critical information at the exact moment when intervention is required, distinguishing it from traditional "in the loop" processes where humans are required for every iterative step in a workflow. 

By treating the SDLC itself as a product that can be instrumented and improved, Org Pulse helps us to scale our AI-first development program with confidence.

The end-to-end workflow

Our agentic SDLC is designed as an autonomous end-to-end workflow. By integrating automated agents into each stage of development, we aim to streamline the transition of features from initial  business requirement to shippable software. 

Humans are actively involved in the initial feature definition phase to verify the accuracy and completeness of the feature specification. Once that human intent is approved, our agentic SDLC pipeline is designed to operate autonomously, scaling the heavy lifting until it requires a final engineering review on the closing pull request (PR). 

The pipeline is structured into 4 major operational phases: 

1. Plan: This stage begins with an RFE. These high-level requirements are analyzed, decomposed into technical strategies, and further broken down into actionable Epics. This makes sure that every engineering activity is grounded in a clear "what," "why," and "how."
2. Build: This is where codebase implementation and active review occur. In this phase, agents act as critical force multipliers for our developers—generating initial code drafts, performing automatic fixes, and directly assisting engineers in maintaining high code quality. 
3. Verify: Rigorous testing and architectural integration are baked into the pipeline. This phase uses automated test plan generation and continuous evaluation gates, which assess whether emerging features meet our definition of "ready for release."
4. Ship: The final stage focuses on build system onboarding, documentation, final portfolio integration testing, and the actual release cadence. By automating these traditionally manual steps, we significantly increase velocity and minimize overall time-to-market.

The "on the loop" philosophy

The most significant cultural and operational shift in our program is the transition from "in the loop" to "on the loop" development. To understand the impact of this evolution, it helps to contrast how the 2 structures operate: 

• In the loop: In traditional processes, a human gates every single step of the pipeline. While safe, this creates bottlenecks and limits the ability to scale.
• On the loop: Here, the system runs autonomously, and humans act as pilots. We steer the process at critical gates rather than manually approving every minor action. 

Under an "on the loop" model, the system alerts engineers when intervention is required. This philosophy allows our engineering teams to focus their expertise on high-value strategic decisions, leaving the repetitive, manual tasks to the autonomous system. 

The evolving role of the engineer

This shift doesn't diminish the engineer's role—it elevates it. The work that has historically consumed the most time (implementation, boilerplate, manual review) is increasingly handled by the autonomous pipeline. 

That gives engineers more time to go deeper on the work that drives the most value:

• Understanding customer problems: Focusing deeply on core user needs and challenges.
• Shaping solutions: Designing architectures to fit real-world constraints.
• Exercising domain judgment: Applying the unique insights that no pipeline can provide on its own.

Engineers are the stewards of our products. They set direction, validate that what we're building maps to genuine customer needs, and work to ship solutions that create real impact. The agentic SDLC accelerates delivery of the right solutions, while engineers define what "right" means.

Engineering reliable agents

Trust is a prerequisite for automation. We don't simply let agents run unchecked,  we build reliability into the foundation of our agentic workflows through 3 core principles:

1. Constrain, then trust: We apply deterministic guardrails. This allows us to focus model creativity where it provides the most value, while simultaneously enforcing hard limits that the model can't override.
2. Adversarial review: Our core design philosophy dictates that nothing should review its own work. By strictly separating generation from review, we reduce anchoring bias and maintain a significantly higher standard of quality.
3. Evaluations gate every change: Before any code ships or an agent skill is updated, it must pass through an evaluation harness grounded in real-world datasets. This rigorous gating catches regressions early and makes sure that agent updates consistently improve—rather than degrade—overall system performance.

Looking ahead

The AI Engineering agentic SDLC is a living system. It will continue to evolve as we refine our agentic workflows, build in new skills, and integrate feedback from across the organization.

 This framework—built on the pillars of end-to-end automation, human-on-the-loop steering, and rigorous agent reliability—is designed to help us build better software, faster.

As we move forward, we'll continue to dive deeper into these core components, providing more detailed insights into the engineering and operational strategies that make this new kind of software development lifecycle possible.