The Case for Continuous Efficiency
Most development teams rarely discuss sustainability in standups. Yet green software practices have measurable business value: reduced resource consumption, lower costs, improved code quality, and better user experience. The challenge is that sustainability rarely makes it onto roadmaps or backlogs.
GitHub's Next and Sustainability teams are piloting an approach they call Continuous Efficiency — the idea that codebases can improve themselves through endless, incremental, validated optimizations. It operates at the intersection of two existing concepts: Continuous AI (LLM-powered automation in CI/CD workflows) and Green Software (software designed to be energy-efficient with a lower environmental impact). While green software tends to be cheaper, more performant, and more resilient, the goal of Continuous Efficiency is to realize those benefits with minimal human effort.
The underlying platform is Agentic Workflows, a research-demonstrator framework from GitHub that is publicly available and open source, though experimental. It explores proactive, automated, event-driven behaviors in GitHub repositories, running safely in GitHub Actions.
Implementing Rules and Standards
Traditional linting and static analysis require hard-coded patterns and logic, limiting their scope and flexibility. With modern LLMs and agentic workflows, engineering standards and code-quality guidelines can be expressed in natural language and applied at scale, going beyond conventional approaches in three ways:
- Declarative, intent-based rule authoring — describe intent in natural language, and the model interprets and implements it.
- Semantic generalizability — one high-level rule can apply across diverse code patterns, languages, and architectures.
- Intelligent remediation — issues are resolved agentically through platform-integrated actions like opening pull requests or adding comments with suggested edits.
This allows engineering guidelines that previously required lengthy review cycles to be consistently enforced across any repository.
| Case study: Code base reviews Green software rules implementation We have implemented a wide range of standard and specific Green Software rules, tactics and patterns. These can be applied fully agentically to entire codebases and repos. Example: We teamed up with the resolve project to scan their codebase with a number of rules, and agentically delivered proposed improvements. The outputs weren’t all perfect—but one of the recently approved and merged pull requests makes a small performance improvement by “hoisting” RegExp literals from within hot functions. The project gets 500M+ downloads per month on npm. So this small impact will scale! | Case study: Implementing standards Web sustainability guidelines (WSG) The W3C WSG is a great resource to help people make web products and services more sustainable. We implemented the Web Development section into a set of 20 agentic workflows, so now the guidelines can be used by AI too! Example: We have run the WSG workflows on a number of GitHub and Microsoft web properties and found opportunities and built resolutions to improve them—ranging from deferred loading to using native browser features and latest language standards. |
Heterogeneous Performance Engineering
Performance engineering is difficult not merely because of algorithmic complexity—real-world software is deeply heterogeneous, mixing languages, architectures, cache behaviors, and network paths in each repository. Expert performance engineers can navigate this complexity, but the industry needs tooling that scales beyond expert input.
The underlying aspiration is a generic agent that works with any piece of software and can demonstrably improve performance. Semi-automatic performance engineering addresses this with an iterative workflow where an agent researches, plans, measures, and implements changes under human guidance. The process begins with "fit-to-repo" discovery to understand how a project builds and measures itself before attempting any modifications.
Agentically, the framework can explore repositories, identify relevant performance tools, run microbenchmarks, and propose targeted changes. Early results vary, but some demonstrate that guided automation can meaningfully contribute to performance improvement at scale.
| Case study: Daily perf improver Daily Perf Improver is a three-phase workflow, intended to run in small daily sprints. It can do things like: (1) Research and plan improvements (2) Infer how to build and benchmark the repository (3) Iteratively propose measured optimizations Example:On a focused recent pilot on FSharp.Control.AsyncSeq it has already delivered real gains by producing multiple accepted pull requests, including a rediscovered performance bug fix and verified microbenchmark-driven optimizations.Daily Perf Improver Research Demonstrator |
Building Agentic Workflows
Instead of writing traditional YAML automation scripts, GitHub's agentic workflows are authored in Markdown. A workflow file contains YAML-like front matter defining triggers, permissions, and tools, followed by plain-English instructions. The gh aw compile command (part of the agentic workflow CLI) converts that Markdown into a standard GitHub Actions .yml workflow.
When executed, the workflow runs an AI agent inside a sandboxed GitHub Actions environment, pulling context from the repository and applying human-written natural-language instructions—say "look for missing documentation, update README files, then open a pull request"—to produce repository modifications. Since execution occurs within GitHub Actions, permission boundaries and safe-output restrictions remain enforced.
The internal process for creating Continuous Efficiency workflows is repetitively simple in four steps:
- Define the intent, from a public standard or a domain-specific engineering requirement.
- Author the workflow in Markdown using structured natural language, guided by the
create-agentic-workflowagent. - Compile the Markdown to standard GitHub Actions YAML.
- Run the workflow in GitHub Actions on selected repositories.
Developers exploring the experimental phase can start immediately by running agentic workflows in GitHub Actions, with examples including a "Daily performance improver" available to try or serve as a basis for authoring custom workflows.
