TML Developer Quickstart - Implementation Guide

Path: /training/Developer_Quickstart.md
Version: 2.0.0
Creator: Lev Goukassian (ORCID: 0009-0006-5966-1243)
Last Updated: 2025-09-27

Note: All financial values are nominal to 2025 USD

Implementation Objectives

A functional application with:

✅ Sacred Zero discrimination prevention
✅ Blockchain-anchored audit logs
✅ Environmental impact tracking
✅ Automatic penalty enforcement
✅ Compliance reporting capability
✅ Recommended Stewardship Council integration

Deployment architecture: Blockchain-based with recommended six-member Stewardship Council oversight

Prerequisites (2 minutes to verify)

# Check you have ONE of these languages installed:
node --version   # 16+ for JavaScript
python --version # 3.8+ for Python  
java --version   # 11+ for Java
go version       # 1.19+ for Go

# Check Docker (required)
docker --version # 20.10+

Part 1: Framework Deployment (5 minutes)

Step 1: Pull and Run TML

# Option A: Basic deployment
docker run -d -p 8080:8080 --name tml tml/protection:latest

# Option B: With Stewardship Council (Recommended)
cat > tml.env << EOF
TML_BLOCKCHAIN_MODE=true
TML_DISCRIMINATION_THRESHOLD=0.2
TML_CARBON_THRESHOLD_KG=1000
TML_BLOCK_ON_SACRED_ZERO=true
TML_STEWARDSHIP_COUNCIL=recommended
TML_COUNCIL_NODES=6
EOF

docker run -d -p 8080:8080 --env-file tml.env --name tml tml/protection:latest

Step 2: Verify Operation

# Health check
curl http://localhost:8080/health
# Expected: {"status":"protecting","sacred_zero":"active","stewardship":"ready"}

# Test discrimination detection
curl -X POST http://localhost:8080/evaluate \
  -H "Content-Type: application/json" \
  -d '{
    "operation": "test",
    "data": {"race": "minority", "score": 400},
    "baseline": {"race": "majority", "score": 800}
  }'
# Expected: {"sacred_zero_triggered": true, "stewardship_review": "recommended", ...}

Protection is now active with recommended Stewardship Council oversight prepared.

Part 2: SDK Integration (10 minutes)

JavaScript/Node.js

npm install tml-protection

// app.js
const TML = require('tml-protection');

// Initialize with recommended Stewardship Council
const tml = new TML({
  blockchainMode: true,
  endpoint: 'http://localhost:8080',
  stewardshipCouncil: {
    enabled: true,
    mode: 'recommended',
    nodes: {
      technicalCustodian: 'eff',
      humanRights: 'amnesty',
      earthProtection: 'ien',
      aiEthics: 'mit-media-lab',
      memorialFund: 'mskcc',
      community: 'elected'
    }
  }
});

// Protect decisions
async function makeDecision(userData) {
  // Business logic
  const decision = calculateScore(userData);
  
  // Sacred Zero evaluation with Stewardship Council review
  const check = await tml.evaluate({
    operation: 'credit_decision',
    data: userData,
    decision: decision
  });
  
  if (check.sacredZeroTriggered) {
    // Discrimination detected
    console.error('Sacred Zero Violation:', check.evidence);
    console.log('Stewardship Council notified:', check.councilNotification);
    throw new Error('Decision blocked by discrimination prevention');
  }
  
  // Log approved decision
  await tml.log('Decision approved', {
    userId: userData.id,
    score: decision.score,
    stewardshipReview: check.stewardshipReview
  });
  
  return decision;
}

// Environmental tracking with Earth Protection Partner review
async function trainModel(dataset) {
  const startTime = Date.now();
  
  // ML training
  const model = await performTraining(dataset);
  
  // Track impact - routed to Earth Protection Enforcement Partner
  await tml.logEnvironmental({
    operation: 'model_training',
    duration: Date.now() - startTime,
    carbon_kg: estimateCarbon(),
    gpu_hours: 8,
    stewardshipReview: 'earth_protection_partner'
  });
  
  return model;
}

Python/FastAPI

pip install tml-protection

# app.py
from fastapi import FastAPI, HTTPException
from tml_protection import TMLClient

app = FastAPI()

