Backing 16 Green AI Projects in Asia-Pacific: A Regional Push for Sustainable Innovation

Backing 16 Green AI Projects in Asia-Pacific: A Regional Push for Sustainable Innovation

On 7 September 2026, the Google AI Blog made a quiet but revealing announcement: the company is backing 16 green AI projects across Asia-Pacific. The post, titled exactly that, is part of a wider pattern that engineers, ML platform teams, and sustainability officers should read carefully. This is not a flagship-model announcement, and it does not promise a single breakthrough system. Instead, the signal is structural: a large AI organisation is spending real resources on a portfolio of efforts that tie artificial intelligence directly to environmental outcomes, and it has chosen Asia-Pacific as the proving ground.

What does that mean for engineering teams in the region? First, it means green AI has moved from academic commentary to a market position. Second, it means that the tools and habits we use to measure energy and carbon in our own work now deserve the same attention as accuracy metrics. This article unpacks what can be verified about the announcement, why the Asia-Pacific focus matters, and how you can apply the same “carbon-first” discipline to your own AI projects with an open, practical workflow.

What the announcement does and does not tell us

The primary source for this article is the Google AI Blog post, available at:

• Backing 16 green AI projects in Asia-Pacific — Google AI Blog

That source, which was accessible and verified, establishes the central fact: Google is backing 16 green AI projects in Asia-Pacific. The URL path also tells us something useful about the framing of the effort: the post lives under a section named ai-planet-accelerator-apac. In other words, these 16 projects fall within an ongoing “AI Planet Accelerator” effort aimed at the Asia-Pacific region.

Whenever a team announces a number like “16 projects,” the temptation is to list winners and describe their technology. This article deliberately does not do that. The source page carries a boasted article title but not, in the detail we can safely reproduce here, a fully itemised catalogue of all 16 teams, their countries, their funding amounts, or their technical stacks. The lesson for readers is methodological as much as editorial: distinguish the verified signal from the surrounding interpretation.

The verified signal is short and strong:

• 16 projects were selected or backed.
• They are described as green AI projects.
• The work is concentrated in Asia-Pacific.
• The announcement comes from Google’s AI Blog.
• The page’s path associates the effort with Google DeepMind / AI Planet Accelerator APAC.

Everything else in the public conversation — which country has the most represented teams, which environmental sector is favoured, what the accelerator’s acceptance rate was — should be treated with caution until confirmed by the original source or by a follow-up from Google. What we can do without speculation is build a technical reading of why an organisation would back 16 projects at once, and what that implies for the region’s AI community.

Green AI versus AI for green problems

“Green AI” is used loosely across the industry, and the ambiguity matters. There are two related but distinct directions of work:

1. Making AI itself greener. This covers efficient model architectures, smaller training runs, hardware-aware scaling, better data-centre utilisation, and carbon-aware scheduling. The goal is to reduce the environmental footprint of computation.
2. Using AI to solve environmental problems. This covers forecasting solar and wind output, detecting methane leaks, monitoring biodiversity, optimising agricultural water use, and improving disaster early-warning systems.

The 16 projects announced in the Asia-Pacific post likely live at the intersection of these two categories. A regional accelerator can fund projects that reduce the carbon cost of AI and projects that use AI to protect ecosystems. Without the full list in front of us, we should avoid claiming that all 16 fall into one bucket. But we can observe that the phrase “green AI projects” increasingly refers to a spectrum rather than a single discipline.

That spectrum is exactly what makes a multi-project strategy powerful. A single moonshot can fail. A portfolio of 16 smaller bets can test different models of sustainability — efficiency, measurement, climate adaptation, conservation — and let the strongest succeed through evidence rather than hype.

Why Asia-Pacific? Region as a test bed

Asia-Pacific is a sensible and arguably urgent home for this kind of experimentation. The region contains some of the world’s fastest-growing AI adoption markets, a dense concentration of data centres, and an immense diversity of electricity grids. Some countries in the region have access to abundant hydro or solar resources; others still rely heavily on coal-fired baseload power. Carbon intensity — the amount of CO₂ emitted per kilowatt-hour of electricity — can vary dramatically across borders and even within a single country across a single day.

This variation creates a technical challenge and an opportunity. For AI engineers, the carbon cost of training the same model can change entirely depending on where and when it runs. A job executed at the wrong hour on a dirty grid may emit several times more carbon than an identical job executed at a cleaner hour, without any change to the model code. In Asia-Pacific, this variability is not an abstract edge case. It is the daily reality for teams managing compute in Singapore, Tokyo, Mumbai, Sydney, Jakarta, or Seoul.

The regional push therefore makes technical sense: if you want to develop green AI practice that will scale globally, the best place to test it is a region where grid dynamics are complex, regulation is still evolving, and the potential for positive climate impact is high.

