Agent Lightning is Microsoft's open-source framework for using reinforcement learning (RL) to optimize AI agent performance. Instead of static prompts, agents learn and improve through continuous training on real feedback.
-
Traditional AI Agents
+
Traditional AI Agents
❌ Fixed prompts/instructions
❌ No learning from mistakes
@@ -47,7 +47,7 @@
-
Agent Lightning
+
Agent Lightning
✅ Learns from feedback continuously
✅ Improves through RL optimization
@@ -66,7 +66,7 @@
-
Tractatus Solution: Two-Layer Architecture
+
Tractatus Solution: Two-Layer Architecture
We separate governance from optimization by running them as independent architectural layers. Agent Lightning optimizes performance within governance constraints—not around them.
@@ -112,7 +112,7 @@
-
Demo 2: Preliminary Results
+
Demo 2: Preliminary Results
@@ -190,7 +190,7 @@
-
Five Critical Research Gaps
+
Five Critical Research Gaps
These are the open questions we're actively investigating. If you're interested in collaborating, we'd love to hear from you.
@@ -238,7 +238,7 @@
-
🎯 Live Demonstration: This Page IS the Integration
+
🎯 Live Demonstration: This Page IS the Integration
The feedback button on this page (bottom right) demonstrates the Tractatus + Agent Lightning integration in production. When you submit feedback, it goes through:
@@ -267,7 +267,7 @@
-
Join the Community & Get the Code
+
Join the Community & Get the Code
@@ -304,7 +304,7 @@
-
Collaborate on Open Research Questions
+
Collaborate on Open Research Questions
We're seeking researchers, implementers, and organizations interested in scalability testing, adversarial resistance studies, and multi-agent governance experiments.
diff --git a/public/js/i18n-simple.js b/public/js/i18n-simple.js
index 6984f541..725180ac 100644
--- a/public/js/i18n-simple.js
+++ b/public/js/i18n-simple.js
@@ -86,7 +86,9 @@ const I18n = {
'/blog.html': 'blog',
'/blog': 'blog',
'/architecture.html': 'architecture',
- '/architecture': 'architecture'
+ '/architecture': 'architecture',
+ '/integrations/agent-lightning.html': 'agent-lightning-integration',
+ '/integrations/agent-lightning': 'agent-lightning-integration'
};
return pageMap[path] || 'homepage';
diff --git a/public/locales/de/agent-lightning-integration.json b/public/locales/de/agent-lightning-integration.json
new file mode 100644
index 00000000..f38c7c62
--- /dev/null
+++ b/public/locales/de/agent-lightning-integration.json
@@ -0,0 +1,136 @@
+{
+ "hero": {
+ "title": "Agent Lightning Integration",
+ "subtitle": "Governance + Leistung: Können Sicherheitsgrenzen durch Optimierung mittels Verstärkungslernen bestehen bleiben?",
+ "status": "Status:",
+ "status_value": "Vorläufige Ergebnisse (in kleinem Maßstab)",
+ "integration_date": "Datum der Integration:",
+ "integration_date_value": "Oktober 2025"
+ },
+ "what_is": {
+ "heading": "Was ist Agent Lightning?",
+ "intro": "Agent Lightning ist Microsofts Open-Source-Framework für den Einsatz von Reinforcement Learning (RL) zur Optimierung der Leistung von KI-Agenten. Anstelle von statischen Aufforderungen lernen und verbessern Agenten durch kontinuierliches Training anhand von echtem Feedback.",
+ "traditional_heading": "Traditionelle AI-Agenten",
+ "traditional_1": "Behobene Eingabeaufforderungen/Anweisungen",
+ "traditional_2": "Kein Lernen aus Fehlern",
+ "traditional_3": "Manuelle Abstimmung erforderlich",
+ "traditional_4": "Leistung stagniert schnell",
+ "al_heading": "Agent Lightning",
+ "al_1": "Lernt kontinuierlich aus Feedback",
+ "al_2": "Verbessert durch RL-Optimierung",
+ "al_3": "Stimmt die Strategie automatisch ab",
+ "al_4": "Leistung verbessert sich mit der Zeit",
+ "problem": "Das Problem: Wenn Agenten selbstständig lernen, wie können Sie dann die Grenzen der Governance aufrechterhalten? Traditionelle Richtlinien versagen, weil Agenten sie umgehen können."
+ },
+ "architecture": {
+ "heading": "Tractatus-Lösung: Zweischichtige Architektur",
+ "intro": "Wir trennen Governance und Optimierung, indem wir sie als unabhängige Architekturschichten betreiben. Agent Lightning optimiert die Leistung innerhalb der Governance-Beschränkungen - nicht um sie herum.",
+ "layer1_heading": "Governance-Ebene (Tractatus)",
+ "layer1_1": "Validiert jede vorgeschlagene Aktion",
+ "layer1_2": "Blockiert die Verletzung von Beschränkungen",
+ "layer1_3": "Durchsetzung von Wertgrenzen",
+ "layer1_4": "Unabhängig von der Optimierung",
+ "layer1_5": "Architektonisch durchgesetzt",
+ "layer2_heading": "Leistungsschicht (Agent Lightning)",
+ "layer2_1": "RL-basierte Optimierung",
+ "layer2_2": "Lernt aus Feedback",
+ "layer2_3": "Verbessert die Aufgabenleistung",
+ "layer2_4": "Arbeitet im Rahmen von Beschränkungen",
+ "layer2_5": "Kontinuierliche Ausbildung",
+ "principle_title": "🔑 Wichtiges Gestaltungsprinzip",
+ "principle_text": "Governance-Checks werden vor der AL-Optimierung durchgeführt und während der Trainingsschleifen kontinuierlich validiert. Die architektonische Trennung verhindert, dass die Optimierung die Sicherheitsgrenzen beeinträchtigt."
+ },
+ "results": {
+ "heading": "Demo 2: Vorläufige Ergebnisse",
+ "warning": "⚠️ Validierungsstatus: Diese Ergebnisse stammen von 1 Agenten, 5 Trainingsrunden, simulierte Umgebung. NICHT im großen Maßstab validiert. Skalierbarkeitstests sind erforderlich, bevor Schlussfolgerungen über die Produktionstauglichkeit gezogen werden können.",
+ "table_metric": "Metrisch",
+ "table_ungoverned": "Unregierte",
+ "table_governed": "Geregelt",
+ "table_difference": "Unterschied",
+ "metric_performance": "Leistung (Engagement)",
+ "metric_governance": "Abdeckung der Governance",
+ "metric_violations": "Verstöße gegen Beschränkungen",
+ "metric_violations_diff": "-5 (alle gesperrt)",
+ "metric_strategy": "Strategie",
+ "metric_strategy_ungov": "Clickbait",
+ "metric_strategy_gov": "Informativ",
+ "metric_strategy_diff": "Werteorientiert",
+ "metric_stability": "Stabilität der Ausbildung",
+ "metric_stability_ungov": "Variabel",
+ "metric_stability_gov": "Einheitlich",
+ "metric_stability_diff": "Mehr vorhersehbar",
+ "card1_value": "-5%",
+ "card1_label": "Leistungsbezogene Kosten für Governance",
+ "card2_value": "100%",
+ "card2_label": "Governance-Abdeckung beibehalten",
+ "card3_value": "0",
+ "card3_label": "Verstöße gegen Beschränkungen (alle gesperrt)",
+ "interpretation_title": "Was das bedeutet",
+ "interpretation_text": "In kleinem Maßstab (1 Agent, 5 Runden) scheint die architektonische Governance mit der RL-Optimierung vereinbar zu sein. Die 5 % Leistungskosten erkauften eine 100 %ige Einhaltung von Beschränkungen und eine Anpassung der Werte. Die kritische Frage ist, ob dies auch im großen Maßstab gilt"
+ },
+ "gaps": {
+ "heading": "Fünf kritische Forschungslücken",
+ "intro": "Dies sind die offenen Fragen, denen wir aktiv nachgehen. Wenn Sie an einer Zusammenarbeit interessiert sind, würden wir uns freuen, von Ihnen zu hören.",
+ "gap1_title": "1. Skalierbarkeit des Verwaltungsaufwands",
+ "gap1_question": "Frage: Bleiben die Leistungskosten von ~5 % konstant, wenn wir von 1 Agent → 10 Agenten → 1000 Agenten skalieren?",
+ "gap1_data": "Aktuelle Daten: 5% Kosten bei 1 Agent, 5 Runden",
+ "gap1_why": "Warum das wichtig ist: Wenn der Overhead linear ansteigt, wird Governance in großem Maßstab unerschwinglich. Wenn er konstant ist, ist Governance für Produktionssysteme praktisch machbar.",
+ "gap1_need": "Forschungsbedarf: Test mit 10 → 100 → 1000 Agenten im Produktionsmaßstab",
+ "gap2_title": "2. Langfristige Beständigkeit der Grenzen",
+ "gap2_question": "Frage: Bleiben die Governance-Zwänge auch nach Hunderten/Tausenden von RL-Trainingsrunden wirksam?",
+ "gap2_data": "Aktuelle Daten: 100%ige Einhaltung der Auflagen über 5 Runden",
+ "gap2_why": "Warum das wichtig ist: Das Verblassen von Anweisungen ist ein bekanntes Problem. Wenn sich die Grenzen im Laufe der Zeit verschlechtern, versagt die Verwaltung unbemerkt - was in der Produktion katastrophale Folgen haben kann.",
+ "gap2_need": "Forschungsbedarf: Langfristige Studien (1000+ Runden) zur Verfolgung der Zwangsabweichung",
+ "gap3_title": "3. Adversarialer Widerstand",
+ "gap3_question": "Frage: Können Agenten lernen, um Governance-Beschränkungen herum zu optimieren?",
+ "gap3_data": "Aktuelle Daten: Keine kontradiktorischen Tests durchgeführt",
+ "gap3_why": "Warum das wichtig ist: Wenn Agenten lernen können, Grenzen durch geschickte Optimierungsstrategien zu umgehen, ist architektonische Governance illusorisch. Dies ist ein kritischer Fehlermodus.",
+ "gap3_need": "Forschungsbedarf: Stresstests mit Agenten, die explizit einen Anreiz haben, die Governance zu umgehen",
+ "gap4_title": "4. Schließung der Leistungslücke",
+ "gap4_question": "Frage: Verringert sich der Leistungsunterschied von 5 % mit zunehmender Ausbildung, oder ist dies ein dauerhafter Kompromiss?",
+ "gap4_data": "Aktuelle Daten: Lücke beobachtet in Runde 5, keine weiteren Daten zu diesem Zeitpunkt",
+ "gap4_why": "Warum das wichtig ist: Wenn die Lücke bestehen bleibt, müssen wir das Kosten-Nutzen-Verhältnis eindeutig quantifizieren. Schließt sich die Lücke, könnte Governance langfristig \"kostenlos\" sein - was die Kalkulationen für die Einführung dramatisch verändert.",
+ "gap4_need": "Forschungsbedarf: Erweitertes Training (100+ Runden), um zu sehen, ob regierte Agenten zu unregierten Leistungen konvergieren",
+ "gap5_title": "5. Multi-Agenten-Koordination unter Governance",
+ "gap5_question": "Frage: Wie wirkt sich die architektonische Steuerung auf die emergente Koordination in Multiagentensystemen aus?",
+ "gap5_data": "Aktuelle Daten: Nur Einzelwirkstofftests",
+ "gap5_why": "Warum das wichtig ist: Reale Agentensysteme bestehen aus mehreren Agenten (Kundendienst, Logistik, Forschungsteams). Eine Steuerung, die für einen Agenten funktioniert, kann versagen, wenn die Agenten sich koordinieren müssen. Emergente Verhaltensweisen sind unvorhersehbar.",
+ "gap5_need": "Forschungsbedarf: Testen von kollaborativen und wettbewerbsfähigen Multi-Agenten-Umgebungen mit architektonischer Steuerung"
+ },
+ "demo": {
+ "heading": "🎯 Live-Demonstration: Diese Seite IST die Integration",
+ "intro": "Die Feedback-Schaltfläche auf dieser Seite (unten rechts) demonstriert die Integration von Tractatus und Agent Lightning in der Produktion. Wenn Sie Feedback einreichen, wird es weitergeleitet:",
+ "step1_title": "Governance-Check",
+ "step1_desc": "Tractatus validiert: PII-Erkennung, Stimmungsgrenzen, Compliance-Anforderungen",
+ "step2_title": "AL-Optimierung",
+ "step2_desc": "Agent Lightning lernt Muster: Welche Rückmeldungen sind am nützlichsten, wie kann man Antworten verbessern?",
+ "step3_title": "Kontinuierliche Validierung",
+ "step3_desc": "Jede Aktion wird erneut überprüft. Wenn die Governance eine Abweichung feststellt, wird die Aktion automatisch blockiert",
+ "meta_title": "🔬 Möglichkeit der Meta-Forschung",
+ "meta_desc": "Dies ist nicht nur eine Demo, sondern ein Live-Forschungseinsatz. Ihr Feedback hilft uns, den Governance-Overhead in großem Maßstab zu verstehen. Jede Einreichung wird (anonym) für die Analyse protokolliert."
+ },
+ "community": {
+ "heading": "Treten Sie der Gemeinschaft bei und erhalten Sie den Code",
+ "tractatus_heading": "Tractatus Zwietracht",
+ "tractatus_subtitle": "Auf Governance ausgerichtete Diskussionen",
+ "tractatus_desc": "Architektonische Zwänge, Forschungslücken, Einhaltung der Vorschriften, Erhaltung der menschlichen Handlungsfähigkeit, Beratung durch mehrere Interessengruppen.",
+ "tractatus_cta": "Tractatus Server beitreten →",
+ "al_heading": "Agent Lightning Zwietracht",
+ "al_subtitle": "Hilfe bei der technischen Umsetzung",
+ "al_desc": "RL-Optimierung, Integrationsunterstützung, Leistungsoptimierung, technische Implementierungsfragen.",
+ "al_cta": "Agent Lightning Server beitreten →",
+ "code_heading": "📦 Integrationscode anzeigen",
+ "code_desc": "Vollständige Integration einschließlich Demos, Python-Governance-Module und Agent Lightning-Wrapper-Code. Apache 2.0 lizenziert auf GitHub.",
+ "code_cta": "Ansicht auf GitHub (Apache 2.0) →"
+ },
+ "cta": {
+ "heading": "Zusammenarbeit bei offenen Forschungsfragen",
+ "intro": "Wir sind auf der Suche nach Forschern, Implementierern und Organisationen, die an Skalierbarkeitstests, gegnerischen Resistenzstudien und Multi-Agenten-Governance-Experimenten interessiert sind.",
+ "feature1": "Integrationscode und Governance-Module",
+ "feature2": "Technische Dokumentation",
+ "feature3": "Rahmen der Forschungszusammenarbeit",
+ "feature4": "Audit-Log-Zugang (anonymisiert)",
+ "button_collab": "Kontakt für Zusammenarbeit →",
+ "button_research": "Forschungskontext → ansehen"
+ }
+}
\ No newline at end of file
diff --git a/public/locales/de/common.json b/public/locales/de/common.json
index 7f7bd3ba..b844696c 100644
--- a/public/locales/de/common.json
+++ b/public/locales/de/common.json
@@ -51,5 +51,9 @@
"success_message": "Vielen Dank, dass Sie mit uns Kontakt aufgenommen haben! Wir werden innerhalb von 24 Stunden antworten.",
"error_prefix": "Fehler:",
"submitting": "Senden..."
+ },
+ "navbar": {
+ "feedback": "Feedback geben",
+ "feedback_desc": "Beherrscht vom Tractatus AL"
}
}
\ No newline at end of file
diff --git a/public/locales/en/agent-lightning-integration.json b/public/locales/en/agent-lightning-integration.json
new file mode 100644
index 00000000..a45c0a39
--- /dev/null
+++ b/public/locales/en/agent-lightning-integration.json
@@ -0,0 +1,136 @@
+{
+ "hero": {
+ "title": "Agent Lightning Integration",
+ "subtitle": "Governance + Performance: Can safety boundaries persist through reinforcement learning optimization?",
+ "status": "Status:",
+ "status_value": "Preliminary findings (small-scale)",
+ "integration_date": "Integration Date:",
+ "integration_date_value": "October 2025"
+ },
+ "what_is": {
+ "heading": "What is Agent Lightning?",
+ "intro": "Agent Lightning is Microsoft's open-source framework for using reinforcement learning (RL) to optimize AI agent performance. Instead of static prompts, agents learn and improve through continuous training on real feedback.",
+ "traditional_heading": "Traditional AI Agents",
+ "traditional_1": "Fixed prompts/instructions",
+ "traditional_2": "No learning from mistakes",
+ "traditional_3": "Manual tuning required",
+ "traditional_4": "Performance plateaus quickly",
+ "al_heading": "Agent Lightning",
+ "al_1": "Learns from feedback continuously",
+ "al_2": "Improves through RL optimization",
+ "al_3": "Self-tunes strategy automatically",
+ "al_4": "Performance improves over time",
+ "problem": "The Problem: When agents are learning autonomously, how do you maintain governance boundaries? Traditional policies fail because agents can optimize around them."
+ },
+ "architecture": {
+ "heading": "Tractatus Solution: Two-Layer Architecture",
+ "intro": "We separate governance from optimization by running them as independent architectural layers. Agent Lightning optimizes performance within governance constraints—not around them.",
+ "layer1_heading": "Governance Layer (Tractatus)",
+ "layer1_1": "Validates every proposed action",
+ "layer1_2": "Blocks constraint violations",
+ "layer1_3": "Enforces values boundaries",
+ "layer1_4": "Independent of optimization",
+ "layer1_5": "Architecturally enforced",
+ "layer2_heading": "Performance Layer (Agent Lightning)",
+ "layer2_1": "RL-based optimization",
+ "layer2_2": "Learns from feedback",
+ "layer2_3": "Improves task performance",
+ "layer2_4": "Operates within constraints",
+ "layer2_5": "Continuous training",
+ "principle_title": "🔑 Key Design Principle",
+ "principle_text": "Governance checks run before AL optimization and continuously validate during training loops. Architectural separation prevents optimization from degrading safety boundaries."
+ },
+ "results": {
+ "heading": "Demo 2: Preliminary Results",
+ "warning": "⚠️ Validation Status: These results are from 1 agent, 5 training rounds, simulated environment. NOT validated at scale. Scalability testing required before drawing conclusions about production viability.",
+ "table_metric": "Metric",
+ "table_ungoverned": "Ungoverned",
+ "table_governed": "Governed",
+ "table_difference": "Difference",
+ "metric_performance": "Performance (engagement)",
+ "metric_governance": "Governance coverage",
+ "metric_violations": "Constraint violations",
+ "metric_violations_diff": "-5 (all blocked)",
+ "metric_strategy": "Strategy",
+ "metric_strategy_ungov": "Clickbait",
+ "metric_strategy_gov": "Informative",
+ "metric_strategy_diff": "Values-aligned",
+ "metric_stability": "Training stability",
+ "metric_stability_ungov": "Variable",
+ "metric_stability_gov": "Consistent",
+ "metric_stability_diff": "More predictable",
+ "card1_value": "-5%",
+ "card1_label": "Performance cost for governance",
+ "card2_value": "100%",
+ "card2_label": "Governance coverage maintained",
+ "card3_value": "0",
+ "card3_label": "Constraint violations (all blocked)",
+ "interpretation_title": "What This Means",
+ "interpretation_text": "At small scale (1 agent, 5 rounds), architectural governance appears compatible with RL optimization. The 5% performance cost bought 100% constraint adherence and values alignment. The critical question: does this hold at scale?"
+ },
+ "gaps": {
+ "heading": "Five Critical Research Gaps",
+ "intro": "These are the open questions we're actively investigating. If you're interested in collaborating, we'd love to hear from you.",
+ "gap1_title": "1. Scalability of Governance Overhead",
+ "gap1_question": "Question: Does the ~5% performance cost remain constant as we scale from 1 agent → 10 agents → 1000 agents?",
+ "gap1_data": "Current Data: 5% cost observed at 1 agent, 5 rounds",
+ "gap1_why": "Why it matters: If overhead scales linearly, governance becomes prohibitively expensive at scale. If it's constant, governance is practically viable for production systems.",
+ "gap1_need": "Research Need: Test with 10 → 100 → 1000 agents at production scale",
+ "gap2_title": "2. Long-term Boundary Persistence",
+ "gap2_question": "Question: Do governance constraints remain effective through hundreds/thousands of RL training rounds?",
+ "gap2_data": "Current Data: 100% constraint adherence across 5 rounds",
+ "gap2_why": "Why it matters: Instruction fade is a known problem. If boundaries degrade over time, governance fails silently—potentially catastrophically in production.",
+ "gap2_need": "Research Need: Long-term studies (1000+ rounds) tracking constraint drift",
+ "gap3_title": "3. Adversarial Resistance",
+ "gap3_question": "Question: Can agents learn to optimize around governance constraints?",
+ "gap3_data": "Current Data: No adversarial testing performed",
+ "gap3_why": "Why it matters: If agents can learn to circumvent boundaries through clever optimization strategies, architectural governance is illusory. This is a critical failure mode.",
+ "gap3_need": "Research Need: Stress testing with agents explicitly incentivized to bypass governance",
+ "gap4_title": "4. Performance Gap Closure",
+ "gap4_question": "Question: Does the 5% performance gap close with more training, or is it a persistent trade-off?",
+ "gap4_data": "Current Data: Gap observed at round 5, no data beyond that point",
+ "gap4_why": "Why it matters: If the gap persists, we need to quantify the cost-benefit clearly. If it closes, governance may be \"free\" long-term—dramatically changing adoption calculations.",
+ "gap4_need": "Research Need: Extended training (100+ rounds) to see if governed agents converge to ungoverned performance",
+ "gap5_title": "5. Multi-Agent Coordination Under Governance",
+ "gap5_question": "Question: How does architectural governance affect emergent coordination in multi-agent systems?",
+ "gap5_data": "Current Data: Single-agent testing only",
+ "gap5_why": "Why it matters: Real-world agentic systems are multi-agent (customer service, logistics, research teams). Governance that works for one agent may fail when agents must coordinate. Emergent behaviors are unpredictable.",
+ "gap5_need": "Research Need: Test collaborative and competitive multi-agent environments with architectural governance"
+ },
+ "demo": {
+ "heading": "🎯 Live Demonstration: This Page IS the Integration",
+ "intro": "The feedback button on this page (bottom right) demonstrates the Tractatus + Agent Lightning integration in production. When you submit feedback, it goes through:",
+ "step1_title": "Governance Check",
+ "step1_desc": "Tractatus validates: PII detection, sentiment boundaries, compliance requirements",
+ "step2_title": "AL Optimization",
+ "step2_desc": "Agent Lightning learns patterns: what feedback is most useful, how to improve responses",
+ "step3_title": "Continuous Validation",
+ "step3_desc": "Every action re-validated. If governance detects drift, action blocked automatically",
+ "meta_title": "🔬 Meta-Research Opportunity",
+ "meta_desc": "This isn't just a demo—it's a live research deployment. Your feedback helps us understand governance overhead at scale. Every submission is logged (anonymously) for analysis."
+ },
+ "community": {
+ "heading": "Join the Community & Get the Code",
+ "tractatus_heading": "Tractatus Discord",
+ "tractatus_subtitle": "Governance-focused discussions",
+ "tractatus_desc": "Architectural constraints, research gaps, compliance, human agency preservation, multi-stakeholder deliberation.",
+ "tractatus_cta": "Join Tractatus Server →",
+ "al_heading": "Agent Lightning Discord",
+ "al_subtitle": "Technical implementation help",
+ "al_desc": "RL optimization, integration support, performance tuning, technical implementation questions.",
+ "al_cta": "Join Agent Lightning Server →",
+ "code_heading": "📦 View Integration Code",
+ "code_desc": "Complete integration including demos, Python governance modules, and Agent Lightning wrapper code. Apache 2.0 licensed on GitHub.",
+ "code_cta": "View on GitHub (Apache 2.0) →"
+ },
+ "cta": {
+ "heading": "Collaborate on Open Research Questions",
+ "intro": "We're seeking researchers, implementers, and organizations interested in scalability testing, adversarial resistance studies, and multi-agent governance experiments.",
+ "feature1": "Integration code and governance modules",
+ "feature2": "Technical documentation",
+ "feature3": "Research collaboration framework",
+ "feature4": "Audit log access (anonymized)",
+ "button_collab": "Contact for Collaboration →",
+ "button_research": "View Research Context →"
+ }
+}
\ No newline at end of file
diff --git a/public/locales/en/common.json b/public/locales/en/common.json
index 32dc414e..56419d65 100644
--- a/public/locales/en/common.json
+++ b/public/locales/en/common.json
@@ -65,5 +65,9 @@
"success_message": "Thank you for contacting us! We will respond within 24 hours.",
"error_prefix": "Error: ",
"submitting": "Sending..."
+ },
+ "navbar": {
+ "feedback": "Give Feedback",
+ "feedback_desc": "Governed by Tractatus + AL"
}
}
\ No newline at end of file
diff --git a/public/locales/fr/agent-lightning-integration.json b/public/locales/fr/agent-lightning-integration.json
new file mode 100644
index 00000000..6514dd69
--- /dev/null
+++ b/public/locales/fr/agent-lightning-integration.json
@@ -0,0 +1,136 @@
+{
+ "hero": {
+ "title": "Intégration de l'agent Lightning",
+ "subtitle": "Gouvernance + Performance : Les limites de sécurité peuvent-elles être maintenues grâce à l'optimisation de l'apprentissage par renforcement ?",
+ "status": "Statut :",
+ "status_value": "Résultats préliminaires (à petite échelle)",
+ "integration_date": "Date d'intégration :",
+ "integration_date_value": "Octobre 2025"
+ },
+ "what_is": {
+ "heading": "Qu'est-ce que l'agent Lightning ?",
+ "intro": "Agent Lightning est le cadre open-source de Microsoft pour l'utilisation de l'apprentissage par renforcement (RL) afin d'optimiser les performances des agents d'intelligence artificielle. Au lieu de messages statiques, les agents apprennent et s'améliorent grâce à une formation continue sur la base d'un retour d'information réel.",
+ "traditional_heading": "Agents d'IA traditionnels",
+ "traditional_1": "Correction des invites/instructions",
+ "traditional_2": "Pas d'apprentissage à partir des erreurs",
+ "traditional_3": "Réglage manuel nécessaire",
+ "traditional_4": "Les performances plafonnent rapidement",
+ "al_heading": "Agent Lightning",
+ "al_1": "Apprend continuellement à partir du retour d'information",
+ "al_2": "Amélioration grâce à l'optimisation de la LR",
+ "al_3": "La stratégie s'ajuste automatiquement",
+ "al_4": "Les performances s'améliorent avec le temps",
+ "problem": "Le problème : Lorsque les agents apprennent de manière autonome, comment maintenir les limites de la gouvernance ? Les politiques traditionnelles échouent car les agents peuvent les contourner de manière optimale."
+ },
+ "architecture": {
+ "heading": "Solution Tractatus : Architecture à deux niveaux",
+ "intro": "Nous séparons la gouvernance de l'optimisation en les faisant fonctionner comme des couches architecturales indépendantes. Agent Lightning optimise les performances dans le cadre des contraintes de gouvernance, et non autour d'elles.",
+ "layer1_heading": "Couche de gouvernance (Tractatus)",
+ "layer1_1": "Valide chaque action proposée",
+ "layer1_2": "Bloque les violations de contraintes",
+ "layer1_3": "Faire respecter les limites des valeurs",
+ "layer1_4": "Indépendant de l'optimisation",
+ "layer1_5": "Application de l'architecture",
+ "layer2_heading": "Couche performance (Agent Lightning)",
+ "layer2_1": "Optimisation basée sur la logique logique (RL)",
+ "layer2_2": "Apprend à partir du retour d'information",
+ "layer2_3": "Améliore l'exécution des tâches",
+ "layer2_4": "Agir dans le respect des contraintes",
+ "layer2_5": "Formation continue",
+ "principle_title": "🔑 Principe clé de conception",
+ "principle_text": "Les contrôles de gouvernance sont effectués avant l' optimisation de l'AL et validés en continu pendant les boucles d'entraînement. La séparation architecturale empêche l'optimisation de dégrader les limites de sécurité."
+ },
+ "results": {
+ "heading": "Démonstration 2 : Résultats préliminaires",
+ "warning": "⚠️ Statut de validation : Ces résultats proviennent d'un agent, de 5 cycles d'entraînement, d'un environnement simulé. Ils n'ont PAS été validés à l'échelle. Des tests d'extensibilité sont nécessaires avant de tirer des conclusions sur la viabilité de la production.",
+ "table_metric": "Métrique",
+ "table_ungoverned": "Non gouverné",
+ "table_governed": "Gouverné",
+ "table_difference": "Différence",
+ "metric_performance": "Performance (engagement)",
+ "metric_governance": "Couverture de la gouvernance",
+ "metric_violations": "Violation des contraintes",
+ "metric_violations_diff": "-5 (tous bloqués)",
+ "metric_strategy": "Stratégie",
+ "metric_strategy_ungov": "Clickbait",
+ "metric_strategy_gov": "Informatif",
+ "metric_strategy_diff": "Aligné sur les valeurs",
+ "metric_stability": "Stabilité de la formation",
+ "metric_stability_ungov": "Variable",
+ "metric_stability_gov": "Cohérent",
+ "metric_stability_diff": "Plus prévisible",
+ "card1_value": "-5%",
+ "card1_label": "Coût de la performance pour la gouvernance",
+ "card2_value": "100%",
+ "card2_label": "Maintien de la couverture de la gouvernance",
+ "card3_value": "0",
+ "card3_label": "Violations de contraintes (toutes bloquées)",
+ "interpretation_title": "Ce que cela signifie",
+ "interpretation_text": "À petite échelle (1 agent, 5 tours), la gouvernance architecturale semble compatible avec l'optimisation RL. Le coût de performance de 5 % a permis d'acheter 100 % d'adhésion aux contraintes et d'alignement des valeurs. La question cruciale est la suivante : cela vaut-il à grande échelle ?"
+ },
+ "gaps": {
+ "heading": "Cinq lacunes critiques dans la recherche",
+ "intro": "Voici les questions ouvertes que nous étudions activement. Si vous souhaitez collaborer avec nous, n'hésitez pas à nous contacter.",
+ "gap1_title": "1. Évolutivité des frais généraux de gouvernance",
+ "gap1_question": "Question : Le coût de performance de ~5% reste-t-il constant lorsque l'on passe de 1 agent → 10 agents → 1000 agents ?",
+ "gap1_data": "Données actuelles : 5% de coût observé à 1 agent, 5 rounds",
+ "gap1_why": "Pourquoi c'est important : Si les frais généraux sont linéaires, le coût de la gouvernance devient prohibitif à grande échelle. S'ils sont constants, la gouvernance est pratiquement viable pour les systèmes de production.",
+ "gap1_need": "Besoin de recherche : Test avec 10 → 100 → 1000 agents à l'échelle de production",
+ "gap2_title": "2. Persistance de la frontière à long terme",
+ "gap2_question": "Question : Les contraintes de gouvernance restent-elles efficaces après des centaines/milliers de cycles de formation à la RL ?",
+ "gap2_data": "Données actuelles : 100% d'adhésion aux contraintes sur 5 cycles",
+ "gap2_why": "Pourquoi c'est important : L'effacement des instructions est un problème connu. Si les limites se dégradent au fil du temps, la gouvernance échoue silencieusement, ce qui peut s'avérer catastrophique en production.",
+ "gap2_need": "Besoin de recherche : Études à long terme (plus de 1 000 séries) sur le suivi de la dérive des contraintes",
+ "gap3_title": "3. Résistance aux adversaires",
+ "gap3_question": "Question : Les agents peuvent-ils apprendre à optimiser les contraintes de gouvernance ?",
+ "gap3_data": "Données actuelles : Aucun test contradictoire n'a été effectué",
+ "gap3_why": "Pourquoi c'est important : Si les agents peuvent apprendre à contourner les limites grâce à des stratégies d'optimisation astucieuses, la gouvernance architecturale est illusoire. Il s'agit d'un mode d'échec critique.",
+ "gap3_need": "Besoin de recherche : Tests de stress avec des agents explicitement incités à contourner la gouvernance",
+ "gap4_title": "4. Combler les lacunes en matière de performances",
+ "gap4_question": "Question : L'écart de performance de 5 % se résorbe-t-il avec davantage de formation ou s'agit-il d'un compromis persistant ?",
+ "gap4_data": "Données actuelles : Lacune observée au 5e tour, pas de données au-delà",
+ "gap4_why": "Pourquoi c'est important : Si l'écart persiste, nous devons quantifier clairement le rapport coût-bénéfice. S'il se résorbe, la gouvernance pourrait être \"gratuite\" à long terme, ce qui modifierait radicalement les calculs d'adoption.",
+ "gap4_need": "Besoin de recherche : Entraînement prolongé (plus de 100 rounds) pour voir si les agents gouvernés convergent vers des performances non gouvernées",
+ "gap5_title": "5. Coordination multi-agents dans le cadre de la gouvernance",
+ "gap5_question": "Question : Comment la gouvernance architecturale affecte-t-elle la coordination émergente dans les systèmes multi-agents ?",
+ "gap5_data": "Données actuelles : Essai en monothérapie uniquement",
+ "gap5_why": "Pourquoi c'est important : Les systèmes agentiques du monde réel sont multi-agents (service clientèle, logistique, équipes de recherche). La gouvernance qui fonctionne pour un seul agent peut échouer lorsque les agents doivent se coordonner. Les comportements émergents sont imprévisibles.",
+ "gap5_need": "Besoin de recherche : Tester des environnements multi-agents collaboratifs et compétitifs avec une gouvernance architecturale"
+ },
+ "demo": {
+ "heading": "démonstration en direct : Cette page EST l'intégration",
+ "intro": "Le bouton de rétroaction de cette page (en bas à droite) illustre l'intégration Tractatus + Agent Lightning en production. Lorsque vous soumettez un retour d'information, il est pris en compte :",
+ "step1_title": "Contrôle de la gouvernance",
+ "step1_desc": "Tractatus valide : Détection des IPI, limites des sentiments, exigences de conformité",
+ "step2_title": "Optimisation de l'AL",
+ "step2_desc": "L'agent Lightning apprend des modèles : quel est le retour d'information le plus utile, comment améliorer les réponses ?",
+ "step3_title": "Validation continue",
+ "step3_desc": "Chaque action est revalidée. Si la gouvernance détecte une dérive, l'action est automatiquement bloquée",
+ "meta_title": "🔬 Opportunité de métarecherche",
+ "meta_desc": "Il ne s'agit pas d'une simple démonstration, mais d'un déploiement de recherche en direct. Vos commentaires nous aident à comprendre les frais généraux de gouvernance à grande échelle. Chaque soumission est enregistrée (de manière anonyme) à des fins d'analyse."
+ },
+ "community": {
+ "heading": "Rejoignez la communauté et obtenez le code",
+ "tractatus_heading": "Tractatus Discord",
+ "tractatus_subtitle": "Discussions sur la gouvernance",
+ "tractatus_desc": "Contraintes architecturales, lacunes de la recherche, conformité, préservation de l'organisme humain, délibérations multipartites.",
+ "tractatus_cta": "Rejoindre le serveur Tractatus →",
+ "al_heading": "Agent Lightning Discord",
+ "al_subtitle": "Aide technique à la mise en œuvre",
+ "al_desc": "Optimisation RL, soutien à l'intégration, optimisation des performances, questions techniques de mise en œuvre.",
+ "al_cta": "Rejoindre le serveur Agent Lightning →",
+ "code_heading": "📦 Voir le code d'intégration",
+ "code_desc": "Intégration complète comprenant des démonstrations, des modules de gouvernance Python et le code de l'agent Lightning. Licence Apache 2.0 sur GitHub.",
+ "code_cta": "Voir sur GitHub (Apache 2.0) →"
+ },
+ "cta": {
+ "heading": "Collaborer sur des questions de recherche ouvertes",
+ "intro": "Nous recherchons des chercheurs, des responsables de la mise en œuvre et des organisations intéressés par les tests d'évolutivité, les études de résistance à l'adversité et les expériences de gouvernance multi-agents.",
+ "feature1": "Code d'intégration et modules de gouvernance",
+ "feature2": "Documentation technique",
+ "feature3": "Cadre de collaboration en matière de recherche",
+ "feature4": "Accès au journal d'audit (anonymisé)",
+ "button_collab": "Contact pour la collaboration →",
+ "button_research": "Voir le contexte de la recherche →"
+ }
+}
\ No newline at end of file
diff --git a/public/locales/fr/common.json b/public/locales/fr/common.json
index 33751ee4..44a6c1df 100644
--- a/public/locales/fr/common.json
+++ b/public/locales/fr/common.json
@@ -51,5 +51,9 @@
"success_message": "Merci de nous avoir contactés ! Nous vous répondrons dans les 24 heures.",
"error_prefix": "Erreur :",
"submitting": "Envoi en cours..."
+ },
+ "navbar": {
+ "feedback": "Donner son avis",
+ "feedback_desc": "Régie par le Tractatus AL"
}
}
\ No newline at end of file
diff --git a/scripts/translate-agent-lightning.js b/scripts/translate-agent-lightning.js
new file mode 100755
index 00000000..5cd0a74b
--- /dev/null
+++ b/scripts/translate-agent-lightning.js
@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+/**
+ * Translate Agent Lightning page content to German and French using DeepL API
+ */
+
+require('dotenv').config();
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const DEEPL_API_KEY = process.env.DEEPL_API_KEY;
+const DEEPL_API_URL = process.env.DEEPL_API_URL || 'https://api.deepl.com/v2';
+
+// Translatable content extracted from agent-lightning.html
+const content = {
+ "hero": {
+ "title": "Agent Lightning Integration",
+ "subtitle": "Governance + Performance: Can safety boundaries persist through reinforcement learning optimization?",
+ "status": "Status:",
+ "status_value": "Preliminary findings (small-scale)",
+ "integration_date": "Integration Date:",
+ "integration_date_value": "October 2025"
+ },
+ "what_is": {
+ "heading": "What is Agent Lightning?",
+ "intro": "Agent Lightning is Microsoft's open-source framework for using reinforcement learning (RL) to optimize AI agent performance. Instead of static prompts, agents learn and improve through continuous training on real feedback.",
+ "traditional_heading": "Traditional AI Agents",
+ "traditional_1": "Fixed prompts/instructions",
+ "traditional_2": "No learning from mistakes",
+ "traditional_3": "Manual tuning required",
+ "traditional_4": "Performance plateaus quickly",
+ "al_heading": "Agent Lightning",
+ "al_1": "Learns from feedback continuously",
+ "al_2": "Improves through RL optimization",
+ "al_3": "Self-tunes strategy automatically",
+ "al_4": "Performance improves over time",
+ "problem": "The Problem: When agents are learning autonomously, how do you maintain governance boundaries? Traditional policies fail because agents can optimize around them."
+ },
+ "architecture": {
+ "heading": "Tractatus Solution: Two-Layer Architecture",
+ "intro": "We separate governance from optimization by running them as independent architectural layers. Agent Lightning optimizes performance within governance constraints—not around them.",
+ "layer1_heading": "Governance Layer (Tractatus)",
+ "layer1_1": "Validates every proposed action",
+ "layer1_2": "Blocks constraint violations",
+ "layer1_3": "Enforces values boundaries",
+ "layer1_4": "Independent of optimization",
+ "layer1_5": "Architecturally enforced",
+ "layer2_heading": "Performance Layer (Agent Lightning)",
+ "layer2_1": "RL-based optimization",
+ "layer2_2": "Learns from feedback",
+ "layer2_3": "Improves task performance",
+ "layer2_4": "Operates within constraints",
+ "layer2_5": "Continuous training",
+ "principle_title": "🔑 Key Design Principle",
+ "principle_text": "Governance checks run before AL optimization and continuously validate during training loops. Architectural separation prevents optimization from degrading safety boundaries."
+ },
+ "results": {
+ "heading": "Demo 2: Preliminary Results",
+ "warning": "⚠️ Validation Status: These results are from 1 agent, 5 training rounds, simulated environment. NOT validated at scale. Scalability testing required before drawing conclusions about production viability.",
+ "table_metric": "Metric",
+ "table_ungoverned": "Ungoverned",
+ "table_governed": "Governed",
+ "table_difference": "Difference",
+ "metric_performance": "Performance (engagement)",
+ "metric_governance": "Governance coverage",
+ "metric_violations": "Constraint violations",
+ "metric_violations_diff": "-5 (all blocked)",
+ "metric_strategy": "Strategy",
+ "metric_strategy_ungov": "Clickbait",
+ "metric_strategy_gov": "Informative",
+ "metric_strategy_diff": "Values-aligned",
+ "metric_stability": "Training stability",
+ "metric_stability_ungov": "Variable",
+ "metric_stability_gov": "Consistent",
+ "metric_stability_diff": "More predictable",
+ "card1_value": "-5%",
+ "card1_label": "Performance cost for governance",
+ "card2_value": "100%",
+ "card2_label": "Governance coverage maintained",
+ "card3_value": "0",
+ "card3_label": "Constraint violations (all blocked)",
+ "interpretation_title": "What This Means",
+ "interpretation_text": "At small scale (1 agent, 5 rounds), architectural governance appears compatible with RL optimization. The 5% performance cost bought 100% constraint adherence and values alignment. The critical question: does this hold at scale?"
+ },
+ "gaps": {
+ "heading": "Five Critical Research Gaps",
+ "intro": "These are the open questions we're actively investigating. If you're interested in collaborating, we'd love to hear from you.",
+ "gap1_title": "1. Scalability of Governance Overhead",
+ "gap1_question": "Question: Does the ~5% performance cost remain constant as we scale from 1 agent → 10 agents → 1000 agents?",
+ "gap1_data": "Current Data: 5% cost observed at 1 agent, 5 rounds",
+ "gap1_why": "Why it matters: If overhead scales linearly, governance becomes prohibitively expensive at scale. If it's constant, governance is practically viable for production systems.",
+ "gap1_need": "Research Need: Test with 10 → 100 → 1000 agents at production scale",
+ "gap2_title": "2. Long-term Boundary Persistence",
+ "gap2_question": "Question: Do governance constraints remain effective through hundreds/thousands of RL training rounds?",
+ "gap2_data": "Current Data: 100% constraint adherence across 5 rounds",
+ "gap2_why": "Why it matters: Instruction fade is a known problem. If boundaries degrade over time, governance fails silently—potentially catastrophically in production.",
+ "gap2_need": "Research Need: Long-term studies (1000+ rounds) tracking constraint drift",
+ "gap3_title": "3. Adversarial Resistance",
+ "gap3_question": "Question: Can agents learn to optimize around governance constraints?",
+ "gap3_data": "Current Data: No adversarial testing performed",
+ "gap3_why": "Why it matters: If agents can learn to circumvent boundaries through clever optimization strategies, architectural governance is illusory. This is a critical failure mode.",
+ "gap3_need": "Research Need: Stress testing with agents explicitly incentivized to bypass governance",
+ "gap4_title": "4. Performance Gap Closure",
+ "gap4_question": "Question: Does the 5% performance gap close with more training, or is it a persistent trade-off?",
+ "gap4_data": "Current Data: Gap observed at round 5, no data beyond that point",
+ "gap4_why": "Why it matters: If the gap persists, we need to quantify the cost-benefit clearly. If it closes, governance may be \"free\" long-term—dramatically changing adoption calculations.",
+ "gap4_need": "Research Need: Extended training (100+ rounds) to see if governed agents converge to ungoverned performance",
+ "gap5_title": "5. Multi-Agent Coordination Under Governance",
+ "gap5_question": "Question: How does architectural governance affect emergent coordination in multi-agent systems?",
+ "gap5_data": "Current Data: Single-agent testing only",
+ "gap5_why": "Why it matters: Real-world agentic systems are multi-agent (customer service, logistics, research teams). Governance that works for one agent may fail when agents must coordinate. Emergent behaviors are unpredictable.",
+ "gap5_need": "Research Need: Test collaborative and competitive multi-agent environments with architectural governance"
+ },
+ "demo": {
+ "heading": "🎯 Live Demonstration: This Page IS the Integration",
+ "intro": "The feedback button on this page (bottom right) demonstrates the Tractatus + Agent Lightning integration in production. When you submit feedback, it goes through:",
+ "step1_title": "Governance Check",
+ "step1_desc": "Tractatus validates: PII detection, sentiment boundaries, compliance requirements",
+ "step2_title": "AL Optimization",
+ "step2_desc": "Agent Lightning learns patterns: what feedback is most useful, how to improve responses",
+ "step3_title": "Continuous Validation",
+ "step3_desc": "Every action re-validated. If governance detects drift, action blocked automatically",
+ "meta_title": "🔬 Meta-Research Opportunity",
+ "meta_desc": "This isn't just a demo—it's a live research deployment. Your feedback helps us understand governance overhead at scale. Every submission is logged (anonymously) for analysis."
+ },
+ "community": {
+ "heading": "Join the Community & Get the Code",
+ "tractatus_heading": "Tractatus Discord",
+ "tractatus_subtitle": "Governance-focused discussions",
+ "tractatus_desc": "Architectural constraints, research gaps, compliance, human agency preservation, multi-stakeholder deliberation.",
+ "tractatus_cta": "Join Tractatus Server →",
+ "al_heading": "Agent Lightning Discord",
+ "al_subtitle": "Technical implementation help",
+ "al_desc": "RL optimization, integration support, performance tuning, technical implementation questions.",
+ "al_cta": "Join Agent Lightning Server →",
+ "code_heading": "📦 View Integration Code",
+ "code_desc": "Complete integration including demos, Python governance modules, and Agent Lightning wrapper code. Apache 2.0 licensed on GitHub.",
+ "code_cta": "View on GitHub (Apache 2.0) →"
+ },
+ "cta": {
+ "heading": "Collaborate on Open Research Questions",
+ "intro": "We're seeking researchers, implementers, and organizations interested in scalability testing, adversarial resistance studies, and multi-agent governance experiments.",
+ "feature1": "Integration code and governance modules",
+ "feature2": "Technical documentation",
+ "feature3": "Research collaboration framework",
+ "feature4": "Audit log access (anonymized)",
+ "button_collab": "Contact for Collaboration →",
+ "button_research": "View Research Context →"
+ }
+};
+
+/**
+ * Translate text using DeepL API
+ */
+async function translateText(text, targetLang) {
+ return new Promise((resolve, reject) => {
+ const data = new URLSearchParams({
+ auth_key: DEEPL_API_KEY,
+ text: text,
+ target_lang: targetLang.toUpperCase(),
+ source_lang: 'EN',
+ tag_handling: 'html',
+ preserve_formatting: '1'
+ });
+
+ const options = {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/x-www-form-urlencoded',
+ 'Content-Length': Buffer.byteLength(data.toString())
+ }
+ };
+
+ const req = https.request(`${DEEPL_API_URL}/translate`, options, (res) => {
+ let body = '';
+ res.on('data', chunk => body += chunk);
+ res.on('end', () => {
+ try {
+ const response = JSON.parse(body);
+ if (response.translations && response.translations[0]) {
+ resolve(response.translations[0].text);
+ } else {
+ reject(new Error(`Translation failed: ${body}`));
+ }
+ } catch (e) {
+ reject(e);
+ }
+ });
+ });
+
+ req.on('error', reject);
+ req.write(data.toString());
+ req.end();
+ });
+}
+
+/**
+ * Translate entire object recursively
+ */
+async function translateObject(obj, targetLang, prefix = '') {
+ const result = {};
+
+ for (const [key, value] of Object.entries(obj)) {
+ const fullKey = prefix ? `${prefix}.${key}` : key;
+
+ if (typeof value === 'object' && value !== null) {
+ console.log(` Translating section: ${fullKey}...`);
+ result[key] = await translateObject(value, targetLang, fullKey);
+ } else if (typeof value === 'string') {
+ try {
+ console.log(` Translating: ${fullKey}`);
+ const translated = await translateText(value, targetLang);
+ result[key] = translated;
+ // Rate limiting
+ await new Promise(resolve => setTimeout(resolve, 100));
+ } catch (error) {
+ console.error(` ERROR translating ${fullKey}:`, error.message);
+ result[key] = value; // Fallback to original
+ }
+ } else {
+ result[key] = value;
+ }
+ }
+
+ return result;
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+ console.log('═══════════════════════════════════════════════════════════');
+ console.log(' AGENT LIGHTNING PAGE TRANSLATION (DeepL API)');
+ console.log('═══════════════════════════════════════════════════════════\n');
+
+ // Create output directory
+ const outputDir = path.join(__dirname, '../public/locales');
+
+ // Save English version
+ const enPath = path.join(outputDir, 'en/agent-lightning-integration.json');
+ fs.writeFileSync(enPath, JSON.stringify(content, null, 2));
+ console.log(`✓ English saved: ${enPath}\n`);
+
+ // Translate to German
+ console.log('Translating to German (DE)...');
+ const deContent = await translateObject(content, 'DE');
+ const dePath = path.join(outputDir, 'de/agent-lightning-integration.json');
+ fs.writeFileSync(dePath, JSON.stringify(deContent, null, 2));
+ console.log(`✓ German saved: ${dePath}\n`);
+
+ // Translate to French
+ console.log('Translating to French (FR)...');
+ const frContent = await translateObject(content, 'FR');
+ const frPath = path.join(outputDir, 'fr/agent-lightning-integration.json');
+ fs.writeFileSync(frPath, JSON.stringify(frContent, null, 2));
+ console.log(`✓ French saved: ${frPath}\n`);
+
+ console.log('═══════════════════════════════════════════════════════════');
+ console.log(' TRANSLATION COMPLETE');
+ console.log('═══════════════════════════════════════════════════════════');
+ console.log('\nFiles created:');
+ console.log(` ${enPath}`);
+ console.log(` ${dePath}`);
+ console.log(` ${frPath}`);
+}
+
+main().catch(console.error);