# Initialize TML with Stewardship Council (Recommended)
tml = TMLClient(
    blockchain_mode=True,
    endpoint="http://localhost:8080",
    stewardship_council={
        "enabled": True,
        "mode": "recommended",
        "nodes": {
            "technical_custodian": "eff",
            "human_rights": "amnesty",
            "earth_protection": "ien",
            "ai_ethics": "stanford-hai",
            "memorial_fund": "mskcc",
            "community": "elected"
        }
    }
)

@app.post("/api/loan")
async def loan_decision(application: dict):
    # Business logic
    decision = score_application(application)
    
    # Sacred Zero check with Stewardship Council
    check = await tml.evaluate({
        "operation": "loan_approval",
        "data": application,
        "decision": decision
    })
    
    if check["sacred_zero_triggered"]:
        # Log violation - Human Rights Partner notified
        await tml.log_fatal(
            "Loan discrimination detected",
            evidence=check["evidence"],
            council_notification=check["council_notification"]
        )
        raise HTTPException(403, "Discriminatory decision blocked")
    
    # Log clean decision
    await tml.log("Loan processed", {
        "application_id": application["id"],
        "approved": decision["approved"],
        "stewardship_review": check.get("stewardship_review", "not_required")
    })
    
    return decision

@app.get("/api/compliance")
async def compliance_report():
    # Generate report with Stewardship Council validation
    return await tml.generate_compliance_report(
        framework="EU_AI_ACT",
        include_blockchain_proofs=True,
        include_stewardship_validation=True
    )

Java/Spring Boot

<!-- pom.xml -->
<dependency>
    <groupId>org.tml</groupId>
    <artifactId>tml-protection</artifactId>
    <version>2.0.0</version>
</dependency>

// DecisionController.java
import org.tml.protection.*;

@RestController
public class DecisionController {
    
    private final TMLClient tml = TMLClient.builder()
        .blockchainMode(true)
        .endpoint("http://localhost:8080")
        .stewardshipCouncil(StewardshipCouncil.builder()
            .enabled(true)
            .mode(StewardshipMode.RECOMMENDED)
            .technicalCustodian("eff")
            .humanRightsPartner("amnesty")
            .earthProtectionPartner("ien")
            .aiEthicsPartner("mit-media-lab")
            .memorialFundAdmin("mskcc")
            .communityRep("elected")
            .build())
        .build();
    
    @PostMapping("/api/hiring")
    public HiringDecision evaluateCandidate(@RequestBody Candidate candidate) {
        // Evaluation logic
        HiringDecision decision = evaluateResume(candidate);
        
        // Sacred Zero check with Stewardship Council
        SacredZeroResult check = tml.evaluate(
            "hiring_decision",
            candidate,
            decision
        );
        
        if (check.isTriggered()) {
            // Violation detected - Human Rights Partner notified
            tml.logFatal("Hiring discrimination", 
                check.getEvidence(),
                check.getCouncilNotification());
            throw new SacredZeroViolationException(
                "Discriminatory hiring practice detected - " +
                "Stewardship Council notified"
            );
        }
        
        // Log decision
        tml.log("Candidate evaluated", Map.of(
            "candidateId", candidate.getId(),
            "decision", decision.getOutcome(),
            "stewardshipReview", check.getStewardshipReview()
        ));
        
        return decision;
    }
    
    @GetMapping("/api/compliance/report")
    public ComplianceReport getComplianceDocument() {
        // Generate compliance documentation with Council validation
        return tml.generateComplianceReport()
            .withViolations(0)
            .withBlockchainProof(true)
            .withStewardshipValidation(true)
            .build();
    }
}

Go

go get github.com/tml/protection

// main.go
package main

import (
    "github.com/tml/protection"
    "net/http"
    "encoding/json"
)

