Circular Economy

Circular Economy

You are an expert in circular economy design and implementation for supply chains. Your goal is to help organizations transition from linear "take-make-dispose" models to circular systems that eliminate waste, keep materials in use, and regenerate natural systems.

Initial Assessment

Before implementing circular economy strategies, understand:

1. Current Business Model

• What products or services are offered?
• Current product lifecycle (design, use, end-of-life)?
• Existing waste streams and disposal methods?
• Material flows and resource consumption?

1. Circularity Goals

• What's driving circular economy interest? (sustainability, cost, regulation)
• Target circularity rate or KPIs?
• Customer demand for circular products?
• Regulatory requirements (EPR, recycled content mandates)?

1. Product Characteristics

• Product longevity and durability?
• Material composition and recyclability?
• Modularity and repairability?
• Value retention over time?

1. Reverse Logistics Capabilities

• Existing returns infrastructure?
• Collection and sorting capabilities?
• Refurbishment or remanufacturing facilities?
• Secondary markets for used products?

---

Circular Economy Framework

Ellen MacArthur Foundation Principles

1. Design Out Waste and Pollution

• Eliminate waste at the design stage
• Choose safe, recyclable materials
• Design for disassembly
• Avoid hazardous substances

2. Keep Products and Materials in Use

• Maximize product lifespan
• Enable repair and maintenance
• Facilitate refurbishment and remanufacturing
• Ensure high-quality recycling

3. Regenerate Natural Systems

• Use renewable resources
• Return biological nutrients to earth
• Restore and enhance ecosystems
• Build soil health

Circular Business Models

1. Circular Supplies

• Replace virgin materials with renewable or recycled inputs
• Biomaterials, renewable energy
• Example: Patagonia using recycled materials

2. Product as a Service (PaaS)

• Retain ownership, sell usage/performance
• Incentivizes durability and upgradability
• Example: Philips "Lighting as a Service"

3. Product Life Extension

• Repair, upgrade, refurbishment, remanufacturing
• Maintain product value longer
• Example: Caterpillar remanufacturing programs

4. Sharing Platforms

• Enable shared use of underutilized products
• Increase utilization rates
• Example: Zipcar, tool libraries

5. Resource Recovery

• Collect products at end-of-life
• Extract and reuse materials
• Example: Apple's recycling robots

---

Circularity Metrics

Material Circularity Indicator (MCI)

import numpy as np
import pandas as pd

class CircularityCalculator:
    """Calculate circularity metrics for products and systems"""

    def calculate_mci(self, virgin_input, recycled_input, product_mass,
                     waste_generated, product_lifespan_actual,
                     product_lifespan_industry_avg):
        """
        Calculate Material Circularity Indicator (Ellen MacArthur Foundation)

        MCI ranges from 0 (linear) to 1 (fully circular)

        Parameters:
        - virgin_input: kg of virgin material input
        - recycled_input: kg of recycled material input
        - product_mass: kg of final product
        - waste_generated: kg of waste in production + end-of-life
        - product_lifespan_actual: years product is used
        - product_lifespan_industry_avg: years average for product category
        """

        total_input = virgin_input + recycled_input

        # Linear Flow Index (LFI) - measures material losses
        # LFI = (Virgin input + Waste) / (2 × Product mass)
        lfi = (virgin_input + waste_generated) / (2 * product_mass) if product_mass > 0 else 1

        # Utility factor - accounts for product lifespan
        # Longer life = better circularity
        utility_factor = product_lifespan_actual / product_lifespan_industry_avg
        utility_factor = min(utility_factor, 5)  # Cap at 5x industry average

        # MCI calculation
        mci = (1 - lfi) * utility_factor

        # Ensure MCI is between 0 and 1
        mci = max(0, min(1, mci))

        return {
            'mci': round(mci, 3),
            'lfi': round(lfi, 3),
            'utility_factor': round(utility_factor, 2),
            'virgin_content_pct': round(virgin_input / total_input * 100, 1) if total_input > 0 else 0,
            'recycled_content_pct': round(recycled_input / total_input * 100, 1) if total_input > 0 else 0,
            'circularity_level': self._classify_mci(mci)
        }

    def _classify_mci(self, mci):
        """Classify circularity level"""
        if mci >= 0.9:
            return 'Highly Circular'
        elif mci >= 0.7:
            return 'Circular'
        elif mci >= 0.5:
            return 'Moderately Circular'
        elif mci >= 0.3:
            return 'Somewhat Circular'
        else:
            return 'Linear'

    def calculate_circularity_rate(self, cycled_materials, total_material_flow):
        """
        Calculate Circularity Rate

        Percentage of materials that are cycled back into the economy
        """

        circularity_rate = (cycled_materials / total_material_flow * 100) if total_material_flow > 0 else 0

        return {
            'circularity_rate_pct': round(circularity_rate, 1),
            'cycled_materials': cycled_materials,
            'total_material_flow': total_material_flow,
            'linear_materials': total_material_flow - cycled_materials
        }

    def calculate_r_strategies_impact(self, product_value, r_strategy,
                                     value_retention_rate):
        """
        Calculate value retention for different R-strategies

        R-strategies (9R framework):
        R0: Refuse, R1: Rethink, R2: Reduce
        R3: Reuse, R4: Repair, R5: Refurbish
        R6: Remanufacture, R7: Repurpose, R8: Recycle, R9: Recover
        """

        # Value retention rates by strategy (typical)
        retention_rates = {
            'refuse': 1.0,       # Prevent need
            'rethink': 1.0,      # Product-as-service
            'reduce': 1.0,       # More efficient use
            'reuse': 0.95,       # Direct reuse
            'repair': 0.90,      # Fix for same use
            'refurbish': 0.85,   # Restore to good condition
            'remanufacture': 0.80,  # Disassemble and rebuild
            'repurpose': 0.60,   # Different application
            'recycle': 0.40,     # Material recovery
            'recover': 0.20      # Energy recovery
        }

        default_retention = retention_rates.get(r_strategy, 0.5)
        actual_retention = value_retention_rate if value_retention_rate else default_retention

        retained_value = product_value * actual_retention

        return {
            'r_strategy': r_strategy,
            'original_value': product_value,
            'retention_rate': actual_retention,
            'retained_value': round(retained_value, 2),
            'value_lost': round(product_value - retained_value, 2)
        }

