In my experience as a software architect, most of what makes CI/CD valuable isn't the "integration" or the "deployment" part. It's the "continuous" part. Things happen in the background, on their own schedule, without someone needing to remember to trigger them.
GitHub Next has been pushing a term for what happens when you apply that same idea to AI: Continuous AI, the use of automated AI to support software collaboration on any platform. Not a single tool, not something GitHub owns, just a category. The claim is that this will become as standard a part of software development as CI/CD is today.
What Continuous AI actually covers
The GitHub Next team lists a handful of recurring patterns: Continuous Triage (labeling and responding to issues), Continuous Documentation (keeping docs in sync with code), Continuous Fault Analysis (explaining failed CI runs), Continuous Summarization, Continuous Code Improvement. Different tasks, same shape.
That shape has a few properties in common, and I think this is the more useful part of the framing:
- Automatable: AI can do it with reasonably high reliability.
- Repetitive: it's an ongoing task, not a one-off.
- Event-triggered: something in the repo (an issue, a PR, a schedule) sets it off.
- Auditable: a team can see what ran and why and stay in control of it.
That's a decent checklist to hold any automation idea against before you build it. If it doesn't score well on most of these, it's probably not ready to hand off yet.
Automations in the GitHub Copilot app: Continuous AI you can set up in five minutes
You don't need a GitHub Actions pipeline to try this. The GitHub Copilot app ships a feature called Automations that's a pretty direct, low-ceremony implementation of the idea: define a task once, attach a trigger, and Copilot runs it whenever that trigger fires. No manual input needed after that.
Some of the use cases GitHub itself points to:
- Triage incoming issues: label new issues as bug, enhancement, or other, based on their content. (Continuous Triage)
- Fix failing tests nightly: check main every night, attempt a fix, open a draft PR. (Continuous Fault Analysis and Continuous Code Improvement in one)
- Prepare weekly release notes: draft them and open a PR on a schedule. (Continuous Summarization)
Two ways to run one
Automations come in two flavors:
- Local automations: run from your own machine.
- Cloud automations: run in a cloud environment, so they keep firing even when your laptop is closed.
Remark: cloud automations need Copilot cloud agent enabled for the repository. If you're on Copilot Business or Enterprise, that's a policy an admin has to turn on first.
Setting one up
Let me walk you how to set this up through the Automations tab in the Copilot app.
- Open Automations in the sidebar, click New automation, give it a name.
- Pick a Trigger:
- Manual — only runs when you start it.
- Hourly — runs every hour.
- Daily — pick one or more times.
- Weekly — pick days and a time.
- CRON — for local automations, a custom CRON expression, with a human-readable preview so you don't have to decode it yourself.
- Issue — fires when an issue is created, optionally filtered by a search query.
- Pull request — fires when a PR is opened or synchronized, optionally filtered by files changed.
- Toggle Run in the cloud if you want it to survive your machine being off. For cloud runs, pick the Tools Copilot is allowed to use (pushing changes, updating labels, opening a PR,... ). Only select what the task actually needs. This is your auditability and control knob.
- Write the prompt. This is the actual instruction Copilot follows every time the automation runs. You can type
/to pull in an existing skill.
- Pick the model, reasoning effort, and agent below the prompt box.
- Select the project, then Create. Or use Create and run from the dropdown next to it to test it immediately instead of waiting for the schedule.
That's it! You now have a saved automation.
Putting it into practice: “where was I?”
Here's a prompt that list what I was working on before, set to run every morning before the workday starts:
Review all the commits I did the last time I worked on this repository. Summarize them by feature and present them in a nice overview. Do not modify files.Trigger: Daily, one time slot, early morning. Tools: read PR status, comment on PR. Run in the cloud, so it's done before I've had coffee.
Remark: I had to add the 'Do not modify files' after noticing that the agent was to eager and started changing stuff. What a work ethics.
Tip: automations ignore events triggered by users without write access by default, which limits prompt-injection risk from random issue comments. If you do want automations triggerable by anyone, there's a repository setting for that but think twice before flipping it.
The takeaway
Continuous AI is a (pun intended) continuous effort. GitHub Next themselves compare it to a 30-year story, the same timescale as CI/CD. You don't have to buy into all of it to get something out of it today. Automations in the Copilot app is one small, practical corner of that vision that you can set up before lunch.
Simple, useful, done.