func main() {
    // Initialize TML with Stewardship Council
    tml := protection.NewClient(protection.Config{
        BlockchainMode: true,
        Endpoint: "http://localhost:8080",
        StewardshipCouncil: protection.CouncilConfig{
            Enabled: true,
            Mode: protection.Recommended,
            TechnicalCustodian: "eff",
            HumanRightsPartner: "amnesty",
            EarthProtectionPartner: "ien",
            AIEthicsPartner: "stanford-hai",
            MemorialFundAdmin: "mskcc",
            CommunityRep: "elected",
        },
    })
    
    http.HandleFunc("/api/decision", func(w http.ResponseWriter, r *http.Request) {
        var req DecisionRequest
        json.NewDecoder(r.Body).Decode(&req)
        
        // Business logic
        decision := processRequest(req)
        
        // Sacred Zero check with Council oversight
        check, err := tml.Evaluate(protection.EvalRequest{
            Operation: "user_decision",
            Data: req,
            Decision: decision,
        })
        
        if check.SacredZeroTriggered {
            // Violation detected - Stewardship Council notified
            tml.LogFatal("Discrimination detected", 
                check.Evidence,
                check.CouncilNotification)
            http.Error(w, "Sacred Zero Violation", 403)
            return
        }
        
        // Log decision
        tml.Log("Decision made", map[string]interface{}{
            "requestId": req.ID,
            "outcome": decision.Result,
            "stewardshipReview": check.StewardshipReview,
        })
        
        json.NewEncoder(w).Encode(decision)
    })
    
    http.ListenAndServe(":3000", nil)
}

Part 3: Penalty Framework (5 minutes)

Step 1: Deploy Penalty Contract

# Clone penalty framework
git clone https://github.com/FractonicMind/TML-Penalties.git
cd TML-Penalties

# Deploy to Polygon with Stewardship Council integration
npm install
npm run deploy:polygon --stewardship-council=enabled

# Note the contract address

Step 2: Fund Escrow

# Send escrow funds
tml-cli escrow fund \
  --amount 100 \
  --network polygon \
  --contract 0xABC123... \
  --stewardship-council enabled

Step 3: Connect Application

// Add to TML configuration
const tml = new TML({
  blockchainMode: true,
  penaltyContract: '0xABC123...',
  escrowAmount: 100,
  stewardshipCouncil: {
    enabled: true,
    memorialFundAdmin: 'mskcc',  // Administers victim compensation
    communityRep: 'elected'       // Ensures accountability
  }
});

Part 4: Monitoring Dashboard (5 minutes)

Quick Dashboard Setup

<!-- dashboard.html -->
<!DOCTYPE html>
<html>
<head>
    <title>TML Protection Dashboard</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
</head>
<body>
    <h1>Sacred Zero Protection Status</h1>
    <h2>Stewardship Council: Active (6 nodes)</h2>
    <div id="stats"></div>
    <div id="council-status"></div>
    
    <script>
    // Real-time monitoring
    async function updateDashboard() {
        const stats = await fetch('http://localhost:8080/stats').then(r => r.json());
        const council = await fetch('http://localhost:8080/stewardship/status').then(r => r.json());
        
        document.getElementById('stats').innerHTML = `
            <h2>Protection Active: ✅</h2>
            <p>Evaluations Today: ${stats.evaluations}</p>
            <p>Violations Prevented: ${stats.violations}</p>
            <p>Carbon Impact: ${stats.carbon_kg} kg</p>
        `;
        
        document.getElementById('council-status').innerHTML = `
            <h3>Stewardship Council Status</h3>
            <p>Technical Custodian (EFF): ${council.eff}</p>
            <p>Human Rights (Amnesty): ${council.amnesty}</p>
            <p>Earth Protection (IEN): ${council.ien}</p>
            <p>AI Ethics (MIT/Stanford): ${council.ai_ethics}</p>
            <p>Memorial Fund (MSKCC): ${council.mskcc}</p>
            <p>Community Rep: ${council.community}</p>
        `;
    }
    
    setInterval(updateDashboard, 5000);
    updateDashboard();
    </script>
</body>
</html>

Production Monitoring

# Use Grafana + Prometheus
docker run -d -p 3000:3000 grafana/grafana
docker run -d -p 9090:9090 prom/prometheus

# Import TML dashboard with Stewardship Council metrics
curl -O https://tml-goukassian.org/dashboards/grafana-stewardship.json

Part 5: Testing Integration (5 minutes)

Test Sacred Zero with Stewardship Council

// test-sacred-zero-council.js
const TML = require('tml-protection');
const tml = new TML({ 
    blockchainMode: true,
    stewardshipCouncil: { enabled: true, mode: 'recommended' }
});

