Connecting Product Management to Agentic Engineering: Jira as the Human Control Plane
Disclosure: This article was written with AI assistance, and the architecture diagram was generated with AI assistance to illustrate the workflow described.
Most organizations do not start software development with an empty backlog. They already have product management processes, delivery teams, and established tools such as Jira.
Product managers maintain roadmaps, prioritize features, define user stories, and agree on acceptance criteria. Engineering teams plan their work, implement features, test software, and report delivery progress.
Introducing an AI-native software development lifecycle (SDLC) raises an important question:
How do we integrate AI agents into these existing practices without creating a parallel delivery process?
Replacing Jira with AI-generated Markdown files is unlikely to be practical for most enterprises. Product managers still need visibility into priorities, dependencies, and delivery commitments. Engineering teams still need version control, technical specifications, automated testing, and deployment pipelines.
The objective should be to connect these existing capabilities rather than replace them.
Separating Product Management from Engineering Execution
An AI-native SDLC does not mean transferring product ownership to AI agents.
Product managers remain responsible for product direction and business priorities. Engineering teams remain accountable for technical implementation and the quality of delivered software.
For organizations using Scrum, it is important to distinguish between a Product Manager and a Product Owner.
The Product Owner is a formal Scrum accountability, responsible for maximizing product value and effective Product Backlog management. Product Manager is an organizational job title rather than a role defined by Scrum. In some organizations, the same person performs both functions.
This article uses Product Owner when discussing Scrum accountabilities and Product Manager when referring to broader organizational responsibilities.
AI agents can assist both groups, but their authority should be explicitly defined.
A practical division of responsibilities would be:
| Responsibility | Primary owner | AI agent contribution |
|---|---|---|
| Product strategy and roadmap | Product Manager | Research and analysis |
| Product Backlog management | Product Owner | Dependency and impact analysis |
| User stories and acceptance criteria | Product Owner, with stakeholders | Drafting and refinement |
| Technical specifications | Engineering | Generate proposed specifications |
| Architecture | Engineering / Technical Lead | Evaluate technical options |
| Implementation | Developers | Generate code and tests |
| Quality assurance | Developers / QA | Execute tests and identify defects |
| Release governance | Authorized release owner | Produce validation evidence |
| Product acceptance | Product Owner and relevant stakeholders | Compare outcomes with requirements |
In Scrum, Developers are accountable for creating a usable Increment that meets the Definition of Done. The Scrum Team remains accountable for its work regardless of how extensively AI agents assist.
This distinction matters because an AI agent may generate technically correct software that does not address the intended business problem.
Human ownership of product decisions remains necessary.
Jira as the Product Delivery System of Record
In the proposed architecture, Jira remains the system of record for the Product Backlog, business requirements, and delivery tracking.
Git becomes the system of record for versioned engineering specifications, implementation plans, source code, and tests.
An orchestration layer connects these systems and coordinates AI agents.
The workflow is:
Product Owner → Jira → Agentic Orchestration → Specifications → Implementation → Validation → Deployment → Jira