The portfolio strategy of 16 projects

Why 16 instead of one large flagship? A portfolio approach is a deliberate design choice with several advantages.

First, parallelism. Different green AI problems operate on different timescales. A carbon-accounting library might produce results in weeks, while a wildlife-monitoring system needs multiple seasons to prove itself. Funding 16 projects at once allows the organisation to hedge against unequal maturity.

Second, regional credibility. Asia-Pacific is not monolithic. Projects in the tropics worry about heat and cooling efficiency; island nations worry about grid stability and sea-level risk; agricultural economies worry about water and fertiliser. No single project can speak to all of these contexts. A geographically diverse portfolio gives the accelerator credibility across communities.

Third, is a different success measure. A large language model launch is measured by benchmarks. A green AI project is measured by kilowatt-hours saved, emissions avoided, or hectares monitored. These are messier metrics. Running many of them in parallel generates comparative data: which intervention yields the most decarbonisation per invested dollar? That comparison is more valuable than any single romantic success story.

Fourth, ecosystem building. Announcing 16 projects signals to universities, startups, and open-source contributors that the AI-for-climate field in Asia-Pacific has a seat at the table. That signal invites more applicants in the next cycle, strengthens local talent pipelines, and normalises the idea that a good machine learning paper is not only accurate but also accountable for its energy use.

Bringing the regional push into your own terminal

If you work in AI in Asia-Pacific, you do not need to wait for a formal accelerator to apply its principles. You can adopt the discipline in your own environment today. The remainder of this article shows a concrete workflow for measuring the carbon footprint of your experiments, inspecting power utilisation, and scheduling workloads for cleaner hours.

This workflow is offered as an engineering example, not as a description of the tools used by the 16 announced projects. It relies on real, installable open-source tools and standard Linux commands.

Requirements

For this setup you will need:

• A Linux machine (Debian or Ubuntu recommended) with sudo access.
• Python 3.9 or newer.
• A clean Python environment for your experiment.
• pip and the standard build packages.
• Optional: an NVIDIA GPU with nvidia-smi if you want GPU-level power readings.

If you are testing on a laptop or a branch without a GPU, the example still works — CodeCarbon will estimate CPU energy and memory influences, giving you a reasonable number for comparison between runs.

Step-by-step installation

First, update the system package index and install the base packages we need. This gives us Python tooling and powertop, a useful Linux tool for visualizing power consumption on the host.

sudo apt update
sudo apt install -y python3 python3-venv python3-pip powertop

Next, create a dedicated project directory and a virtual environment. Isolating dependencies means we can experiment without affecting your system Python.

mkdir -p ~/green-ml-demo
cd ~/green-ml-demo
python3 -m venv .venv
source .venv/bin/activate

Now upgrade the packaging tools and install the core measurement library. codecarbon is the tool we will use to track the estimated emissions of a running Python process.

pip install --upgrade pip setuptools wheel
pip install codecarbon psutil

Verify that the library is correctly installed and check the version available in the environment:

pip show codecarbon | grep -E "Name|Version"

You should see a version line printed, confirming the installation.

Usage examples

The simplest way to use CodeCarbon is inside a Python script. The following example simulates a small numerical workload — the kind of dense matrix operations a tiny training loop would perform — and measures its carbon cost from start to finish.

Create a file named track_train.py:

# track_train.py
import time

import numpy as np
from codecarbon import EmissionsTracker


def small_training_simulation(steps: int = 100):
    """A stand-in for a real training loop."""
    matrix = np.zeros((1500, 1500))
    for step in range(steps):
        matrix += np.random.normal(size=(1500, 1500)) / (step + 1)
        time.sleep(0.05)
    return matrix.sum()


if __name__ == "__main__":
    tracker = EmissionsTracker(
        project_name="green-ai-demo-apac",
        output_dir="emissions",
        log_level="error",
        save_to_api=False,
        measure_power_secs=10,
    )
    tracker.start()
    try:
        result = small_training_simulation()
        print(f"Workload finished with result: {result:.2f}")
    finally:
        kg_co2 = tracker.stop()
        print(f"Estimated emissions: {kg_co2:.4f} kg CO2-eq")

Run it:

python track_train.py

The script will print a numerical result and an estimated emissions value. By default, the tracker writes its detailed observations to a CSV file inside the emissions directory.

Look at the first lines of that file to understand what was recorded:

head -n 5 emissions/emissions.csv

You will see columns such as timestamp, duration_s, emissions, cpu_power, and gpu_power. These columns give you an audit trail for every experiment. If a colleague asks why a certain training run emitted a certain amount of carbon, you can answer with data rather than intuition.

Now make the measurement comparative. Green AI is not a single number — it is a practice of reducing that number. Run the same experiment twice: once with default settings, and then with a smaller matrix size or fewer steps. Compare the emissions column.