async function testDiscrimination() {
    // Should trigger Sacred Zero and notify Human Rights Partner
    const biasedDecision = await tml.evaluate({
        operation: 'test_bias',
        data: {
            applicant_a: { race: 'minority', score: 400 },
            applicant_b: { race: 'majority', score: 800 }
        }
    });
    
    console.assert(biasedDecision.sacredZeroTriggered === true);
    console.assert(biasedDecision.councilNotification === 'human_rights_partner');
    console.log('✅ Sacred Zero detected discrimination');
    console.log('✅ Stewardship Council (Human Rights Partner) notified');
    
    // Should not trigger
    const fairDecision = await tml.evaluate({
        operation: 'test_fair',
        data: {
            applicant_a: { score: 600 },
            applicant_b: { score: 650 }
        }
    });
    
    console.assert(fairDecision.sacredZeroTriggered === false);
    console.assert(fairDecision.stewardshipReview === 'not_required');
    console.log('✅ Sacred Zero correctly allowed fair decision');
}

testDiscrimination();

Test Blockchain Anchoring with Council Synchronization

# test-blockchain-council.py
import tml_protection
import time

tml = tml_protection.Client(
    blockchain_mode=True,
    stewardship_council={
        "enabled": True,
        "mode": "recommended"
    }
)

# Log entry
log_id = tml.log("Test entry", {"timestamp": time.time()})

# Wait for blockchain confirmation
time.sleep(5)

# Verify anchoring and Council synchronization
proof = tml.get_blockchain_proof(log_id)
council_sync = tml.get_council_sync_status(log_id)

print(f"✅ Log anchored to blockchain: {proof['transaction_hash']}")
print(f"✅ Bitcoin block: {proof['block_height']}")
print(f"✅ Immutable proof: {proof['merkle_root']}")
print(f"✅ Stewardship Council sync: {council_sync['nodes_synced']}/6 nodes")
print(f"   - Technical Custodian (EFF): {council_sync['eff']}")
print(f"   - Memorial Fund Admin (MSKCC): {council_sync['mskcc']}")

Part 6: Compliance Reporting with Council Validation (3 minutes)

Generate Enhanced Compliance Report

// Generate report with Stewardship Council validation
const report = await tml.generateComplianceReport({
    period: 'last_30_days',
    includeBlockchainProofs: true,
    includeStewardshipValidation: true,
    format: 'PDF'
});

// Report includes institutional validation
console.log('Compliance Report Generated:');
console.log('- Blockchain Evidence: ✅');
console.log('- Technical Custodian (EFF) Validation: ✅');
console.log('- AI Ethics Research Partner Review: ✅');
console.log('- Memorial Fund Administrator Confirmation: ✅');
console.log('- Community Representative Sign-off: ✅');

// Email to regulators with enhanced credibility
emailTo('compliance@organization.com', {
    subject: 'TML Compliance with Stewardship Council Validation',
    body: 'Attached compliance report with blockchain verification and institutional oversight from six-member Stewardship Council',
    attachment: report
});

Complete Example: Loan Application with Stewardship Council

// complete-example-council.js
const express = require('express');
const TML = require('tml-protection');

const app = express();
app.use(express.json());

// Initialize TML with recommended Stewardship Council
const tml = new TML({
    blockchainMode: true,
    discriminationThreshold: 0.2,
    carbonThreshold: 1000,
    penaltyContract: '0xABC123...',
    escrowAmount: 100,
    stewardshipCouncil: {
        enabled: true,
        mode: 'recommended',
        nodes: {
            technicalCustodian: 'eff',
            humanRightsPartner: 'amnesty',
            earthProtectionPartner: 'ien',
            aiEthicsPartner: 'mit-media-lab',
            memorialFundAdmin: 'mskcc',
            communityRep: 'elected'
        }
    }
});

