The Repository That Maintains Itself
On February 18, 2026, GitHub announced the technical preview of Agentic Workflows — a framework that allows AI coding agents to automate complex, repetitive repository tasks within GitHub Actions. Unlike traditional automation that follows rigid scripts, agentic workflows employ AI models that understand context, reason about intent, and adapt their approach based on results.
This is not a minor feature update. It represents a fundamental shift in the relationship between developers and their repositories: from humans maintaining code with tool assistance, to AI agents maintaining code with human oversight.
What Agentic Workflows Can Do
GitHub's initial technical preview supports several workflow categories:
Automated Issue Triage and Labelling
When a new issue is filed, an agent reads the description, analyzes the relevant code paths, and applies appropriate labels, assigns it to the correct team, and even drafts an initial response. For large open-source projects that receive hundreds of issues per week, this eliminates a significant manual burden.
Documentation Updates
When a pull request changes a public API, the agent can detect the change, locate the relevant documentation files, and submit a companion PR that updates the docs. This addresses one of the most persistent pain points in software development: documentation that falls out of sync with code.
CI Troubleshooting
When a CI pipeline fails, the agent analyzes the failure logs, identifies the root cause (a flaky test, a missing environment variable, a dependency conflict), and either fixes the issue directly or provides a detailed diagnosis. For CI pipelines that fail intermittently due to flaky tests, this alone can save hours per week.
Test Improvement
The agent can analyze code coverage reports, identify untested code paths, and generate test cases to fill the gaps. Combined with mutation testing — where the agent verifies that the new tests actually catch bugs — this improves code quality without requiring developers to write boilerplate test code.
Dependency Update Orchestration
Perhaps the most directly relevant capability for drift management: the agent can monitor for available dependency updates, assess breaking changes, apply the upgrade, run the test suite, and submit a PR with a detailed summary of what changed and why. If the tests fail, the agent attempts to fix the code to accommodate the breaking changes before flagging the PR for human review.
How It Works Under the Hood
Agentic Workflows build on GitHub Actions, which means they are triggered by the same events (push, pull request, issue creation, schedule) and run in the same infrastructure. The difference is what happens inside the workflow step. Instead of executing a shell script or a Docker container with deterministic logic, the step invokes an AI agent with:
- A goal: what the agent should accomplish (e.g., "update documentation to reflect API changes in this PR").
- Context: the relevant files, the PR diff, issue history, and any other repository metadata.
- Tools: the ability to read files, write files, run commands, make API calls, and submit PRs.
- Guardrails: constraints on what the agent may modify, which branches it may target, and what requires human approval.
The agent then plans a sequence of actions, executes them, evaluates the results, and iterates until the goal is met or a human is needed. All actions are logged and auditable, and all changes go through the standard PR review process.
Implications for Drift Management
For teams that struggle with dependency drift, agentic workflows offer a compelling path forward. Instead of relying on Dependabot to create PRs that sit unreviewed, an agentic workflow can:
- Detect that a dependency update is available.
- Analyse the changelog for breaking changes.
- Assess whether the breaking changes affect your codebase (using AST analysis and test impact analysis).
- Apply the upgrade and any necessary code changes.
- Run the test suite to verify correctness.
- Submit a PR with a detailed summary: what was upgraded, what code was changed, what tests were run, and what the risk level is.
- Escalate to a human reviewer only if the changes are complex, the tests fail after remediation attempts, or the exposure score exceeds a threshold.
This workflow compresses what currently takes days (or weeks, if the PR sits in a queue) into hours, with higher quality context than a developer doing the same work manually.
The Trust and Governance Challenge
The prospect of AI agents making changes to production codebases raises legitimate concerns about trust, auditability, and governance. GitHub has addressed several of these in the technical preview:
- All agent actions are logged and visible in the Actions tab, just like any other workflow run.
- Changes always go through PRs, subject to branch protection rules, required reviewers, and status checks.
- Agents can be scoped to specific directories, file types, or change categories. A documentation agent does not have write access to source code.
- Human-in-the-loop checkpoints can be configured for high-risk changes.
However, governance frameworks are still catching up with the technology. Organisations will need to define policies for:
- Which workflows are allowed to run agents.
- What level of change requires human approval.
- How agent-generated changes are audited and attributed.
- Whether agent-authored code needs to meet the same review standards as human-authored code.
These are not purely technical questions — they are organizational ones that will evolve as teams gain experience with the technology.
What to Do Now
Agentic Workflows are in technical preview, which means they are available to try but not yet recommended for production-critical use. Here is how to get started:
- Request access to the technical preview through your GitHub organization settings.
- Start with low-risk workflows: documentation updates, label automation, and test generation are ideal first candidates.
- Define guardrails early: before enabling agents on any repository, establish which files and branches are in scope, what changes require human approval, and how agent actions are monitored.
- Measure impact: track metrics like time-to-merge for dependency update PRs, documentation freshness, and CI failure recovery time. Compare before and after enabling agents.
- Share learnings: this is a new capability for everyone. Document what works, what does not, and what surprises you.
The future of software maintenance is not developers doing everything manually, and it is not AI doing everything autonomously. It is a collaborative model where agents handle the routine, humans handle the judgment calls, and both work from the same repository of truth. Agentic Workflows are the first major step toward that future — and they are available today.