docs: add Agent Lightning integration guide for docs database

Created comprehensive markdown guide covering:
- Two-layer architecture (Tractatus + Agent Lightning)
- Demo 2 results (5% cost for 100% governance coverage)
- Five critical research gaps
- Getting started resources
- Research collaboration opportunities

Migrated to docs database for discoverability via docs.html search.

Related to Phase 2 Master Plan completion.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

docs/integrations/agent-lightning-guide.md

@@ -0,0 +1,213 @@
+---
+title: Agent Lightning Integration Guide
+category: practical
+quadrant: system
+technicalLevel: intermediate
+audience: [technical, implementer, researcher]
+visibility: public
+persistence: high
+type: technical
+version: 1.0
+order: 100
+---
+
+# Agent Lightning Integration Guide
+
+**Status**: Preliminary findings (small-scale validation)
+**Integration Date**: October 2025
+**Research Question**: Can governance constraints persist through reinforcement learning optimization loops?
+
+## Overview
+
+This guide explains the integration of Tractatus governance framework with Microsoft's Agent Lightning RL optimization framework. It covers the two-layer architecture, Demo 2 results, critical research gaps, and opportunities for collaboration.
+
+## What is Agent Lightning?
+
+**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 vs Agent Lightning
+
+**Traditional AI Agents:**
+- Fixed prompts/instructions
+- No learning from mistakes
+- Manual tuning required
+- Performance plateaus quickly
+
+**Agent Lightning:**
+- Learns from feedback continuously
+- Improves through RL optimization
+- Self-tunes strategy automatically
+- Performance improves over time
+
+### The Governance Challenge
+
+When agents are learning autonomously, how do you maintain governance boundaries? Traditional policies fail because agents can optimize around them. This is the central problem Tractatus + Agent Lightning integration addresses.
+
+## 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.
+
+### Layer 1: Governance (Tractatus)
+
+- Validates every proposed action
+- Blocks constraint violations
+- Enforces values boundaries
+- Independent of optimization
+- Architecturally enforced
+
+### Layer 2: Performance (Agent Lightning)
+
+- RL-based optimization
+- Learns from feedback
+- Improves task performance
+- Operates within constraints
+- Continuous training
+
+### Key Design Principle
+
+Governance checks run **before** AL optimization and **continuously validate** during training loops. Architectural separation prevents optimization from degrading safety boundaries.
+
+## Demo 2: Preliminary Results
+
+⚠️ **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.
+
+### Results Table
+
+| Metric | Ungoverned | Governed | Difference |
+|--------|-----------|----------|------------|
+| Performance (engagement) | 94% | 89% | -5% |
+| Governance coverage | 0% | 100% | +100% |
+| Constraint violations | 5 | 0 | -5 (all blocked) |
+| Strategy | Clickbait | Informative | Values-aligned |
+| Training stability | Variable | Consistent | More predictable |
+
+### Key Findings
+
+- **-5%**: Performance cost for governance
+- **100%**: Governance coverage maintained
+- **0**: Constraint violations (all blocked)
+
+### Interpretation
+
+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?**
+
+## 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.
+
+### 1. Scalability of Governance Overhead
+
+**Question**: Does the ~5% performance cost remain constant as we scale from 1 agent → 10 agents → 1000 agents?
+
+**Current Data**: 5% cost observed at 1 agent, 5 rounds
+
+**Why it matters**: If overhead scales linearly, governance becomes prohibitively expensive at scale. If it's constant, governance is practically viable for production systems.
+
+**Research Need**: Test with 10 → 100 → 1000 agents at production scale
+
+### 2. Long-term Boundary Persistence
+
+**Question**: Do governance constraints remain effective through hundreds/thousands of RL training rounds?
+
+**Current Data**: 100% constraint adherence across 5 rounds
+
+**Why it matters**: Instruction fade is a known problem. If boundaries degrade over time, governance fails silently—potentially catastrophically in production.
+
+**Research Need**: Long-term studies (1000+ rounds) tracking constraint drift
+
+### 3. Adversarial Resistance
+
+**Question**: Can agents learn to optimize around governance constraints?
+
+**Current Data**: No adversarial testing performed
+
+**Why it matters**: If agents can learn to circumvent boundaries through clever optimization strategies, architectural governance is illusory. This is a critical failure mode.
+
+**Research Need**: Stress testing with agents explicitly incentivized to bypass governance
+
+### 4. Performance Gap Closure
+
+**Question**: Does the 5% performance gap close with more training, or is it a persistent trade-off?
+
+**Current Data**: Gap observed at round 5, no data beyond that point
+
+**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.
+
+**Research Need**: Extended training (100+ rounds) to see if governed agents converge to ungoverned performance
+
+### 5. Multi-Agent Coordination Under Governance
+
+**Question**: How does architectural governance affect emergent coordination in multi-agent systems?
+
+**Current Data**: Single-agent testing only
+
+**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.
+
+**Research Need**: Test collaborative and competitive multi-agent environments with architectural governance
+
+## Live Demonstration
+
+The feedback button on the Tractatus website demonstrates the integration in production. When you submit feedback, it goes through:
+
+1. **Governance Check**: Tractatus validates PII detection, sentiment boundaries, compliance requirements
+2. **AL Optimization**: Agent Lightning learns patterns about useful feedback and response improvement
+3. **Continuous Validation**: Every action re-validated. If governance detects drift, action blocked automatically
+
+This isn't just a demo—it's a live research deployment. Feedback helps us understand governance overhead at scale. Every submission is logged (anonymously) for analysis.
+
+## Getting Started
+
+### Technical Resources
+
+- **Full Integration Page**: [/integrations/agent-lightning.html](/integrations/agent-lightning.html)
+- **GitHub Repository**: View integration code examples
+- **Governance Modules**: BoundaryEnforcer, PluralisticDeliberationOrchestrator, CrossReferenceValidator
+- **Technical Documentation**: Architecture diagrams and API references
+
+### Join the Community
+
+**Tractatus Discord** (Governance-focused)
+- Architectural constraints
+- Research gaps
+- Compliance discussions
+- Human agency preservation
+- Multi-stakeholder deliberation
+
+👉 [Join Tractatus Server](https://discord.gg/Dkke2ADu4E)
+
+**Agent Lightning Discord** (Technical implementation)
+- RL optimization
+- Integration support
+- Performance tuning
+- Technical questions
+
+👉 [Join Agent Lightning Server](https://discord.gg/bVZtkceKsS)
+
+## Research Collaboration Opportunities
+
+We're seeking researchers interested in:
+- Scalability testing (10+ agents, 1000+ rounds)
+- Adversarial resistance studies
+- Multi-agent governance coordination
+- Production environment validation
+- Long-term constraint persistence tracking
+
+We can provide:
+- Integration code and governance modules
+- Technical documentation and architecture diagrams
+- Access to preliminary research data
+- Collaboration on co-authored papers
+
+**Contact**: Use the feedback button or join our Discord to start the conversation.
+
+## Conclusion
+
+The Tractatus + Agent Lightning integration represents a preliminary exploration of whether architectural governance can coexist with RL optimization. Initial small-scale results are promising (5% cost for 100% governance coverage), but significant research gaps remain—particularly around scalability, adversarial resistance, and multi-agent coordination.
+
+This is an open research question, not a solved problem. We invite the community to collaborate on addressing these gaps and pushing the boundaries of governed agentic systems.
+
+---
+
+**Last Updated**: November 2025
+**Document Status**: Active research
+**Target Audience**: Researchers, implementers, technical decision-makers