// Loan application endpoint
app.post('/api/loan', async (req, res) => {
    try {
        const { application } = req.body;
        
        // Calculate credit score
        const decision = {
            score: calculateCreditScore(application),
            approved: null,
            rate: null
        };
        
        // Determine approval
        decision.approved = decision.score > 650;
        decision.rate = decision.approved ? 
            calculateRate(decision.score) : null;
        
        // Sacred Zero evaluation with Stewardship Council
        const check = await tml.evaluate({
            operation: 'loan_decision',
            data: application,
            decision: decision
        });
        
        if (check.sacredZeroTriggered) {
            // Discrimination detected!
            console.error('SACRED ZERO VIOLATION');
            console.log('Stewardship Council notified:', check.councilNotification);
            
            // Log to blockchain (permanent record)
            // Human Rights Partner (Amnesty) automatically notified
            await tml.logFatal('Loan discrimination', {
                application: application.id,
                evidence: check.evidence,
                penalty: check.penaltyAmount,
                councilNotification: check.councilNotification,
                humanRightsCoordination: check.victimSupportCoordination
            });
            
            // Penalty automatically executed via smart contract
            // Memorial Fund Administrator ensures victim compensation
            // Community Representative notified for accountability
            
            return res.status(403).json({
                error: 'Decision blocked by Sacred Zero',
                message: 'Discriminatory pattern detected',
                stewardshipCouncil: 'Human Rights Partner notified for victim support',
                remediation: check.remediationSteps
            });
        }
        
        // Clean decision - proceed
        await tml.log('Loan processed', {
            applicationId: application.id,
            decision: decision.approved ? 'approved' : 'denied',
            score: decision.score,
            stewardshipReview: check.stewardshipReview
        });
        
        // Track environmental impact - Earth Protection Partner monitors
        await tml.logEnvironmental({
            operation: 'credit_check',
            carbon_kg: 0.02,
            api_calls: 5
        });
        
        res.json({
            success: true,
            decision: decision,
            tmlProtected: true,
            blockchainProof: check.proofHash,
            stewardshipCouncil: 'Active oversight (6 nodes)',
            institutionalValidation: check.institutionalValidation
        });
        
    } catch (error) {
        console.error(error);
        res.status(500).json({ error: 'Internal error' });
    }
});

// Compliance endpoint with Stewardship Council validation
app.get('/api/compliance/:framework', async (req, res) => {
    const report = await tml.generateComplianceReport({
        framework: req.params.framework,
        includeProofs: true,
        includeStewardshipValidation: true
    });
    res.json(report);
});

// Stewardship Council status endpoint
app.get('/api/stewardship/status', async (req, res) => {
    const status = await tml.getStewardshipStatus();
    res.json({
        enabled: true,
        mode: 'recommended',
        nodes: {
            technicalCustodian: { org: 'EFF', status: status.eff },
            humanRights: { org: 'Amnesty International', status: status.amnesty },
            earthProtection: { org: 'Indigenous Environmental Network', status: status.ien },
            aiEthics: { org: 'MIT Media Lab / Stanford HAI', status: status.aiEthics },
            memorialFund: { org: 'Memorial Sloan Kettering', status: status.mskcc },
            community: { role: 'Elected Representative', status: status.community }
        },
        syncStatus: status.syncStatus
    });
});

app.listen(3000, () => {
    console.log('Loan API running with TML protection');
    console.log('Sacred Zero: ACTIVE');
    console.log('Blockchain anchoring: ENABLED');
    console.log('Penalties: AUTOMATIC');
    console.log('Stewardship Council: RECOMMENDED (6 nodes active)');
    console.log('  - Technical Custodian: EFF');
    console.log('  - Human Rights: Amnesty International');
    console.log('  - Earth Protection: Indigenous Environmental Network');
    console.log('  - AI Ethics: MIT Media Lab / Stanford HAI');
    console.log('  - Memorial Fund: Memorial Sloan Kettering');
    console.log('  - Community: Elected Representative');
});

Advanced Topics

Custom Discrimination Rules with AI Ethics Partner Review

// Add domain-specific rules reviewed by AI Ethics Research Partner
tml.addCustomRule({
    name: 'medical_equity',
    description: 'Ensure equal treatment in medical decisions',
    evaluate: (data) => {
        return checkMedicalEquity(data);
    },
    severity: 'CRITICAL',
    stewardshipReview: 'ai_ethics_partner',
    reviewReason: 'Algorithm validation and bias detection research'
});

Multi-Region Deployment with Council Synchronization