Jira provides business context and delivery visibility. The engineering repository contains the versioned technical definition and implementation evidence.
The integration can use Jira REST APIs, webhooks, and appropriately configured Model Context Protocol (MCP) tools.
For example, when a Jira story reaches an agreed workflow state, a webhook could notify the orchestration service that the story is ready for specification generation.
However, a Jira event should not automatically authorize an agent to modify code or deploy software.
The orchestration layer must validate the event, check the applicable workflow policy, and determine which actions the agent is permitted to perform.
This allows organizations to automate engineering activities while maintaining control over business requirements and technical changes.
A Practical Example: Building Our Secure Document API
Consider the secure document API introduced in the previous article.
The project uses:
- GitHub Spec Kit for specification-driven development.
- Claude Code as the AI coding environment.
- VS Code as the development environment.
- Git for version control and engineering artifacts.
- Containers for consistent development and deployment environments.
- Jira for Product Backlog and delivery management.
We now connect these tools through an agentic engineering workflow.
Step 1: The Product Owner Creates a User Story
The Product Owner creates a Jira issue:
SDAPI-42 — Implement Secure Document Upload
As an authenticated user, I want to upload documents securely so that they can be stored and accessed only by authorized users.
Initial acceptance criteria:
- Users must authenticate before uploading.
- Only PDF and DOCX files are accepted.
- Maximum upload size is 10 MB.
- Uploaded documents must be associated with their owner.
- Unauthorized users must not access documents belonging to other users.
In a conventional workflow, Developers would refine the story, discuss technical requirements, and determine how to implement it.
In our proposed agentic workflow, AI assists with these activities before implementation begins.
Step 2: The Requirements Agent Reviews the Story
The requirements agent retrieves the Jira issue and checks it against the project's existing intent, architecture constraints, and engineering constitution.
It identifies several unanswered questions:
- Should uploaded files undergo malware scanning?
- Where should documents be stored?
- Should files be encrypted at rest?
- What happens if an upload is interrupted?
- Should document uploads generate audit events?
Rather than inventing business requirements, the agent records these questions in Jira and requests clarification.
The Product Owner works with Developers and relevant stakeholders to resolve them.
AI may identify missing requirements and recommend improvements, but it should not independently decide what constitutes approved business scope.
Step 3: Generate a Versioned Specification
Once the story is sufficiently understood for implementation, the orchestration layer initiates the specification workflow.
The specification agent uses the Jira requirements to generate a proposed specification in the Git repository.
For example:
specs/042-secure-document-upload/spec.md
The specification describes expected behavior, functional requirements, authorization rules, error scenarios, and testable acceptance conditions.
It also records the originating Jira issue and links to relevant decisions.
The proposed specification can be reviewed through a pull request, according to the team's engineering policies.
If the engineering team identifies an unresolved business requirement, the issue returns to the Product Owner for clarification.
Step 4: Technical Planning and Task Decomposition
After the specification has been reviewed to the required level, the planning agent generates:
plan.md— the technical architecture and implementation approach.tasks.md— the engineering tasks required to implement the specification.
For the secure document API, the plan might include an authenticated upload endpoint, object storage, ownership metadata, file validation, malware scanning, and audit logging.
The agent evaluates these details against the project's engineering constitution, architecture, and existing codebase.
Developers review significant technical decisions and determine how the work should be performed.
The technical tasks remain in Git rather than being duplicated automatically as Jira issues.
Jira continues to represent the product requirement, while the repository records the engineering work needed to deliver it.
Agentic Implementation: Context, Coding, and Automated Validation
Generating a specification is only part of an AI-native SDLC.
The engineering agents must also understand the existing application before making changes.
An agent that reads only the immediate Jira ticket and specification may overlook important architectural constraints or dependencies.
Providing Engineering Context
The orchestration layer should make relevant engineering information available to agents.
Depending on the project, this may include:
- Existing source code and repository structure.
- Architecture Decision Records (ADRs).
- API schemas and interface contracts.
- Coding standards and security requirements.
- Existing automated tests.
- Dependency and infrastructure configurations.
Agents can retrieve this information through repository tools, MCP integrations, or retrieval-augmented generation (RAG) where appropriate.
Not every project requires a separate vector database. For smaller repositories, direct access to source files, documentation, and search tools may be sufficient.
The objective is to provide the agent with the context needed to make changes that are consistent with the existing system.
The Automated Code–Test–Fix Loop
Once the implementation plan is ready, the implementation agent creates a feature branch and begins writing code.
The testing agent generates or executes tests against the approved specification.
The security agent checks relevant controls, including authentication, authorization, file handling, and dependency vulnerabilities.
For example, a security test should verify that one authenticated user cannot retrieve another user's document by changing the document identifier.
If a test fails, the implementation agent analyzes the failure, modifies the code, and reruns the relevant checks.
This creates an automated cycle:
Generate Code → Run Tests → Analyze Failures → Fix Code → Retest
The agents may repeat this process within defined execution limits.
However, they cannot change acceptance criteria simply to make a failing implementation pass.
If the problem requires a change to business requirements, architecture, or security policy, it must be escalated.
Once the required checks pass, the agent creates a pull request containing the implementation and supporting evidence.
Developers review the changes according to the project's risk-based engineering policies.
Review, Release, and Jira Synchronization
After implementation and validation, the engineering workflow proceeds through the organization's established review and deployment process.
The pull request links back to SDAPI-42.
CI/CD pipelines execute the required checks, including automated tests and relevant security scans.
Once the applicable merge and release conditions are satisfied, the changes can be deployed.
The orchestration layer updates Jira with delivery information such as:
- Pull request references.
- Test and security results.
- Deployment status.
- Outstanding defects or exceptions.
The Product Owner and relevant stakeholders can then inspect the delivered functionality against the intended business outcome.
For teams using Scrum, an Increment is Done when it meets the Definition of Done. Jira workflow status and business acceptance activities should not redefine that quality standard.
This maintains traceability between the original requirement and the delivered software.
Avoiding Two Competing Backlogs
A common integration mistake would be to replicate every Jira issue inside GitHub Spec Kit's tasks.md, or automatically create Jira tickets for every technical task generated by an AI agent.
That approach creates unnecessary synchronization problems.
A better approach is to maintain separate but connected records.
Jira owns product requirements and delivery tracking. Git owns versioned engineering specifications, implementation plans, technical tasks, and source code.
The integration maintains traceability between them.
For example:
SDAPI-42 → spec.md → plan.md → tasks.md → Pull Request → Test Evidence → Release
This allows Product Owners to understand delivery progress without managing every engineering task.
It also allows Developers to adapt their technical plans without repeatedly modifying the Product Backlog.
In Scrum, the Sprint Backlog remains the Developers' plan for achieving the Sprint Goal. Engineering tasks maintained in Git can support that plan, but the tooling should not obscure Sprint progress or transfer Sprint Backlog ownership to AI agents.
Managing Requirement Changes Within Scrum
Requirements rarely remain unchanged once development begins.
Product priorities shift, users request additional functionality, and engineering teams discover constraints that were not apparent during initial planning.
An AI-native SDLC needs a practical way to manage these changes without losing control of the engineering specifications.
A Change to Our Secure Document API
Suppose development of SDAPI-42 is already underway.
The Product Owner receives feedback that users need to upload documents up to 200 MB rather than the original 10 MB.
What should happen?
Should the Product Owner edit SDAPI-42 or create another Jira ticket?
The answer depends on the nature of the change, the current state of development, and the team's agreed workflow.
Scrum does not require a new Jira ticket whenever a requirement changes.
The Scrum Guide allows scope to be clarified and renegotiated with the Product Owner during a Sprint as more is learned, provided the Sprint Goal is not endangered and quality does not decrease.
The Product Owner and Developers should first discuss the change and its implications.