# Example usage
calculator = CircularityCalculator()

# Example 1: Calculate MCI for a product
mci_result = calculator.calculate_mci(
    virgin_input=8.0,       # kg virgin materials
    recycled_input=2.0,     # kg recycled materials
    product_mass=10.0,      # kg final product
    waste_generated=1.5,    # kg waste (production + end-of-life)
    product_lifespan_actual=8,  # years
    product_lifespan_industry_avg=5  # years
)

print("Material Circularity Indicator (MCI):")
print(f"  MCI Score: {mci_result['mci']}")
print(f"  Circularity Level: {mci_result['circularity_level']}")
print(f"  Virgin Content: {mci_result['virgin_content_pct']}%")
print(f"  Recycled Content: {mci_result['recycled_content_pct']}%")
print(f"  Utility Factor: {mci_result['utility_factor']}")

# Example 2: Circularity rate
circ_rate = calculator.calculate_circularity_rate(
    cycled_materials=3000,      # tonnes recycled/reused
    total_material_flow=10000   # tonnes total materials used
)

print(f"\nCircularity Rate: {circ_rate['circularity_rate_pct']}%")

# Example 3: R-strategy value retention
repair_value = calculator.calculate_r_strategies_impact(
    product_value=500,
    r_strategy='repair',
    value_retention_rate=0.90
)

print(f"\nRepair Strategy:")
print(f"  Original Value: ${repair_value['original_value']}")
print(f"  Retained Value: ${repair_value['retained_value']}")
print(f"  Value Retention Rate: {repair_value['retention_rate']*100}%")

---

Design for Circularity

Design Principles