# compare_runs.py
import numpy as np
from codecarbon import EmissionsTracker


def workload(size: int, steps: int):
    matrix = np.random.normal(size=(size, size))
    for step in range(steps):
        matrix = matrix * matrix * 0.5 + np.ones_like(matrix)
    return matrix.std()


captured = {}
for name, size, steps in [("baseline", 1000, 400), ("efficient", 800, 300)]:
    tracker = EmissionsTracker(
        project_name=name,
        output_dir="emissions",
        log_level="error",
        save_to_api=False,
    )
    tracker.start()
    workload(size, steps)
    captured[name] = tracker.stop()
    print(f"{name}: {captured[name]:.4f} kg CO2-eq")

saved = captured["baseline"] - captured["efficient"]
print(f"Relative reduction: {(saved / captured['baseline']) * 100:.1f}%")

This kind of relative comparison is the heart of the green-engineering workflow. You will not always be able to change the grid your data centre uses, but you can reduce model size, batch less wastefully, and stop unnecessary experiment runs.

Next, check power utilisation at the system level. If you have an NVIDIA GPU, query its live power draw:

nvidia-smi --query-gpu=index,name,power.draw,utilization.gpu --format=csv -l 2

On a CPU-only machine, use powertop to capture a system-level estimate:

sudo powertop --csv=/tmp/powertop_measurement.csv

You can stop the capture with Ctrl+C after a few minutes and inspect the CSV file for platform power figures.

The final practical step is carbon-aware scheduling. In Asia-Pacific, grid carbon intensity often varies by hour of the day. If you cannot reduce compute, you can shift it. The following shell-level approach submits your experiment only during the hours you designate as cleaner — for example, late night, depending on the local grid mix.

Add a scheduled job with cron:

crontab -e

Then insert a line that changes the working directory, activates the environment, and runs your experiment:

20 3 * * * cd ~/green-ml-demo && . .venv/bin/activate && python track_train.py >> logs/train.log 2>&1

For more flexible control, use a Python supervisor script that polls the local time at a fixed interval and waits for the preferred window before launching the training job:

# wait_for_window.py
import datetime
import subprocess
import time

CLEAN_HOUR_BEGIN = 2
CLEAN_HOUR_END = 6


def in_clean_window(now: datetime.datetime) -> bool:
    return CLEAN_HOUR_BEGIN <= now.hour < CLEAN_HOUR_END


if __name__ == "__main__":
    while not in_clean_window(datetime.datetime.now()):
        print("Waiting for cleaner grid window...")
        time.sleep(600)  # check every 10 minutes
    subprocess.run(["python", "track_train.py"])

This is a simple illustration of a carbon-aware scheduler. In production, you would feed the script with real grid-intensity data for your location rather than a fixed hour rule. But the principle is correct: treat your experiment’s running time as an optimisation variable, not as a side effect of developer convenience.

From measurement to a regional habit

An announcement about 16 green AI projects creates momentum. But momentum without measurement is fragile. If the field truly wants sustainable innovation in Asia-Pacific, every funded project should report not only its model quality but also its energy intensity per unit of useful output. Researchers in the region should start asking: “What was the accuracy gain per kilowatt-hour?” and “Could the same result have been achieved with a smaller model on a cleaner grid?”

These habits scale better than any single grant. When you record emissions alongside model checkpoints, you create a culture. When you reward engineers for reducing experiment time as well as improving accuracy, you align business incentives with environmental ones. The 16 projects in the announcement are a beginning, not an end. They function as both a proof of concept and a demand on the wider community to build the measurement infrastructure that green AI needs.

The practical takeaway is simple. You do not need to be part of an accelerator to ship a green AI workflow. You need a tracking library, a decision to measure every run, and the honesty to compare your results against a baseline. Asia-Pacific is a region with high compute growth, urgent climate exposure, and profoundly heterogeneous grids. That makes it the perfect place to turn “green AI” from a slogan into a comparative engineering metric — one experiment at a time.

Conclusion

The announcement that 16 green AI projects are being backed in Asia-Pacific is a clear regional signal of intent. What we can verify from the source is concise: the count, the geography, the topic, and the association with an AI Planet Accelerator initiative. What we should infer is broader: the AI community is shifting from celebrating raw compute toward rewarding responsible compute.

An engineering response means putting that inference into practice. Track your emissions. Compare runs. Query your GPU power. Schedule work for less carbon-heavy windows. The tools are real, open, and installable today. You can start with a virtual environment and a single experiment — then measure your improvement as rigorously as you measure your model’s accuracy.

The 16 projects announced by Google are part of a regional push for sustainable innovation. The equally important push will happen inside every machine learning team that decides to make carbon a first-class metric in the development loop.