Agile software development methodologies rely on effective requirements management to maintain alignment between evolving business needs and delivered functionality. This article investigates the integration of Large Language Models (LLMs) into five widely used Agile frameworks: Scrum, Kanban, Extreme Programming (XP), the Scaled Agile Framework (SAFe), and Lean Software Development with a focus on enhancing requirement capture, refinement, prioritization, traceability, and feedback processing. For each methodology, the study maps specific LLM capabilities to native workflow stages, illustrating opportunities for automation and augmentation without undermining core Agile principles. The findings demonstrate that LLMs can reduce ambiguity, accelerate refinement cycles, and strengthen stakeholderdeveloper collaboration, while also highlighting risks such as hallucinations, bias, and data privacy concerns. The article concludes that effective integration requires tailored strategies, human oversight, and alignment with organizational priorities, and identifies future research directions including domainspecific fine-tuning and long-term impact evaluation.
Effective requirements management is one of the most critical success factors in software
development [
Recent advances in Large Language Models (LLMs), such as GPT-4, Claude, and other
transformer-based systems, have created new opportunities to address these challenges. Trained on
vast amounts of text data, LLMs excel at understanding, classifying, summarizing, and generating
natural language. These capabilities position them as promising assistants in the requirements
engineering process – from transforming raw stakeholder input into structured backlog items, to
maintaining requirement quality across the entire development lifecycle. The integration of
artificial intelligence and data science approaches in software development [
This article explores methods for integrating LLMs into requirements management processes
within five Agile methodologies: Scrum, Kanban, Extreme Programming (XP), the Scaled Agile
Framework (SAFe), and Lean Software Development. For each methodology, we map LLM
capabilities to native workflow stages, propose concrete enhancement points, and illustrate the
changes using process diagrams. The goal is to identify integration strategies that deliver
measurable value – such as reduced ambiguity, faster backlog preparation, improved prioritization,
and better traceability – while respecting the core principles of each methodology and established
software quality frameworks [
While the potential of LLMs in Agile requirements management is significant, their adoption
requires careful consideration of risks, including hallucinated outputs, embedded bias,
overreliance on automation, and data confidentiality concerns. As such, this study emphasizes
humanin-the-loop approaches, where LLMs augment but do not replace human judgment in
qualitycritical decisions [
The findings contribute both to the theoretical understanding of AI-assisted requirements engineering and to its practical application in Agile settings. They provide a foundation for future research into domain-specific fine-tuning, integration into project management tools, and empirical studies on productivity and quality outcomes.
Agile software development encompasses a variety of frameworks, each with its own philosophy, workflow structure, and approach to managing requirements. Although the Agile Manifesto emphasizes “working software over comprehensive documentation” and “responding to change over following a plan,” requirements remain central to ensuring product success. Understanding how requirements are gathered, refined, and maintained across different Agile methods is a prerequisite for identifying effective Large Language Model (LLM) integration points. 2.1.
Kanban’s visual and continuous approach allows for rapid adaptation to change but relies heavily on the quality of requirement intake and ongoing communication to ensure clarity. 2.3.
XP emphasizes technical excellence, continuous integration, and frequent releases.
Requirements are often represented as story cards discussed directly with an on-site customer. This
method integrates requirement specification tightly with automated testing, using practices such as
test-driven development (TDD) [
The stages of the Extreme Programming pipeline are shown in Figure 3.
Extreme Programming Pipeline includes following stages:
Stage 1 - Planning Game, where customer and team collaborate to define user stories and release planning.
Stage 2 - Design Simply: Create the simplest design that works, using metaphors and CRC cards. Stage 3 - Write Tests First: Create unit tests before coding.
Stage 4 - Code in Pairs: Implement code with pair programming.
Stage 5 - Continuous Integration: Integrate and test frequently.
Stage 6 - Listen and Adapt: Gather feedback from running software and adjust stories accordingly.
XP’s lightweight, test-first approach to requirements promotes rapid responsiveness to customer needs while maintaining high-quality standards through continuous testing. 2.4.
SAFe (Scaled Agile Framework) is the world's leading framework for implementing Agile
practices at enterprise scale, created by Dean Leffingwell in 2011 to address the challenge of
coordinating multiple Agile teams across large organizations while maintaining the flexibility and
responsiveness of traditional Agile methods [
SAFe Pipeline stages are shown in figure 4.
Stages of SAFe are: Stage 1 – Portfolio Strategy - define portfolio epics and strategic themes at the portfolio level. Stage 2 – Solution Planning - break down portfolio epics into capabilities and program epics. Stage 3 – Program Planning - decompose capabilities/epics into features during PI planning.
Stage 4 – Team Execution - break features into stories and execute in iterations within Program Increments.
Stage 5 – Continuous Delivery - deliver value incrementally across ARTs with regular inspect and adapt cycles.
SAFe provides a structured yet flexible approach to scaling Agile beyond individual teams. By organizing work hierarchically from strategic portfolio epics down to implementable user stories, and coordinating delivery through Program Increments and Agile Release Trains, SAFe enables large organizations to maintain Agile's benefits – rapid response to change, continuous improvement, and customer focus – while providing the coordination and governance needed at enterprise scale.
The framework's emphasis on alignment, transparency, and continuous delivery makes it particularly valuable for organizations building complex products that require coordination across multiple teams, departments, and even business units. With over 20,000 organizations worldwide using SAFe, it has proven its effectiveness in helping enterprises achieve business agility in today's rapidly changing market conditions. 2.5.
Lean emphasizes eliminating waste and delivering maximum value to the customer as quickly
as possible. Requirements are kept minimal and often validated by quick prototyping.
Decisionmaking is decentralized, and documentation is limited to essential artifacts [
Pipeline stages: Stage 1 - Define what customers truly value and eliminate unnecessary work.
Stage 2 - Visualize workflow from concept to delivery, identifying waste and bottlenecks. Stage 3 - Establish continuous workflow by removing delays and optimizing process steps. Stage 4 - Implement demand-driven delivery where work starts only when customers need it. Stage 5 - Continuously improve processes through regular feedback and waste elimination.
Lean’s streamlined approach enables fast delivery and adaptability but depends on clear prioritization and disciplined validation to avoid pursuing low-value work.
Comparative analysis of requirement management characteristics in Agile frameworks are displayed in table 1. 3. Types of Large Language Models and Their Potential in Requirements Management
Large Language Models (LLMs) are advanced AI systems trained on extensive corpora of text to perform a wide range of language-related tasks, including comprehension, summarization, classification, and generation of natural language. Their transformer-based architectures enable them to capture contextual relationships in text with high accuracy, making them a potentially transformative tool in requirements engineering (RE) for Agile environments. This section outlines the classification of LLMs, their capabilities relevant to requirements management, and the risks associated with their application. 3.1.
LLMs can be categorized along several dimensions that determine their suitability for Agile
requirements workflows [
Falcon, MPT), offering greater control over data privacy and compliance. 3. By deployment model Cloud-hosted LLMs – operated by the provider, enabling scalable use but raising concerns over confidentiality and compliance. On-premises/self-hosted LLMs – deployed within organizational infrastructure, ensuring data control but requiring more computational resources and maintenance.
Understanding the classification of LLMs is crucial for selecting an appropriate model that aligns with the organization’s domain, security requirements, and technical capabilities. 3.2.
LLMs can enhance different stages of the requirements engineering process in Agile contexts,
from initial backlog creation to continuous refinement and traceability. The following capabilities
are the most relevant for practical integration[
LLMs bring multi-faceted benefits to Agile requirements management – not only by accelerating repetitive tasks like classification and traceability but also by improving requirement clarity, consistency, and adaptability to changing business priorities. 3.3.
While the promise of LLMs in Agile requirements management is considerable, their adoption
comes with notable caveats that teams must address before large-scale deployment [
To harness the benefits of LLMs without undermining Agile principles, organizations must combine AI assistance with robust governance – including human-in-the-loop review, data handling policies, and continuous monitoring of output quality. Large Language Models can be classified by their scope, accessibility, and deployment approach, each offering distinct trade-offs between flexibility, control, and resource requirements. Their capabilities extend well beyond simple text generation – supporting classification, refinement, traceability, validation, and tool integration – making them highly relevant to Agile requirements management.
At the same time, effective adoption demands awareness of potential risks: inaccuracies, bias, data security concerns, over-reliance on automation, and operational costs. These challenges highlight the importance of tailored integration strategies that account for the unique workflows of different Agile methodologies. The following section builds on these insights by exploring how LLMs can be systematically embedded into Scrum, Kanban, XP, SAFe, and Lean pipelines, including practical examples and visual process models.
The application of LLMs in Agile environments should be adapted to the specific workflow and artifacts of each methodology. This section proposes practical integration strategies for five widely used frameworks – Scrum, Kanban, Extreme Programming (XP), SAFe, and Lean – and illustrates their use through diagrams and a detailed case study for Scrum. 4.1.
Stage 7.1 – Sprint review
Stage 7.2 (LLM) - LLM can summarize stakeholder feedback, map it to new/updated stories, and note terminology drift. Produce a short change log and traceability suggestions back to epics/tests.
Stage 7.3 – Validate and update requirements based on Product Owner input and using LLM summary. Continue with stage 3.
Figure 6 presents a visualization of the modified Scrum pipeline with integrated LLM models.
LLMs can improve Scrum requirements management by clarifying stakeholder inputs, converting them into well-structured user stories with acceptance criteria, and assisting in backlog refinement through dependency detection, risk highlighting, and story adjustments. They support sprint planning with prioritization hints and capacity checks, aid development by suggesting acceptance tests and edge cases, and post-sprint by analyzing feedback to update the backlog. This reduces ambiguity, speeds refinement, and strengthens traceability while keeping human oversight central. 4.2.
While Kanban excels at transparency and adaptability, its minimal documentation approach can lead to vague or incomplete cards if the intake process is not well structured. Large Language Models can improve Kanban’s requirement handling by transforming unstructured stakeholder inputs into well-formed cards, enriching them with acceptance criteria, and maintaining clarity as work progresses. They can also assist in prioritization, detect bottlenecks, and generate meaningful release summaries without breaking Kanban’s lightweight workflow. Figure 7 displays the modified Kanban pipeline with LLMs models integration.
Stage 1.1 – Gather raw requirements
Stage 1.2 (LLM) - Before anything appears on the Kanban board, LLMs can process stakeholder inputs – from meeting notes, emails, or chat logs – to extract the core requirement, remove noise, and rewrite it as a concise, well-structured card candidate. They can also propose initial tags and detect missing details, generating clarifying questions for the product owner.
Stage 2.1 - Add structured requirement as Kanban card.
Stage 2.1 (LLM) - At this stage, the LLM can further clean wording, group similar cards, and ensure the descriptions follow the team’s standards and the format is consistent.
Stage 3.1 - Prioritize according to business needs.
Stage 3.2 (LLM) - An LLM can review deadlines, business objectives, and dependency chains to propose a priority order. It might also highlight quick wins or warn about items with high complexity or risk.
Stage 4.1 - To Do.
Stage 4.2 (LLM) - Before work begins, the LLM can suggest acceptance criteria, generate example scenarios, and identify unclear requirements.
Stage 5 - In Progress.
Stage 6 - Done.
Stage 7.1 - Continuous or batch release.
Stage 7.2 (LLM) - When features are delivered, the LLM can summarize changes for release notes and trace delivered items back to their original requests or epics. This supports transparency, traceability, and compliance documentation.
Integrating LLMs into Kanban supports requirement gathering, card creation, prioritization, and continuous improvement. LLMs can extract and format stakeholder requests into structured Kanban cards, enrich them with tags and acceptance criteria, and assist in priority ordering based on business objectives and dependencies. During development, they help maintain clarity as work items progress and, after release, generate summaries and trace items back to original requests. This results in cleaner intake, faster prioritization, and improved traceability without disrupting Kanban’s continuous flow. 4.3.
While XP’s lightweight artifacts encourage flexibility, they can be challenging to keep synchronized with evolving feedback and tests. By integrating Large Language Models, XP teams can accelerate story creation from customer conversations, expand acceptance tests with comprehensive scenarios, and maintain an up-to-date repository of requirements and tests. This helps preserve XP’s agility while reducing the risk of overlooked or outdated requirements.
LLM-Enhanced XP pipeline: Stage 1.1 – Planning Game: Customer presents requirements and priorities
Stage 1.2 (LLM) - LLM can normalize customer requirements, extract clear user stories following XP format, generate story estimates based on complexity patterns, and suggest release planning options. Create metaphors and system vocabulary to ensure shared understanding.
Stage 2.1 – Design Simply: Team creates simplest design
Stage 2.2 (LLM) – LLM can suggest simple design patterns, generate CRC cards automatically from user stories, identify potential over-engineering risks, and propose refactoring opportunities to maintain simplicity.
Stage 3.1 – Write Tests First: Create unit tests
Stage 3.2 (LLM) – LLM can auto-generate test cases from acceptance criteria, suggest edge cases and boundary conditions, create test data sets, and ensure comprehensive test coverage following TDD principles.
Stage 4.1 – Code in Pairs: Implement functionality
Stage 4.2 (LLM) – LLM can act as coding assistant during pair programming, suggest code improvements, detect code smells in real-time, and provide refactoring suggestions while maintaining collective code ownership.
Stage 5.1 – Continuous Integration: Integrate code frequently
Stage 5.2 (LLM) – LLM can analyze integration conflicts, suggest merge strategies, optimize build processes, and predict integration risks based on code changes.
Stage 6.1 – Listen and Adapt: Collect feedback from running software
Stage 6.2 (LLM) – LLM can analyze user feedback patterns, correlate feedback with specific user stories, suggest story adjustments, and identify emerging requirements for the next planning cycle.
In Extreme Programming, LLMs can streamline the translation of customer conversations into structured user stories, propose thorough acceptance tests including edge cases, and keep these aligned through iterative feedback cycles. They help detect when tests or requirements become outdated, maintain traceability, and generate clear changelogs. The result is faster feedback incorporation, higher test coverage, and a continuously accurate repository of requirements and tests, while preserving XP’s emphasis on close customer collaboration. 4.4.
While SAFe offers robust planning and traceability mechanisms, its complexity can introduce overhead in managing large volumes of requirements and dependencies. Integrating Large Language Models into SAFe can streamline decomposition, improve consistency in requirement descriptions, and enhance dependency management during Program Increment (PI) planning. LLMs can also strengthen traceability across all levels of the hierarchy, ensuring that business value is preserved from epic definition to feature delivery.
Stage 1.1 – Portfolio Strategy: Define strategic themes and business objectives
Stage 1.2 (LLM) - LLM can analyze market data, competitive intelligence, and business metrics to suggest strategic themes. Generate portfolio epic proposals based on business objectives, perform risk/benefit analysis, and map themes to value streams automatically.
Stage 2.1 – Solution Planning: Break down portfolio epics
Stage 2.2 (LLM) - LLM can decompose large portfolio epics into appropriately sized capabilities and program epics. Suggest capability boundaries, identify cross-ART dependencies, generate benefit hypotheses, and create traceability matrices between portfolio and program levels.
Stage 3.1 – Program Planning: PI Planning preparation and feature decomposition Stage 3.2 (LLM) - LLM can assist in PI Planning by breaking capabilities into right-sized features, generating feature acceptance criteria, identifying program dependencies and risks, suggesting team capacity allocation, and creating draft PI objectives.
Stage 4.1 – Team Execution: Story creation and sprint execution
Stage 4.2 (LLM) - LLM can decompose features into implementable user stories following INVEST criteria, generate acceptance criteria and test cases, suggest story splitting techniques, provide estimation support, and identify blockers or dependencies between stories.
Stage 5.1 – Continuous Delivery: Release and feedback collection
Stage 5.2 (LLM) - LLM can analyze delivery metrics across ARTs, synthesize stakeholder feedback from inspect and adapt events, suggest process improvements, track value delivery against PI objectives, and recommend adjustments for future PI planning cycles.
Figure 9 displays LLM-Enhanced SAFe Pipeline.
In SAFe, LLMs can assist at every level of requirement decomposition, from epics to user stories, ensuring alignment with business value and portfolio priorities. They help maintain consistency in acceptance criteria, visualize dependencies during PI planning, and preserve traceability across the entire hierarchy. The result is improved clarity, stronger cross-team coordination, and easier compliance reporting, all while supporting SAFe’s structured, multi-level planning approach.
The minimalism that Lean Software Development provides makes this methodology highly adaptable, but it also risks omitting important details or traceability if not carefully managed. LLMs can enhance Lean by ensuring even lightweight requirements are clear, consistent, and traceable, without adding unnecessary bureaucracy.
Figure 10 displays modified Lean Software Development Pipeline with integrated LLMs stages.
Stage 1.1 - Define what customers truly value
Stage 1.2 (LLM) - LLM can analyze customer feedback, surveys, and usage data to identify true value drivers. Generate customer personas, prioritize value propositions, and suggest features that eliminate non-value-adding work automatically.
Stage 2.1 - Visualize workflow from concept to delivery
Stage 2.2 (LLM) - LLM can auto-generate value stream maps from process documentation, identify waste patterns across similar workflows, suggest bottleneck removal strategies, and predict where delays are likely to occur.
Stage 3.1 - Establish continuous workflow
Stage 3.2 (LLM) - LLM can optimize process sequences, suggest workflow automation opportunities, identify resource allocation improvements, monitor flow metrics in real-time, and recommend process standardization approaches.
Stage 4.1 - Implement demand-driven delivery
Stage 4.2 (LLM) - LLM can analyze demand patterns to predict customer needs, optimize pull system triggers, suggest capacity adjustments based on demand forecasting, and automate work initiation based on customer signals.
Stage 5.1 - Continuously improving processes
Stage 5.2 (LLM) - LLM can analyze performance metrics to identify improvement opportunities, suggest kaizen initiatives, synthesize feedback from multiple sources, track improvement impact, and recommend next optimization cycles.
This approach shows how AI enhances each Lean principle while maintaining the focus on waste elimination and continuous flow that defines Lean methodology.
LLMs can summarize user reactions, identify common improvement themes, and propose nextstep requirements. This helps ensure the next iteration is informed by clear, structured insights instead of raw, unfiltered feedback.
This chapter examined how Large Language Models can be embedded into the requirements management processes of five Agile methodologies: Scrum, Kanban, Extreme Programming (XP), the Scaled Agile Framework (SAFe), and Lean Software Development. For each methodology, we mapped LLM capabilities directly to its native workflow stages, introduced specific enhancement opportunities, and illustrated them with annotated process diagrams.
Across all frameworks, LLMs were shown to add value at key points such as requirement intake, backlog or board preparation, prioritization, acceptance criteria generation, and postdelivery feedback analysis. The depth of integration varied according to the methodology: Scrum and SAFe benefit from structured decomposition and traceability support; Kanban gains from improved card clarity and prioritization; XP from enriched acceptance testing and synchronization with evolving feedback; and Lean from structured yet lightweight documentation that preserves agility while reducing waste.
A consistent pattern emerged – LLMs can reduce ambiguity, accelerate refinement, and strengthen traceability without disrupting the core principles of each methodology. However, the chapter also reinforced that these benefits depend on maintaining human oversight, tailoring integration to the workflow, and ensuring alignment with organizational priorities and compliance requirements.
The integration of Large Language Models into Agile requirements management offers a promising avenue for enhancing efficiency, consistency, and traceability across diverse development contexts. By aligning LLM capabilities with the distinct workflows of Scrum, Kanban, Extreme Programming, SAFe, and Lean Software Development, this study has shown that AI can effectively support both structured and lightweight Agile approaches.
LLMs excel in transforming unstructured stakeholder input into well-formed requirements, enriching backlog items or work cards with acceptance criteria, identifying dependencies, and maintaining traceability across the development lifecycle. They also facilitate faster refinement cycles, more informed prioritization, and clearer post-delivery feedback analysis. While the level and style of integration vary by methodology, the underlying benefits are consistent: reduced ambiguity, improved requirement quality, and more efficient collaboration between business and technical stakeholders.
However, the deployment of LLMs in requirements engineering is not without risks. Challenges such as hallucinations, bias, over-reliance on automation, and data privacy concerns underscore the need for robust governance and human-in-the-loop oversight. Moreover, integration strategies must be tailored to each methodology’s principles to avoid undermining the very agility they aim to support.
Future research should explore domain-specific LLM fine-tuning, evaluate real-world productivity impacts over extended projects, and investigate hybrid human–AI collaboration models that optimize both speed and accuracy. As technology matures, LLM-assisted requirements management has the potential to become an integral part of Agile practice, bridging the gap between human creativity and machine efficiency.
[18] Semchyshyn, V., & Mykhalyk, D. (2023). Automated processing and analysis of medical texts.
ITTAP, 300-305. [19] Lypak, O.H., Lytvyn, V., Lozynska, O., Rzheuskyi, A., Dosyn, D. (2019). Formation of Efficient Pipeline Operation Procedures Based on Ontological Approach. Advances in Intelligent Systems and Computing, 871, 571–581.