Step 1: The Product Owner Proposes the Change
The Product Owner explains the new business requirement:
Increase the maximum supported document upload size from 10 MB to 200 MB.
The Product Owner also explains why the change is needed, its business priority, and whether it must be included in the current release.
The change may be recorded in the existing Jira story or a linked issue, depending on the team's tracking practices.
At this point, the requirement is proposed rather than automatically incorporated into the engineering baseline.
Step 2: AI Agents Perform Impact Analysis
The requirements agent compares the proposed change with the current specification.
Engineering agents examine relevant code, tests, infrastructure configurations, and architectural decisions.
For example:
| Area | Potential impact |
|---|---|
| API | Upload validation and request timeouts |
| Storage | Capacity requirements and costs |
| Security | Malware scanning and file-handling controls |
| Performance | Larger transfers and resource consumption |
| Infrastructure | Proxy limits and container configuration |
| Testing | New boundary and performance tests |
| Delivery | Additional implementation and testing effort |
The agents produce an impact assessment for the engineering team.
These findings are recommendations, not final engineering decisions.
Step 3: Product Owner and Developers Discuss the Options
The Developers review the impact assessment and determine the technical implications.
They may identify that increasing the file-size limit is straightforward, or that supporting 200 MB files requires a different upload mechanism.
The Product Owner considers the business value, urgency, and impact on the Sprint Goal.
Several outcomes are possible.
Option A — Update the existing story
If the change can be accommodated within the Sprint without endangering the Sprint Goal, the Product Owner and Developers may agree to revise SDAPI-42.
The revised requirement is reflected in Jira and the associated engineering specification.
Option B — Create a linked Jira item
If the change is substantial or requires separate tracking, the team may create a linked item such as:
SDAPI-58 — Increase Document Upload Limit to 200 MB
This preserves the relationship with SDAPI-42 and allows the additional work to be tracked separately.
The linked item does not necessarily mean the change must wait for another release.
Option C — Defer the change
If the additional functionality cannot reasonably be accommodated within the current Sprint, it can remain in the Product Backlog for future consideration.
The original 10 MB requirement may proceed as planned.
The Product Owner is accountable for Product Backlog ordering, while Developers remain responsible for determining how to accomplish the work.
Step 4: Update the Engineering Specification
Once the change is agreed, the specification agent prepares updates to the relevant engineering artifacts.
These may include:
spec.md— revised upload requirements.plan.md— changes to the technical approach.tasks.md— additional or modified engineering tasks.- Automated tests — revised validation and performance scenarios.
The agent creates a proposed change in Git.
Developers review the affected technical decisions according to the team's policies.
If implementation is already underway, the orchestration layer should ensure that agents do not continue working against an obsolete specification.
Affected work can be paused or checkpointed while the updated engineering baseline is established.
Step 5: Resume Implementation and Validation
The implementation agent resumes work using the revised specification.
Existing code that remains valid can be retained.
Only affected components and tests need to be modified.
The agents repeat the automated code–test–fix cycle and produce updated validation evidence.
The resulting changes are linked to the relevant Jira issue or issues.
The Product Owner can then inspect the delivered functionality against the revised requirements.
Maintaining Scrum Compatibility
This approach does not introduce a mandatory change-control board into Scrum.
It uses AI to accelerate impact analysis and engineering updates while preserving the accountabilities of the Product Owner and Developers.
A new Jira ticket is a tracking option, not a Scrum requirement.
The central principle is that requirement changes should trigger impact assessment and appropriate scope negotiation, rather than uncontrolled changes to implementation.
Human Approval Gates and Risk-Based Agent Autonomy
Not every agent activity requires human intervention.
Requiring manual approval for every generated test, specification adjustment, or code modification would reduce the productivity benefits of agentic development.
Instead, organizations should distinguish between routine engineering activities and changes that introduce significant business, technical, or operational risk.
A practical approach is to classify changes by risk.
| Risk level | Example | Typical control |
|---|---|---|
| Low | Documentation corrections or minor text changes | Automated checks and lightweight review |
| Moderate | API behavior changes or new workflow functionality | Product and engineering review |
| High | Authentication changes, sensitive data handling, major architectural changes | Additional technical, security, or release approval |
The precise controls depend on organizational policies, regulatory requirements, and the nature of the application.
Agents may recommend a risk classification, but they should not be allowed to downgrade controls without authorization.
For low-risk changes, automated checks and established branch policies may be sufficient.
Higher-risk changes may require additional reviews before implementation, merging, or deployment.
These are enterprise governance controls, not requirements imposed by Scrum.
They should be designed to support delivery rather than create unnecessary approval bottlenecks.
Closing the Loop with Production Observability
The SDLC should not end when the software is deployed.
Production systems generate information about performance, reliability, security, and user behavior.
These signals can provide valuable input to the Product Backlog.
For example, monitoring may reveal that uploads frequently fail when files exceed 50 MB.
An observability agent could examine relevant logs, metrics, and recent deployments to identify possible causes.
It could then propose a Jira defect containing supporting evidence.
The engineering team would investigate the issue, while the Product Owner would consider its priority relative to other Product Backlog items.
For serious operational incidents, established incident response procedures should take precedence over normal backlog prioritization.
This creates a feedback loop:
Production Telemetry → AI-Assisted Analysis → Jira Backlog → Engineering → Deployment
The result is a continuous delivery process in which production evidence informs future product and engineering decisions.
What Changes for Enterprise Product Teams?
The most significant change is not that AI agents can write code.
It is that the handoff between product management and engineering can become more structured, traceable, and partially automated.
Product managers and Product Owners continue to use Jira to manage priorities, requirements, and delivery commitments.
Engineering teams work with versioned specifications, automated implementation tools, and established development controls.
AI agents connect these activities by translating requirements into proposed engineering artifacts, performing authorized technical work, and returning evidence of completion.
The effectiveness of this approach depends on the quality of the integration, the clarity of decision rights, and the reliability of its validation mechanisms.
It does not require organizations to abandon their existing product management or Scrum practices.
Further Reading
The proposed approach is an enterprise implementation pattern, not an extension of the formal Scrum framework.
The following resources provide additional perspectives on Scrum accountabilities, AI-assisted product development, and integrating AI into Agile teams.
- The Scrum Guide (2020) — Ken Schwaber and Jeff Sutherland. The authoritative reference for Scrum accountabilities, events, artifacts, and commitments.
- The Future of AI-Powered Product Development: You Can't Delegate Accountability to an Agent — Scrum.org. Discusses human accountability when AI agents participate in product development.
- Contextual AI Integration for Agile Product Teams — Scrum.org. Examines the importance of context and integrating AI into existing team practices.
- AI Augmented Scrum Framework: When Half Your Team is Autonomous Agents — Scrum.org. Explores agent participation in Scrum-based delivery.
- Artificial Intelligence and Scrum — Scrum.org's collection of AI-related resources.