works**: Using a grounded 150W runner baseline and IEA 2024 carbon intensity (475 gCO2/kWh) produces mathematically verifiable emissions data per job.

• Hidden waste is quantifiable: Claude identified a sleep 60 command responsible for 77% of a pipeline's total CO2, proving that AI-driven pattern detection surfaces optimization opportunities traditional logs miss.
• Multi-agent separation is critical: Routing pipeline_fetcher → carbon_calculator → report_publisher via from/as bindings eliminates prompt overload, ensuring structured markdown tables and precise optimization tips on every run.
• Zero-infrastructure deployment: The entire system runs as 2 YAML files on GitLab Duo, requiring no servers, databases, or maintenance overhead.

Core Solution

Carbon Tracker implements a genuine multi-agent orchestration flow on the GitLab Duo Agent Platform. The architecture chains three specialized AgentComponent steps, passing state via explicit from/as input bindings and router definitions.

Architecture Flow

1. pipeline_fetcher: Triggers on @ai-carbon-tracker-flow mention. Uses get_merge_request and list_merge_requests tools to extract job names, durations, statuses, and retry counts.
2. carbon_calculator: Receives pipeline data. Applies the physics-based energy model, detects waste patterns (e.g., artificial sleeps, config-only triggers, unnecessary deploys), and generates a structured markdown report.
3. report_publisher: Receives the carbon report. Uses create_merge_request_note and create_issue_note tools to post the analysis directly to the MR/Issue thread.

The Carbon Model

The calculation relies on three deterministic steps:

• Energy per job: E(kWh) = (duration_seconds / 3600) × (150W / 1000)
• CO2 per job: CO2(g) = E(kWh) × 475
• Waste multiplier: CO2_total = CO2_job × (1 + N_retries)

Constants Reference:

Parameter	Value	Source
Runner wattage	150W	Typical shared GitLab runner
Carbon intensity	475 gCO2/kWh	IEA Global Average 2024
Km equivalent	CO2g ÷ 150	Average car: 150gCO2/km

Implementation Code

flow.yml — The 3-Agent Orchestration

name: "Carbon Tracker Flow"
description: "Calculates CO2 emissions per CI/CD pipeline job."
public: true
definition:
  version: v1
  environment: ambient
  components:
    - name: "pipeline_fetcher"
      type: AgentComponent
      prompt_id: "fetch_prompt"
      inputs:
        - from: "context:goal"
          as: "goal"
      toolset:
        - "get_merge_request"
        - "list_merge_requests"
      ui_log_events:
        - on_agent_final_answer

    - name: "carbon_calculator"
      type: AgentComponent
      prompt_id: "calculate_prompt"
      inputs:
        - from: "context:goal"
          as: "goal"
        - from: "pipeline_fetcher:output"
          as: "pipeline_data"
      ui_log_events:
        - on_agent_final_answer

    - name: "report_publisher"
      type: AgentComponent
      prompt_id: "publish_prompt"
      inputs:
        - from: "context:goal"
          as: "goal"
        - from: "carbon_calculator:output"
          as: "carbon_report"
      toolset:
        - "create_merge_request_note"
        - "create_issue_note"
      ui_log_events:
        - on_agent_final_answer

  routers:
    - from: "pipeline_fetcher"
      to: "carbon_calculator"
    - from: "carbon_calculator"
      to: "report_publisher"
    - from: "report_publisher"
      to: "end"

  flow:
    entry_point: "pipeline_fetcher"

agent.yml — The Standalone Agent

yaml
name: "Carbon Tracker Agent"
description: "Calculates CO2 emissions for CI/CD pipeline jobs."
public: true
system_prompt: |
  You are the Carbon Tracker Agent running inside GitLab Duo.
  Calculate CO2 per job:
    energy_kwh = (duration_seconds / 3600) * 150 / 1000
    co2_grams  = energy_kwh * 475
  Generate a markdown report with job breakdown and tips.
  End with: "🤖 Carbon Tracker · GitLab Duo + Claude (Anthropic)"

Architecture Decision: Why 3 Agents Instead of 1? A single agent attempting to fetch data, run calculations, and format reports suffers from context window fragmentation and prompt instruction dilution. Separating concerns across three agents produces dramatically better output quality from Claude. Each prompt is laser-focused on one task, ensuring deterministic routing, reliable tool execution, and consistent markdown formatting.

Pitfall Guide

1. YAML Toolset Schema Misconfiguration: The toolset array format for custom flows is strict and undocumented. Unquoted strings or nested objects will fail schema validation. Always use quoted strings: - "get_merge_request".
2. Monolithic Prompt Overload: Combining data fetching, mathematical modeling, and report publishing in a single system prompt causes context drift and formatting failure. Isolate each responsibility into its own AgentComponent.
3. Ignoring Infrastructure Power Baselines: GitLab's API does not expose runner wattage. Do not guess; use physically grounded benchmarks (e.g., 150W for shared runners) and document the assumption to maintain scientific credibility.
4. Static Global Carbon Intensity: Hardcoding 475 gCO2/kWh ignores regional grid differences. Plan for region-aware overrides using runner metadata or GitLab CI/CD variables to improve accuracy for distributed teams.
5. Missing Retry/Waste Multipliers: Failing to account for flaky test retries underestimates emissions by 2–3x. Always apply the CO2_total = CO2_job × (1 + N_retries) multiplier to surface true waste patterns.
6. Over-Provisioning Infrastructure: Building a backend service or database for a stateless calculation adds latency, cost, and maintenance overhead. Leverage GitLab Duo's serverless YAML flows to keep the system ephemeral and zero-maintenance.

Deliverables

• 📘 Multi-Agent Orchestration Blueprint: Step-by-step architecture guide for chaining AgentComponent steps via from/as bindings and router definitions on GitLab Duo.
• ✅ Pre-Deployment Validation Checklist: Schema verification steps, prompt isolation rules, carbon constant sourcing guidelines, and tool permission mapping.
• ⚙️ Configuration Templates: Production-ready flow.yml and agent.yml files, plus a constants reference table for runner wattage, regional carbon intensity, and waste multipliers. Ready to fork and deploy.