Write your awesome label here.
Green AI

Design agentic systems that finish the task on fewer steps, fewer tokens and less energy.

One completed task as the unit, eleven design levers, grounded in SCI for AI. From whether the agent is needed at all, through decomposition, tool surface, context, retrieval, termination, routing, failure and placement, to proving the change — plus an optional lab where you watch the number move, and a capstone on one of your own features.
9-11h 40m
of learning
13
modules
30 questions
final assessment
80%
to pass
Credential
on completion

Designing and Developing Green and Efficient Agentic Systems

What
How
Tools
Who

How the course works

Framework-neutral

The levers apply whatever you build on. One worked implementation illustrates them; nothing depends on a particular agent framework.

One system throughout

The Northbridge support-triage agent, at 4,200 tickets a day, carries every worked example and every exercise.

An optional lab where the numbers are live

Nine exercises against a running agent take the worked baseline from 2.925 to 0.362 gCO₂e per completed task. Every figure printed in the module is an output of the code that ships.

What this course helps with

The loop you did not need to build

Much of what an agent spends is a deterministic process wearing a loop — steps that were known in advance, rediscovered on every request. Module 2 asks for the number instead of the opinion.

Cost that accumulates per step

Context that grows every turn, tool definitions re-read, retrieval that returns more than it needs, retries that repeat work already done. Each is a lever with a measurable effect.

A figure you can show

Energy and carbon per completed task, with the boundary, method and date recorded — so the reduction can be checked rather than asserted.

Who this is for

  • Architects designing agentic systems and developers building them

  • Teams putting an agent into production and answering for its cost and footprint

  • Platform engineers setting defaults for agents across several teams

  • Assumes working familiarity with LLM applications; no measurement background required

Related courses:

For how to obtain the numbers this course asks you to move, see SCI for AI Practitioner: The Measurement Lab. For fleet-level operations and placement policy, see GreenOps Practitioner. For the water dimension of a placement change, see Software Water Foundations.

What you will work with

The agent decision test

Sample real runs, count distinct sequences, cost the deterministic version, and write the benefit sentence for whatever remains.

The accumulation curve

How context, tools and retrieval compound across a run, and where compaction, projection and scoping cut in.

The lab harness

Prefill split into cached and uncached reads, decode, steps, tool calls, retries and cost per completed task — with an SCI figure computed on stated coefficients.

What you will be able to do

  • Cost a deterministic alternative before committing to an agent, and state when autonomy earns its cost
  • Choose between single, pipeline and multi-agent decomposition on evidence
  • Scope a tool surface and a context policy so they stop growing per step
  • Set termination rules and budgets that end a run without abandoning the task
  • Route model and reasoning depth per step rather than per system
  • Handle retry and idempotency so failures do not pay twice
  • Attribute a footprint to a feature and prove a reduction on the same basis

Course Lessons

The full course

Every module ends with an application exercise and a worked solution.

01

Where ML’s Footprint Is Decided

A model’s footprint is created twice: once when it is trained, and again on every inference it serves. This module sets the decision metric and the amortisation rule that every later module is judged against.
module-01

02

Reuse, Adapt, or Train: The First Decision

The largest reduction available on the training side is not to train, yet the question is usually settled by habit before anyone computes it. This module compares six routes to a working model and what to ask of a base model before inheriting its cost.
module-02

03

Sizing the Model and the Data Budget

How large a model, trained on how much data, sets the energy term more directly than any later choice. This module covers compute-optimal sizing and how architecture changes training and serving energy independently of parameter count.
module-03

04

Data Efficiency: What the Model Is Trained On

What the training tokens actually are changes both how many are needed and how good the resulting model is. This is the layer where the footprint lever and the quality lever most often point in the same direction, and this module is careful about where that alignment breaks.
module-04

05

The Training Run: Execution, Stopping and Waste

This module examines the compute that produces nothing: epochs past convergence, crashes without a checkpoint, and experiments that repeat work already done. Waste at this layer is invisible in a cost report, because a failed run and a successful one look identical on the bill.
module-05

06

Search and Evaluation: The Two Multipliers

Earlier modules reduce the cost of one run; this one addresses how many runs happen, which is usually the larger number. It covers search budgets, comparing strategies by cost per answer, and evaluation as a cost that recurs for the life of the model.
module-06

07

Hardware-Aware Training

Compute demanded is one quantity; how efficiently it becomes energy is another. This module covers precision, batch size, accelerator fit and utilisation as the conversion factor sitting between the two.
module-07

08

When and Where to Train

This is the one lever that changes carbon without changing energy, by moving a run to a different hour or region. Training is often a strong candidate, and this module covers the constraints that decide it, along with water, preemptible capacity and embodied allocation.
module-08

09

From Weights to Deployable Artifact

This module deliberately spends training cost once in order to reduce serving cost on every inference that follows. It covers parameter-efficient adaptation, post-training and compression, and the repayment calculation that decides whether the trade is worth making.
module-09

10

Lifecycle, Retirement and Disclosure

Retraining cadence multiplies the training footprint, and retirement is the point at which every amortisation estimate becomes a measured fact. This closing module covers cadence, drift, registry and model card records, disclosure duties, and the capstone footprint report.
module-10

11

Final Assessment

A final assessment of 30 scenario-judgement questions - 80% to pass, 60 minutes, retake available.

Assessment and certificate

How you are assessed

  • A five-question knowledge check after every module, drawn at random from that module’s 15-question pool
  • A final assessment of 30 questions — two from each credential-bearing module plus six cross-module synthesis questions, so every attempt covers every required module
  • 80% to pass, 60 minutes, retake available
  • Drawn from a bank of 253 questions; scenario, numerical and synthesis rather than recall of figures that date

What you earn

GSF Certified
Green Agentic Systems Practitioner
  • Issued on passing the final assessment
  • Valid for 24 months, refreshed by a short update module
  • Shareable credential for your profile, CV and tender responses

Time to complete

Reading and exercises
9–11h across 13 modules
Knowledge checks
About 5 minutes per module
Final assessment
60 minutes
Typical completion
3–4 weeks at a module per session, entirely self-paced
Optional lab
40 minutes guided, plus 1–2 hours working the exercises

Join the Pilot

The GSF Academy is currently in pilot. If your organization would like to enrol learners and issue GSF certifications to your teams, tell us a little about what you need and we'll follow up to discuss access, pricing, and enrolment.

Request Access for Your Organization

First name
Last name
Work email
Tell us about your organisation
Thank you.

We will be in touch shortly