Introduction
AI-assisted development creates the greatest value when it improves the entire software lifecycle, not only the moment when a developer writes code.
For Tieto Tech Consulting’s Network Products team, this means applying agentic engineering in a demanding real-world environment: customer deployments in 20 countries, globally distributed team, both own and 3rd party proprietary source code, and stringent quality requirements.
The experience demonstrates how GitHub Copilot can form an orchestration layer for an end-to-end agentic DevOps approach, while continuing to use established on-premises environments.
Brownfield engineering is where agentic DevOps must prove its value
Many AI development demonstrations start with a new application, a small codebase and few operational constraints. The Network Products represents a very different challenge.
This is an environment with mature products with modern architecture and extensive accumulated product knowledge. The portfolio includes signaling software for SS7 and Diameter networks, signaling control and routing across 2G, 3G, 4G and 5G, and device detection for legacy and LTE (Long Term Evolution) environments with more than 25,000 signaling installations worldwide since 1991.
These are mission-critical products. Changes must meet telecom-grade expectations for robustness, quality and service levels.
The team already relies on on-premises GitLab repositories, Jira for issues and traceability, and Jenkins for CI/CD validation and with committed customer releases they simply couldn’t abandon existing systems to introduce AI.
For the team, the key questions were:
- Can GitHub Copilot and agentic AI help accelerate the lead time for software delivery, while preserving architecture, traceability, security and telecom-grade quality?
- Can the team adopt Agentic AI without compromising customer commitments while improving productivity?
The answer was a sound yes.
The team experienced faster feature implementation when using the agent-based process end- to-end, substantial time savings in unit-test and documentation generation, better user stories and tasks with improved traceability, and broader test coverage through AI-generated edge cases and variants.
Knowledge that previously lived in individual developers’ heads has now been encoded in instructions, skills, templates and agent definitions and stored under version-control, improving team productivity.
GitHub Copilot becomes the agentic orchestration environment
In the Network Products team’s approach, GitHub Copilot becomes the working environment in which developers interact with specialized agents, project instructions, engineering templates, and connected lifecycle tools. Custom agents are configured for distinct responsibilities, such as requirement analysis, story breakdown, technical planning, implementation, documentation, review and maintenance. Each agent receives only the instructions, context, and tools required for its role.
This model helps turn AI from an individual productivity technique into a repeatable team level capability. The agents, instruction files, templates, skills and supporting scripts are version-controlled in a central Git repository that developers can review and use consistently. Repository-specific instructions encode product context, architectural constraints, coding standards and testing rules that a general-purpose model would not otherwise understand.
The importance of this product-specific context should not be underestimated. Our experience showed that default agent mode was insufficient. Custom agents and repository-specific instructions were needed to produce more relevant and reliable results for this specific codebase.
The Network Products team developed custom Model Context Protocol (MCP) integrations for its on-premises GitLab environment. The resulting agentic flows, through GitHub Copilot, can interact with GitLab repositories and merge-request processes without replacing the existing source control and delivery platform.
This creates a hybrid architecture where GitHub Copilot provides the agent experience and orchestration layer. GitLab, Jira and Jenkins continue as the systems of record, traceability and delivery control. MCP connects the two.
This pattern matters for organizations with regulatory, intellectual property or infrastructure constraints. Agentic DevOps does not require every component of the toolchain to move to a public SaaS platform. AI capabilities can be introduced around established on-premises systems through narrowly scoped and governed interfaces.
In practice, GitHub Copilot becomes the developer-facing control plane for the workflow:
- Developers initiate and supervise agent activities in their familiar local environment.
- GitHub Copilot interprets the goal, product instructions and repository context.
- Specialized agents coordinate analysis, planning, implementation, and closure.
- MCP connections provide controlled access to Jira, GitLab, and other internal tools.
- Human approvals and CI/CD gates determine whether work can proceed.
"This is the distinction between AI-assisted coding and agentic DevOps. The former helps with a coding task while the latter coordinates a governed flow of work across the software lifecycle."
An end-to-end flow from Epic to delivered code
The Network Products agentic software development workflow divides feature delivery into specialized, traceable stages.
1. Epic preparation and requirement analysis
An epic-analysis agent retrieves the Epic, identifies goals, actors and requirements, raises clarification questions and produces a structured requirements document. It can also identify the GitLab repositories that are likely to be affected.
The Product Owner and engineering team review the analysis before the requirements are approved. The agent does not independently decide that the Epic is ready.
2. Story and task breakdown
A story-breakdown agent uses the approved Epic analysis to propose stories, dependencies and subtasks. The proposed structure moves through a Product Owner review loop before Jira items are created.
This improves the quality of work entering development. The internal material reports clearer requirements, better-structured work items and improved traceability between Epics, stories, subtasks and merge requests.
3. Technical planning
A code-planning agent reads the approved story or subtask, examines the relevant codebase, and proposes a technical approach before code is changed. The resulting plan is captured in a standard tracking file and reviewed by an engineer.
Separating planning from implementation is an important control. It enables the team to assess the proposed design against the product architecture before giving an agent write access.
4. Code, tests and documentation
Once the plan is approved, an implementation agent generates or modifies code, adds unit tests and updates documentation. The agent follows the approved plan as well as repository-specific coding and testing instructions.
Generated code is reviewed and submitted to the same validation mechanisms used for developer-written code.
5. CI/CD validation and controlled requirement closure
The implementation is validated through the established Jenkins CI/CD pipeline. Build, unit-test, and integration-test gates continue to apply. The conclusion agent prepares documentation, a completion report, and a GitLab merge request, but human approval is still required before merging and closing the Jira story.
The same pattern has been extended to maintenance. Dedicated agents support error and defect report analysis, technical planning, fix implementation, testing, merge-request preparation and closure. The analysis flow can retrieve issue details, examine logs and stack traces, search for similar incidents, identify affected repositories, and create a structured root-cause analysis.
Guardrails are integral part of the workflow
For mission-critical telecom software, autonomy without control would be unacceptable. The Network Products implementation therefore uses several guardrails.
Role-based access. Agents have access only to the tools required for their function. A planning agent can operate with read-only access, while an implementation agent receives controlled write capabilities.
Product-specific instructions. Global and repository-level Markdown files define coding standards, testing requirements, product context, and architectural constraints.
Structured templates. Requirements, planning records, implementation records, error report analyses, and merge requests follow reusable templates, reducing variability and preserving an audit trail.
Human-in-the-loop decisions. Engineers review analyses, plans, code, tests, documentation, and merge requests. Approval points are explicitly represented in the workflow.
Existing delivery gates. AI-generated code passes through the same CI/CD checks as human-written code. The agentic layer augments the engineering process but does not bypass its quality controls.
This combination allows the team to increase automation progressively while keeping accountability.
A practical blueprint for enterprise agentic DevOps
The Network Products experience offers a useful blueprint for other organizations running mature, business-critical software:
- Start with a real feature or maintenance flow, not an isolated AI demonstration.
- Keep the existing systems of record and quality gates.
- Use GitHub Copilot to provide contextual, role-based agent capabilities.
- Connect on-premises lifecycle tools through controlled MCP servers.
- Encode product knowledge in version-controlled instructions, skills, and templates.
- Separate analysis, planning, implementation, and approval responsibilities.
- Preserve human accountability for architectural, quality, and merge decisions.
- Track where AI contributes and measure outcomes across the lifecycle.
- Improve the agent system continuously as product knowledge and models evolve.
Agentic DevOps is therefore not a replacement for disciplined software engineering. Its value comes from making that discipline easier to apply, more consistent across a distributed team, and better connected from design to delivery.
Five takeaways
1. Agentic DevOps can generate value in brownfield engineering.
Agentic development is applicable to mature, mission-critical telecom products, not only small greenfield applications.
2. Productivity improves across the lifecycle, not only in coding.
Productivity doubled across the entire software lifecycle – from requirements and planning to implementation, testing, documentation, and delivery.
3. Quality comes from combining agents with engineering controls.
Additional tests, clearer requirements and more consistent documentation support quality, while human reviews and established CI/CD gates protect delivery standards.
4. Product-specific context is the key to useful agent behavior.
Custom agents, repository instructions, templates and reusable skills produced better outcomes than generic prompting by grounding the agents on product’s context.
5. GitHub Copilot enables a pragmatic orchestration model.
GitHub Copilot provides the developer-facing agent experience, while MCP connects agents to on-premises environments and tools. This enables an end-to-end flow from design to delivery without replacing the organization’s existing systems of record, CI/CD investments, or quality controls.
Apply agentic DevOps for engineering productivity
We help organizations improve software development efficiency and quality with AI-first and agentic ways of working with Github Copilot and Azure DevOps. Tieto is Microsoft's Frontier Partner with more than 1000 certified professionals. Learn more