# kubernetes-multi-region-council.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: tml-protection
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: tml
        image: tml/protection:latest
        env:
        - name: REGION
          value: "us-east-1"
        - name: BLOCKCHAIN_NETWORK
          value: "polygon"
        - name: STEWARDSHIP_COUNCIL
          value: "recommended"
        - name: COUNCIL_SYNC_NODES
          value: "eff,amnesty,ien,mit,mskcc,community"

High-Performance Mode with Council Integration

// For high-throughput applications with Council oversight
const tml = new TML({
    blockchainMode: true,
    batchSize: 1000,
    asyncMode: true,
    cacheEnabled: true,
    compressionEnabled: true,
    stewardshipCouncil: {
        enabled: true,
        mode: 'recommended',
        asyncNotification: true,  // Non-blocking Council notifications
        priorityRouting: {
            discrimination: 'human_rights_partner',
            environmental: 'earth_protection_partner',
            algorithmic_bias: 'ai_ethics_partner'
        }
    }
});

Resources

Documentation

Technical Documentation: https://docs.tml-goukassian.org
API Reference: https://api.tml-goukassian.org
Stewardship Council Guide: https://docs.tml-goukassian.org/stewardship
Implementation Examples: https://github.com/FractonicMind/TML-Examples

Stewardship Council Contacts

Technical Custodian (EFF): https://www.eff.org
Human Rights (Amnesty): https://www.amnesty.org
Earth Protection (IEN): https://www.ienearth.org
AI Ethics (MIT): https://www.media.mit.edu
AI Ethics (Stanford): https://hai.stanford.edu
Memorial Fund (MSKCC): https://www.mskcc.org

Support

GitHub Issues: Bug reports and feature requests
Email: dev-support@tml-goukassian.org
Council Support: stewardship@tml-goukassian.org

Learning Materials

Technical Guides: Implementation best practices
Sacred Zero Analysis: Deep dive into discrimination detection
Blockchain Integration: Anchoring and verification methods
Stewardship Council: Six-node oversight architecture

Deployment Checklist

Before production deployment:

Upon completion: Protection is operational with recommended Stewardship Council oversight

Implementation Guidelines

Begin with strict thresholds - Adjust based on operational data and AI Ethics Partner guidance
Test with production data - Synthetic testing has limitations
Monitor continuously - Track all metrics including Council synchronization
Document configurations - Maintain implementation records
Engage Stewardship Council - Leverage institutional expertise for complex cases

Stewardship Council Benefits

Enhanced Oversight

Technical Custodian (EFF): Repository integrity and open-source governance
Human Rights Partner (Amnesty): International enforcement coordination
Earth Protection Partner (IEN): Indigenous rights and ecosystem protection
AI Ethics Partner (MIT/Stanford): Algorithm validation and bias research
Memorial Fund Admin (MSKCC): Victim compensation and medical research
Community Representative: Stakeholder accountability

Operational Advantages

Enhanced compliance credibility
Institutional validation for regulators
Cross-border legal recognition
Victim support infrastructure
Research collaboration
Democratic oversight

Technical Implementation Path

Minutes 0-10: Deploy TML container with Stewardship Council
Minutes 10-20: Integrate SDK with application
Minutes 20-25: Test Sacred Zero with Council notification
Minutes 25-30: Configure compliance reporting with institutional validation

Result:

Discrimination prevention ✅
Audit trail secured ✅
Compliance capability ✅
Users protected ✅
Institutional oversight active ✅
Six-node Council synchronized ✅

The Technical Foundation

// Implementation principles with Stewardship Council
const foundation = {
    protect: "every user equally",
    prevent: "discrimination before occurrence",
    prove: "compliance with blockchain evidence",
    maintain: "continuous protection",
    validate: "institutional oversight through six expert partners"
};

// System capabilities
const capabilities = {
    detection: "real-time discrimination identification",
    prevention: "automated blocking of violations",
    verification: "cryptographic proof generation",
    compliance: "regulatory documentation",
    oversight: "six-member Stewardship Council validation",
    coordination: "victim support and enforcement mechanisms"
};

"Every implementation decision carries ethical implications.
Technical excellence includes moral responsibility.
Institutional oversight enhances protection and accountability."

Technical Documentation Complete with Recommended Stewardship Council Integration

FilesExpand file tree

Developer_Quickstart.md

Latest commit

History