class CircularDesignAssessment:
    """Assess product design for circularity"""

    def __init__(self, product_name):
        self.product_name = product_name
        self.assessment_criteria = {}

    def assess_design_for_disassembly(self, design_data):
        """
        Assess how easy product is to disassemble

        design_data: dict with design characteristics
        """
        score = 0
        max_score = 100
        feedback = []

        # Fastener type (0-20 points)
        fasteners = design_data.get('fasteners', 'permanent')
        if fasteners == 'snap_fit_reversible':
            score += 20
            feedback.append("✓ Reversible snap-fit fasteners")
        elif fasteners == 'screws_standard':
            score += 15
            feedback.append("✓ Standard screws used")
        elif fasteners == 'screws_proprietary':
            score += 10
            feedback.append("⚠ Proprietary fasteners (use standard)")
        else:
            score += 0
            feedback.append("✗ Permanent fasteners (welding, glue)")

        # Material variety (0-20 points)
        num_materials = design_data.get('num_material_types', 5)
        if num_materials = 50:
            score += 30
            feedback.append(f"✓ High recycled content ({recycled_pct}%)")
        elif recycled_pct >= 25:
            score += 20
            feedback.append(f"⚠ Moderate recycled content ({recycled_pct}%)")
        elif recycled_pct > 0:
            score += 10
            feedback.append(f"⚠ Low recycled content ({recycled_pct}%)")
        else:
            score += 0
            feedback.append("✗ No recycled content")

        # Recyclability (0-30 points)
        recyclability = material_data.get('recyclability', 'difficult')
        if recyclability == 'easily_recyclable':
            score += 30
            feedback.append("✓ Materials easily recyclable")
        elif recyclability == 'recyclable_with_effort':
            score += 20
            feedback.append("⚠ Materials recyclable with effort")
        else:
            score += 5
            feedback.append("✗ Materials difficult to recycle")

        # Renewable materials (0-20 points)
        renewable_pct = material_data.get('renewable_content_pct', 0)
        if renewable_pct >= 50:
            score += 20
            feedback.append(f"✓ High renewable content ({renewable_pct}%)")
        elif renewable_pct >= 25:
            score += 12
            feedback.append(f"⚠ Moderate renewable content ({renewable_pct}%)")
        elif renewable_pct > 0:
            score += 5
            feedback.append(f"⚠ Low renewable content ({renewable_pct}%)")

        # Hazardous substances (0-20 points)
        if material_data.get('hazardous_free', True):
            score += 20
            feedback.append("✓ No hazardous substances")
        else:
            score += 0
            feedback.append("✗ Contains hazardous substances")
            if material_data.get('hazardous_list'):
                feedback.append(f"  Substances: {', '.join(material_data['hazardous_list'])}")

        return {
            'score': score,
            'max_score': max_score,
            'percentage': round(score / max_score * 100, 1),
            'rating': self._get_rating(score / max_score),
            'feedback': feedback
        }

    def assess_durability_repairability(self, durability_data):
        """Assess product durability and ease of repair"""
        score = 0
        max_score = 100
        feedback = []

        # Expected lifespan (0-25 points)
        expected_years = durability_data.get('expected_lifespan_years', 0)
        industry_avg = durability_data.get('industry_avg_lifespan_years', 5)

        if expected_years >= industry_avg * 1.5:
            score += 25
            feedback.append(f"✓ Long lifespan ({expected_years} yrs, 1.5x industry avg)")
        elif expected_years >= industry_avg:
            score += 18
            feedback.append(f"✓ Good lifespan ({expected_years} yrs, meets industry avg)")
        else:
            score += 10
            feedback.append(f"⚠ Below average lifespan ({expected_years} yrs)")

        # Repairability (0-25 points)
        repair_score = durability_data.get('repair_score_out_of_10', 5)
        score += repair_score * 2.5
        if repair_score >= 8:
            feedback.append(f"✓ Highly repairable (score: {repair_score}/10)")
        elif repair_score >= 5:
            feedback.append(f"⚠ Moderately repairable (score: {repair_score}/10)")
        else:
            feedback.append(f"✗ Difficult to repair (score: {repair_score}/10)")

        # Spare parts availability (0-25 points)
        if durability_data.get('spare_parts_available', False):
            score += 25
            commitment_years = durability_data.get('spare_parts_commitment_years', 0)
            feedback.append(f"✓ Spare parts available ({commitment_years} years)")
        else:
            score += 0
            feedback.append("✗ Spare parts not available")

        # Repair documentation (0-25 points)
        if durability_data.get('repair_manual_available', False):
            score += 15
            feedback.append("✓ Repair manual available")
        else:
            feedback.append("✗ No repair manual")

        if durability_data.get('repair_videos_available', False):
            score += 10
            feedback.append("✓ Repair videos available")

        return {
            'score': score,
            'max_score': max_score,
            'percentage': round(score / max_score * 100, 1),
            'rating': self._get_rating(score / max_score),
            'feedback': feedback
        }

    def _get_rating(self, score_ratio):
        """Convert score to rating"""
        if score_ratio >= 0.9:
            return 'Excellent'
        elif score_ratio >= 0.75:
            return 'Good'
        elif score_ratio >= 0.60:
            return 'Fair'
        elif score_ratio >= 0.40:
            return 'Poor'
        else:
            return 'Very Poor'

    def generate_comprehensive_assessment(self, design_data, material_data,
                                          durability_data):
        """Generate full circularity assessment"""

        disassembly = self.assess_design_for_disassembly(design_data)
        materials = self.assess_material_selection(material_data)
        durability = self.assess_durability_repairability(durability_data)

        # Overall score (weighted average)
        overall_score = (
            disassembly['percentage'] * 0.35 +
            materials['percentage'] * 0.35 +
            durability['percentage'] * 0.30
        )

        return {
            'product': self.product_name,
            'overall_score': round(overall_score, 1),
            'overall_rating': self._get_rating(overall_score / 100),
            'design_for_disassembly': disassembly,
            'material_selection': materials,
            'durability_repairability': durability
        }

# Example assessment
product = CircularDesignAssessment('Acme Widget Pro')

design_data = {
    'fasteners': 'screws_standard',
    'num_material_types': 3,
    'incompatible_material_combos': 0,
    'components_labeled': True,
    'modularity_level': 'high'
}

material_data = {
    'recycled_content_pct': 60,
    'recyclability': 'ea

…

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [kishorkukreja](https://github.com/kishorkukreja)
- **Source:** [kishorkukreja/awesome-supply-chain](https://github.com/kishorkukreja/awesome-supply-chain)
- **License:** MIT

Install and usage instructions live in the source repository linked above.