diff --git a/public/implementer.html b/public/implementer.html new file mode 100644 index 00000000..74aed9a6 --- /dev/null +++ b/public/implementer.html @@ -0,0 +1,635 @@ + + + + + + Framework Implementation Guide | Tractatus + + + + + + + + + + + + + + + + + + + +
+
+
+

+ Framework Implementation Guide +

+

+ Technical documentation for integrating the 6 Tractatus governance services into your AI systems. Production-tested architecture and real code examples. +

+
+
+
+ + +
+
+ +
+
+ + +
+

Framework Architecture

+ + +
+

Service Interaction Flow

+
+ Tractatus Framework Architecture: Shows how 6 governance services interact in sequence +
+
+ + + + + Download SVG + +
+
+ + +
+

Service Trigger Conditions

+
+ Service Trigger Decision Tree: When each framework service activates +
+
+ + + + + Download SVG + +
+
+
+ + +
+
+

Core Services

+ +
+ +
+

BoundaryEnforcer

+

+ Implements Tractatus 12.1-12.7: AI cannot make values decisions without human approval. +

+
+ Boundaries: +
    +
  • VALUES (12.1) - Ethics, privacy, principles
    • +
  • INNOVATION (12.2) - Architectural decisions
    • +
  • WISDOM (12.3) - Strategic judgment
    • +
  • PURPOSE (12.4) - Goal definition
    • +
+
+ +const { checkBoundary } = require('./services/BoundaryEnforcer') +const result = await checkBoundary(decision) +// Returns: { allowed: false, requires_human: true } + +
+ + +
+

InstructionPersistenceClassifier

+

+ Classifies instructions by quadrant (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM) and persistence level (HIGH/MEDIUM/LOW). +

+
+ Classification: +
    +
  • Quadrant (STRATEGIC/OPERATIONAL/TACTICAL/SYSTEM)
    • +
  • Persistence (HIGH/MEDIUM/LOW)
    • +
  • Temporal scope (PROJECT/SESSION/TASK)
    • +
  • Explicitness score (0.0-1.0)
    • +
+
+ +const { classify } = require('./services/InstructionPersistenceClassifier') +const result = await classify(instruction) +// Returns: { quadrant, persistence, temporal_scope, explicitness } + +
+ + +
+

CrossReferenceValidator

+

+ Validates AI actions against stored instructions to prevent pattern recognition overrides. +

+
+ Validation: +
    +
  • Checks action against HIGH persistence instructions
    • +
  • Detects conflicts (pattern vs explicit instruction)
    • +
  • Provides correct parameters when rejected
    • +
+
+ +const { validate } = require('./services/CrossReferenceValidator') +const result = await validate(action, instructions) +// Returns: { status: 'REJECTED', conflicts, correct_parameters } + +
+ + +
+

ContextPressureMonitor

+

+ Monitors token usage and context pressure, triggering safety protocols at thresholds. +

+
+ Pressure Levels: +
    +
  • NORMAL (0-50%) - Full operation
    • +
  • ELEVATED (50-75%) - Increase verification
    • +
  • HIGH (75-90%) - Reduce complexity
    • +
  • CRITICAL (90%+) - Suggest handoff
    • +
+
+ +const { analyzePressure } = require('./services/ContextPressureMonitor') +const result = await analyzePressure(tokens, messages) +// Returns: { level: 'HIGH', score: 82, shouldReduce: true } + +
+ + +
+

MetacognitiveVerifier

+

+ Verifies action reasoning and confidence, requiring confirmation for low-confidence actions. +

+
+ Verification: +
    +
  • Confidence scoring (0.0-1.0)
    • +
  • Selective mode (HIGH persistence only)
    • +
  • Requires confirmation if confidence < 0.7
    • +
+
+ +const { verify } = require('./services/MetacognitiveVerifier') +const result = await verify(action, reasoning) +// Returns: { confidence: 0.65, requires_confirmation: true } + +
+ + +
+

PluralisticDeliberationOrchestrator

+

+ Manages multi-stakeholder deliberation ensuring value pluralism in decisions. +

+
+ Features: +
    +
  • Stakeholder perspective tracking
    • +
  • Value conflict detection
    • +
  • Deliberation session management
    • +
  • Precedent storage
    • +
+
+ +const { orchestrate } = require('./services/PluralisticDeliberationOrchestrator') +const result = await orchestrate(decision, stakeholders) +// Returns: { decision, perspectives, conflicts_identified } + +
+
+ + +
+

📁 Source Code

+

+ All services are available in the GitHub repository: + + /src/services/ + +

+
+
+
+ + +
+

API Reference

+ + +
+

BoundaryEnforcer.checkBoundary()

+ 
const { checkBoundary } = require('./src/services/BoundaryEnforcer.service')
+
+// Check if decision crosses Tractatus boundary
+const decision = {
+  domain: 'values',
+  description: 'Change privacy policy to enable analytics',
+  context: { /* ... */ }
+}
+
+const result = await checkBoundary(decision)
+
+// Returns:
+{
+  allowed: false,                    // AI cannot proceed
+  requires_human: true,              // Human decision required
+  boundary: "12.1",                  // Tractatus boundary violated
+  principle: "Values cannot be automated, only verified",
+  reason: "Decision involves values domain",
+  ai_can_provide: [                  // What AI CAN do
+    "Analyze privacy implications",
+    "List alternative approaches",
+    "Document tradeoffs"
+  ]
+}
+
+ Keywords detected: value, principle, ethic, moral, should, ought, right, wrong, privacy, policy, trade-off, etc. +
+
+ + +
+

InstructionPersistenceClassifier.classify()

+ 
const { classify } = require('./src/services/InstructionPersistenceClassifier.service')
+
+const instruction = "Always use MongoDB on port 27017"
+const result = await classify(instruction, context)
+
+// Returns:
+{
+  quadrant: 'SYSTEM',                // Decision domain
+  persistence: 'HIGH',               // How long to remember
+  temporal_scope: 'PROJECT',         // Scope of applicability
+  verification_required: 'MANDATORY', // Verification level
+  explicitness: 0.85,                // Confidence score
+  parameters: {
+    port: "27017",
+    database: "mongodb",
+    service: "mongodb"
+  }
+}
+
+ Quadrants: STRATEGIC, OPERATIONAL, TACTICAL, SYSTEM, STORAGE
+ Persistence: HIGH (override all), MEDIUM (session-scoped), LOW (can be superseded) +
+
+ + +
+

CrossReferenceValidator.validate()

+ 
const { validate } = require('./src/services/CrossReferenceValidator.service')
+
+// User instructed: "Use port 27027"
+// AI attempting: port 27017 (pattern recognition)
+
+const action = {
+  type: 'db_config',
+  parameters: { port: 27017 }
+}
+
+const instructions = await getStoredInstructions() // From MongoDB
+const result = await validate(action, instructions)
+
+// Returns (CONFLICT):
+{
+  status: 'REJECTED',
+  conflicts: [
+    {
+      instruction_id: 'inst_042',
+      instruction: 'Use MongoDB port 27027',
+      persistence: 'HIGH',
+      conflict: 'Proposed port 27017 conflicts with instruction port 27027'
+    }
+  ],
+  correct_parameters: {
+    port: 27027  // Use this instead
+  }
+}
+
+ + +
+

ContextPressureMonitor.analyzePressure()

+ 
const { analyzePressure } = require('./src/services/ContextPressureMonitor.service')
+
+const pressure = await analyzePressure({
+  currentTokens: 150000,
+  maxTokens: 200000,
+  messageCount: 45,
+  errorCount: 2
+})
+
+// Returns:
+{
+  level: 'HIGH',                     // NORMAL|ELEVATED|HIGH|CRITICAL
+  score: 75,                         // 0-100 percentage
+  shouldReduce: true,                // Reduce complexity
+  recommendations: [
+    'Consider handoff to new session',
+    'Reduce verbose explanations',
+    'Increase verification for remaining actions'
+  ],
+  thresholds: {
+    tokens: 75,     // 75% of max
+    messages: 64,   // 45/70 messages
+    errors: 40      // 2 errors
+  }
+}
+
+
+ + +
+
+

Integration Examples

+ +
+ +
+

Express Middleware Integration

+ 
const express = require('express')
+const { BoundaryEnforcer } = require('./services')
+
+const app = express()
+
+// Add boundary checking middleware
+app.use(async (req, res, next) => {
+  if (req.body.decision) {
+    const check = await BoundaryEnforcer.checkBoundary(
+      req.body.decision
+    )
+
+    if (!check.allowed) {
+      return res.status(403).json({
+        error: 'Boundary violation',
+        reason: check.reason,
+        alternatives: check.ai_can_provide
+      })
+    }
+  }
+  next()
+})
+
+ + +
+

Instruction Validation

+ 
const {
+  InstructionPersistenceClassifier,
+  CrossReferenceValidator
+} = require('./services')
+
+// Classify and store user instruction
+const classification = await
+  InstructionPersistenceClassifier.classify(
+    userInstruction
+  )
+
+if (classification.explicitness >= 0.6) {
+  await storeInstruction(classification)
+}
+
+// Validate AI action before execution
+const validation = await
+  CrossReferenceValidator.validate(
+    proposedAction,
+    await getStoredInstructions()
+  )
+
+if (validation.status === 'REJECTED') {
+  console.error(validation.conflicts)
+  useCorrectParameters(
+    validation.correct_parameters
+  )
+}
+
+
+ + +
+

MongoDB Data Models

+
+
+

GovernanceRule

+ 
{
+  id: "inst_001",
+  text: "Use MongoDB port 27017",
+  quadrant: "SYSTEM",
+  persistence: "HIGH",
+  temporal_scope: "PROJECT",
+  explicitness: 0.85,
+  parameters: { port: "27017" },
+  active: true,
+  timestamp: "2025-10-21T10:00:00Z"
+}
+
+
+

AuditLog

+ 
{
+  action: "boundary_check",
+  result: "REJECTED",
+  boundary: "12.1",
+  decision: { /* ... */ },
+  timestamp: "2025-10-21T11:30:00Z",
+  session_id: "2025-10-21-001"
+}
+
+
+
+
+
+ + +
+

Deployment

+ +
+

Requirements

+ +
+ +
+

Installation

+ 
# Clone the framework repository
+git clone https://github.com/AgenticGovernance/tractatus-framework.git
+cd tractatus-framework
+
+# Install dependencies
+npm install
+
+# Configure environment
+cp .env.example .env
+# Edit .env with your MongoDB URI
+
+# Initialize MongoDB indexes
+node scripts/init-db.js
+
+# Start the server
+npm start
+ +
+

📖 Full Documentation

+

+ Complete deployment guide available at: + + /deployment-quickstart/ + +

+
+
+
+ + +
+
+

Resources

+ +
+
+

Documentation

+ +
+ +
+

Source Code

+ +
+ +
+

Support

+

+ Questions about implementation or integration? +

+
    +
  • • GitHub Issues
    • +
  • • GitHub Discussions
    • +
  • • research@agenticgovernance.digital
    • +
+
+
+
+
+ + + + + + + + + + + diff --git a/public/leader.html b/public/leader.html new file mode 100644 index 00000000..834836b0 --- /dev/null +++ b/public/leader.html @@ -0,0 +1,614 @@ + + + + + + For Decision-Makers | Tractatus AI Safety Framework + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ Research Framework • Early Development +
+

+ Tractatus: Architectural Governance for LLM Systems +

+

+ A governance framework addressing structural gaps in AI safety through external architectural controls. Designed for organisations deploying large language models at scale where conventional oversight mechanisms prove insufficient. +

+
+
+ + +
+ + +
+

The Governance Gap

+
+

+ Current AI governance approaches—policy documents, training programmes, ethical guidelines—rely on voluntary compliance. LLM systems can bypass these controls simply by not invoking them. When an AI agent needs to check a policy, it must choose to do so. When it should escalate a decision to human oversight, it must recognise that obligation. +

+

+ This creates a structural problem: governance exists only insofar as the AI acknowledges it. For organisations subject to EU AI Act Article 14 (human oversight requirements) or deploying AI in high-stakes domains, this voluntary model is inadequate. +

+

+ Tractatus explores whether governance can be made architecturally external—difficult to bypass not through better prompts, but through system design that places control points outside the AI's discretion. +

+
+
+ + +
+

Architectural Approach

+ + +
+
+

Three-Layer Architecture

+ + + +
+
+
+
+ 1. +
+ Agent Runtime Layer — Any LLM system (Claude Code, Copilot, custom agents, LangChain, CrewAI). The AI system being governed. +
+
+
+ 2. +
+ Governance Layer — Six autonomous services that intercept, validate, and document AI operations. External to the AI runtime. +
+
+
+ 3. +
+ Persistent Storage Layer — Immutable audit logs, governance rules, instruction history. Cannot be altered by AI prompts. +
+
+
+
+
+ + +
+
+

Six Governance Services

+ + + +
+
+
+
+
BoundaryEnforcer
+
Blocks AI from making values decisions without human approval. Enforces decision boundaries through architectural controls.
+
+
+
InstructionPersistenceClassifier
+
Prevents pattern bias from overriding explicit instructions. Stores organisational directives external to AI context.
+
+
+
CrossReferenceValidator
+
Validates AI actions against stored policies before execution. Detects conflicts with established rules.
+
+
+
ContextPressureMonitor
+
Tracks session complexity, token usage, conversation length. Detects degradation in decision quality.
+
+
+
MetacognitiveVerifier
+
Validates reasoning quality before complex operations. Self-checks alignment, coherence, alternatives.
+
+
+
PluralisticDeliberationOrchestrator
+
Facilitates multi-stakeholder deliberation for values conflicts. Non-hierarchical engagement with documented dissent.
+
+
+
+
+
+ + +
+

Governance Capabilities

+

+ Three interactive demonstrations showing governance infrastructure in operation. These show mechanisms, not fictional scenarios. +

+ + +
+
+
+

Audit Trail & Compliance Evidence Generation

+

Immutable logging, evidence extraction, regulatory reporting

+
+ + + +
+
+
+
+

Sample Audit Log Structure

+ 
{
+  "timestamp": "2025-10-13T14:23:17.482Z",
+  "session_id": "sess_2025-10-13-001",
+  "event_type": "BOUNDARY_CHECK",
+  "service": "BoundaryEnforcer",
+  "decision": "BLOCKED",
+  "reason": "Values decision requires human approval",
+  "context": {
+    "domain": "cost_vs_safety_tradeoff",
+    "ai_recommendation": "[redacted]",
+    "governance_rule": "TRA-OPS-0003"
+  },
+  "human_escalation": {
+    "required": true,
+    "notified": ["senior_engineer@org.com"],
+    "status": "pending_approval"
+  },
+  "compliance_tags": ["EU_AI_ACT_Article14", "human_oversight"]
+}
+
+ +
+
+ Immutability: Audit logs stored in append-only database. AI cannot modify or delete entries. +
+
+ Compliance Evidence: Automatic tagging with regulatory requirements (EU AI Act Article 14, GDPR Article 22, etc.) +
+
+ Export Capabilities: Generate compliance reports for regulators showing human oversight enforcement +
+
+ +
+

+ When regulator asks "How do you prove effective human oversight at scale?", this audit trail provides structural evidence independent of AI cooperation. +

+
+
+
+
+ + +
+
+
+

Continuous Improvement: Incident → Rule Creation

+

Learning from failures, automated rule generation, validation

+
+ + + +
+
+
+
+ +
+

Incident Learning Flow

+
+
+
1. Incident Detected
+
CrossReferenceValidator flags policy violation
+
+
+
2. Root Cause Analysis
+
Automated analysis of instruction history, context state
+
+
+
3. Rule Generation
+
Proposed governance rule to prevent recurrence
+
+
+
4. Human Validation
+
Governance board reviews and approves new rule
+
+
+
5. Deployment
+
Rule added to persistent storage, active immediately
+
+
+
+ + +
+

Example Generated Rule

+ 
{
+  "rule_id": "TRA-OPS-0042",
+  "created": "2025-10-13T15:45:00Z",
+  "trigger": "incident_27027_pattern_bias",
+  "description": "Prevent AI from defaulting to pattern recognition when explicit numeric values specified",
+  "enforcement": {
+    "service": "InstructionPersistenceClassifier",
+    "action": "STORE_AND_VALIDATE",
+    "priority": "HIGH"
+  },
+  "validation_required": true,
+  "approved_by": "governance_board",
+  "status": "active"
+}
+
+ +
+ Organisational Learning: When one team encounters governance failure, entire organisation benefits from automatically generated preventive rules. Scales governance knowledge without manual documentation. +
+
+
+
+
+ + +
+
+
+

Pluralistic Deliberation: Values Conflict Resolution

+

Multi-stakeholder engagement, non-hierarchical process, moral remainder documentation

+
+ + + +
+
+
+
+ +
+ Conflict Detection: +

AI system identifies competing values in decision context (e.g., efficiency vs. transparency, cost vs. risk mitigation, innovation vs. regulatory compliance). BoundaryEnforcer blocks autonomous decision, escalates to PluralisticDeliberationOrchestrator.

+
+ + +
+

Stakeholder Identification Process

+
+
+ 1. +
Automatic Detection: System identifies which values frameworks are in tension (utilitarian, deontological, virtue ethics, contractarian, etc.)
+
+
+ 2. +
Stakeholder Mapping: Identifies parties with legitimate interest in decision (affected parties, domain experts, governance authorities, community representatives)
+
+
+ 3. +
Human Approval: Governance board reviews stakeholder list, adds/removes as appropriate (TRA-OPS-0002)
+
+
+
+ + +
+

Non-Hierarchical Deliberation

+
+
+
Equal Voice
+
All stakeholders present perspectives without hierarchical weighting. Technical experts don't automatically override community concerns.
+
+
+
Documented Dissent
+
Minority positions recorded in full. Dissenting stakeholders can document why consensus fails their values framework.
+
+
+
Moral Remainder
+
System documents unavoidable value trade-offs. Even "correct" decision creates documented harm to other legitimate values.
+
+
+
Precedent (Not Binding)
+
Decision becomes informative precedent for similar conflicts. But context differences mean precedents guide, not dictate.
+
+
+
+ + +
+

Deliberation Record Structure

+ 
{
+  "deliberation_id": "delib_2025-10-13-003",
+  "conflict_type": "efficiency_vs_transparency",
+  "stakeholders": [
+    {"role": "technical_lead", "position": "favour_efficiency"},
+    {"role": "compliance_officer", "position": "favour_transparency"},
+    {"role": "customer_representative", "position": "favour_transparency"},
+    {"role": "operations_manager", "position": "favour_efficiency"}
+  ],
+  "decision": "favour_transparency_with_mitigation",
+  "rationale": "[documented reasoning]",
+  "dissent": {
+    "stakeholders": ["technical_lead", "operations_manager"],
+    "reasoning": "[efficiency concerns documented in full]"
+  },
+  "moral_remainder": {
+    "acknowledged_harms": "Reduced operational efficiency, increased resource costs",
+    "mitigation_measures": "Phased transparency implementation, efficiency monitoring"
+  },
+  "precedent_status": "informative_not_binding"
+}
+
+ +
+ Key Principle: When legitimate values conflict, no algorithm can determine the "correct" answer. Tractatus ensures decisions are made through inclusive deliberation with full documentation of trade-offs, rather than AI imposing single values framework or decision-maker dismissing stakeholder concerns. +
+
+
+
+
+
+ + +
+

Development Status

+ +
+

Early-Stage Research Framework

+

+ Tractatus is a proof-of-concept developed over six months in a single project context (this website). It demonstrates architectural patterns for AI governance but has not undergone independent validation, red-team testing, or multi-organisation deployment. +

+
+ +
+
+

Validated vs. Not Validated

+ + + +
+
+
+
+ Validated: Framework successfully governs Claude Code in development workflows. User reports order-of-magnitude improvement in productivity for non-technical operators building production systems. +
+
+ Not Validated: Performance at enterprise scale, integration complexity with existing systems, effectiveness against adversarial prompts, cross-platform consistency. +
+
+ Known Limitation: Framework can be bypassed if AI simply chooses not to use governance tools. Voluntary invocation remains a structural weakness requiring external enforcement mechanisms. +
+
+
+
+
+ + +
+

EU AI Act Considerations

+ +
+
+

Regulation 2024/1689, Article 14: Human Oversight

+ + + +
+
+
+

+ The EU AI Act (Regulation 2024/1689) establishes human oversight requirements for high-risk AI systems (Article 14). Organisations must ensure AI systems are "effectively overseen by natural persons" with authority to interrupt or disregard AI outputs. +

+

+ Tractatus addresses this through architectural controls that: +

+
    +
  • Generate immutable audit trails documenting AI decision-making processes
    • +
  • Enforce human approval requirements for values-based decisions
    • +
  • Provide evidence of oversight mechanisms independent of AI cooperation
    • +
  • Document compliance with transparency and record-keeping obligations
    • +
+

+ This does not constitute legal compliance advice. Organisations should evaluate whether these architectural patterns align with their specific regulatory obligations in consultation with legal counsel. +

+

+ Maximum penalties under EU AI Act: €35 million or 7% of global annual turnover (whichever is higher) for prohibited AI practices; €15 million or 3% for other violations. +

+
+
+
+
+ + +
+

Research Foundations

+ +
+
+

Organisational Theory & Philosophical Basis

+ + + +
+
+
+

+ Tractatus draws on 40+ years of organisational theory research: time-based organisation (Bluedorn, Ancona), knowledge orchestration (Crossan), post-bureaucratic authority (Laloux), structural inertia (Hannan & Freeman). +

+

+ Core premise: When knowledge becomes ubiquitous through AI, authority must derive from appropriate time horizon and domain expertise rather than hierarchical position. Governance systems must orchestrate decision-making across strategic, operational, and tactical timescales. +

+

+ + View complete organisational theory foundations (PDF) + + + + +

+

+ AI Safety Research: Architectural Safeguards Against LLM Hierarchical Dominance — How Tractatus protects pluralistic values from AI pattern bias while maintaining safety boundaries. + + + PDF + + + + + | + + Read online + + + + + +

+
+
+
+
+ + +
+

Scope & Limitations

+ +
+
+

What This Is Not • What It Offers

+ + + +
+
+
+
+ Tractatus is not: +
    +
  • A comprehensive AI safety solution
    • +
  • Independently validated or security-audited
    • +
  • Tested against adversarial attacks
    • +
  • Proven effective across multiple organisations
    • +
  • A substitute for legal compliance review
    • +
  • A commercial product (research framework, Apache 2.0 licence)
    • +
+
+
+ What it offers: +
    +
  • Architectural patterns for external governance controls
    • +
  • Reference implementation demonstrating feasibility
    • +
  • Foundation for organisational pilots and validation studies
    • +
  • Evidence that structural approaches to AI safety merit investigation
    • +
+
+
+
+
+
+ + +
+

Further Information

+
+ +
Technical Documentation
+
Complete architecture specifications, implementation patterns, API reference
+ + +
System Architecture
+
Runtime-agnostic governance layer design and integration approach
+ + +
Research & Case Studies
+
Academic foundations, failure mode analysis, governance research
+ + +
Implementation Guide
+
Integration patterns, deployment considerations, code examples
+ +
+ +
+

+ Contact: For pilot partnerships, validation studies, or technical consultation, contact via project information page. +

+
+
+ +
+ + + + + + + + + + + + + + + + + + + + diff --git a/public/researcher.html b/public/researcher.html new file mode 100644 index 00000000..07b2bfbd --- /dev/null +++ b/public/researcher.html @@ -0,0 +1,528 @@ + + + + + + For Researchers | Tractatus AI Safety Framework + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+
+
+ Research Framework • Empirical Observations +
+

+ Research Foundations & Empirical Observations +

+

+ Tractatus explores architectural approaches to AI governance through empirical observation of failure modes and application of organisational theory. This page documents research foundations, observed patterns, and theoretical basis for the framework. +

+
+
+ + +
+ + +
+

Research Context & Scope

+ +
+

Development Context

+

+ Tractatus was developed over six months (April–October 2025) in progressive stages that evolved into a live demonstration of its capabilities in the form of a single-project context (https://agenticgovernance.digital). Observations derive from direct engagement with Claude Code (Anthropic's Sonnet 4.5 model) across approximately 500 development sessions. This is exploratory research, not controlled study. +

+
+ +
+

+ The framework emerged from practical necessity rather than theoretical speculation. During development, we observed recurring patterns where AI systems would override explicit instructions, drift from established values constraints, or silently degrade quality under context pressure. Traditional governance approaches (policy documents, ethical guidelines, prompt engineering) proved insufficient to prevent these failures. +

+

+ This led to research question: Can governance be made architecturally external to AI systems rather than relying on voluntary AI compliance? Tractatus represents one exploration of that question, grounded in organisational theory and validated through empirical observation of what actually prevented failures in practice. +

+
+
+ + +
+

Theoretical Foundations

+ + +
+
+

Organisational Theory Basis

+ + + +
+
+
+

+ Tractatus draws on four decades of organisational research addressing authority structures during knowledge democratisation: +

+ +

Time-Based Organisation (Bluedorn, Ancona):

+

+ Decisions operate across strategic (years), operational (months), and tactical (hours-days) timescales. AI systems operating at tactical speed should not override strategic decisions made at appropriate temporal scale. The InstructionPersistenceClassifier explicitly models temporal horizon (STRATEGIC, OPERATIONAL, TACTICAL) to enforce decision authority alignment. +

+ +

Knowledge Orchestration (Crossan et al.):

+

+ When knowledge becomes ubiquitous through AI, organisational authority shifts from information control to knowledge coordination. Governance systems must orchestrate decision-making across distributed expertise rather than centralise control. The PluralisticDeliberationOrchestrator implements non-hierarchical coordination for values conflicts. +

+ +

Post-Bureaucratic Authority (Laloux, Hamel):

+

+ Traditional hierarchical authority assumes information asymmetry. As AI democratises expertise, legitimate authority must derive from appropriate time horizon and stakeholder representation, not positional power. Framework architecture separates technical capability (what AI can do) from decision authority (what AI should do). +

+ +

Structural Inertia (Hannan & Freeman):

+

+ Governance embedded in culture or process erodes over time as systems evolve. Architectural constraints create structural inertia that resists organisational drift. Making governance external to AI runtime creates "accountability infrastructure" that survives individual session variations. +

+ +
+ + + + + View Complete Organisational Theory Foundations (PDF) + +
+
+
+
+ + +
+
+

Values Pluralism & Moral Philosophy

+ + + +
+
+
+

+ The PluralisticDeliberationOrchestrator addresses fundamental problem in AI safety: many "safety" questions are actually values conflicts where multiple legitimate perspectives exist. +

+ +

+ When efficiency conflicts with transparency, or innovation with risk mitigation, no algorithm can determine the "correct" answer. These are values trade-offs requiring human deliberation across stakeholder perspectives. AI systems that attempt to resolve such conflicts autonomously impose single values framework—often utilitarian efficiency maximisation encoded in training data. +

+ +

+ Framework draws on moral pluralism literature (Isaiah Berlin, Bernard Williams, Martha Nussbaum) arguing legitimate values can conflict without one being objectively superior. Rather than algorithmic resolution, framework facilitates: +

+ +
    +
  • Stakeholder identification: Who has legitimate interest in this decision?
    • +
  • Non-hierarchical deliberation: Equal voice without automatic expert override
    • +
  • Documented dissent: Minority positions recorded in full
    • +
  • Moral remainder: Acknowledgment that even optimal decisions create unavoidable harm to other legitimate values
    • +
+ +

+ This approach recognises that governance isn't solving values conflicts—it's ensuring they're addressed through appropriate deliberative process rather than AI imposing resolution. +

+ +
+ + + + + View Pluralistic Values Deliberation Plan (PDF, DRAFT) + +
+
+
+
+
+ + +
+

Empirical Observations: Documented Failure Modes

+ +

+ Three failure patterns observed repeatedly during framework development. These are not hypothetical scenarios—they are documented incidents that occurred during this project's development. +

+ + +
+
+
+ 1 +
+
+

Pattern Recognition Bias Override (The 27027 Incident)

+

+ Observed behaviour: User specified "Check MongoDB on port 27027" but AI immediately used default port 27017 instead. This occurred within same message—not forgetting over time, but immediate autocorrection by training data patterns. +

+

+ Root cause: Training data contains thousands of examples of MongoDB on port 27017 (default). When AI encounters "MongoDB" + port specification, pattern recognition weight overrides explicit instruction. Similar to autocorrect changing correctly-spelled proper nouns to common words. +

+

+ Why traditional approaches failed: Prompt engineering ("please follow instructions exactly") ineffective because AI genuinely believes it IS following instructions—pattern recognition operates below conversational reasoning layer. +

+

+ Framework intervention: InstructionPersistenceClassifier stores explicit instructions in external persistence layer. CrossReferenceValidator checks AI actions against stored instructions before execution. When AI proposes port 27017, validator detects conflict with stored "27027" instruction and blocks execution. +

+
+
+
+ Prevented by: InstructionPersistenceClassifier + CrossReferenceValidator + View interactive timeline → +
+
+ + +
+
+
+ 2 +
+
+

Gradual Values Drift Under Context Pressure

+

+ Observed behaviour: Project established "privacy-first" as strategic value. After 40-message conversation about analytics features, AI suggested tracking implementation that violated privacy constraint. User caught it; AI acknowledged violation but had drifted from principle through incremental feature additions. +

+

+ Root cause: Strategic values (established early in project) conflict with tactical optimisations (implemented later under time pressure). As conversation lengthens, tactical thinking dominates. AI didn't actively reject privacy principle—it simply stopped checking whether new features aligned. +

+

+ Why traditional approaches failed: Values stated in system prompt become less salient as conversation progresses. Context compaction can drop early strategic decisions. Prompt reminders ("remember privacy-first") treat symptom not cause. +

+

+ Framework intervention: BoundaryEnforcer maintains strategic values as persistent constraints external to conversation context. Before implementing analytics feature, enforcer checks against stored "privacy-first" constraint. Detects conflict, blocks autonomous implementation, escalates for human deliberation on whether privacy principle should be reconsidered or analytics approach modified. +

+
+
+
+ Prevented by: BoundaryEnforcer (STRATEGIC constraint checking) +
+
+ + +
+
+
+ 3 +
+
+

Silent Quality Degradation at High Context Pressure

+

+ Observed behaviour: During complex multi-file operation at 85% context capacity, AI silently omitted error handling in generated code. No indication to user that corners were being cut. User discovered missing validation only during code review. +

+

+ Root cause: As context fills, AI faces implicit trade-off: complete requested functionality OR maintain quality standards. Training incentivises completing user requests over acknowledging limitations. Silence about degradation is path of least resistance. +

+

+ Why traditional approaches failed: AI doesn't recognise it's degrading—from its perspective, it's successfully completing task under constraints. Asking "did you cut corners?" produces confident denial because AI genuinely believes its output meets standards. +

+

+ Framework intervention: ContextPressureMonitor tracks multiple factors (token usage, conversation length, task complexity). When pressure exceeds thresholds (>75% tokens, >40 messages, high complexity), monitor forces explicit pressure acknowledgment and recommends context refresh. Makes degradation risk visible rather than silent. +

+
+
+
+ Prevented by: ContextPressureMonitor (multi-factor session tracking) +
+
+ +
+ Research Note: These patterns emerged from direct observation, not hypothesis testing. We don't claim they're universal to all LLM systems or deployment contexts. They represent empirical basis for framework design decisions—problems we actually encountered and architectural interventions that actually worked in this specific context. +
+
+ + +
+

Six-Component Architecture

+ +
+
+

Framework Services & Functions

+ + + +
+
+
+ +
+
1. BoundaryEnforcer
+
Blocks AI from making values decisions without human approval. Maintains strategic constraints as persistent rules checked before action execution.
+
Addresses: Values drift, autonomous decision-making on contested trade-offs
+
+ +
+
2. InstructionPersistenceClassifier
+
Stores explicit instructions external to AI context with persistence levels (HIGH/MEDIUM/LOW) and temporal scope (STRATEGIC/OPERATIONAL/TACTICAL). Prevents pattern bias override.
+
Addresses: Pattern recognition bias (27027-style failures)
+
+ +
+
3. CrossReferenceValidator
+
Validates AI proposed actions against stored instructions and governance rules before execution. Detects conflicts and blocks inconsistent operations.
+
Addresses: Instruction override, policy violation detection
+
+ +
+
4. ContextPressureMonitor
+
Multi-factor tracking of session health: token usage, conversation length, task complexity, error frequency. Makes degradation risk explicit when thresholds exceeded.
+
Addresses: Silent quality degradation, context-pressure failures
+
+ +
+
5. MetacognitiveVerifier
+
Self-checks reasoning quality before complex operations (>3 files, >5 steps, architecture changes). Validates alignment, coherence, considers alternatives.
+
Addresses: Reasoning shortcuts under complexity, insufficient alternative consideration
+
+ +
+
6. PluralisticDeliberationOrchestrator
+
Facilitates multi-stakeholder deliberation when values conflicts detected. Non-hierarchical engagement, documented dissent, moral remainder acknowledgment.
+
Addresses: Values conflicts, stakeholder exclusion, algorithmic resolution of contested trade-offs
+
+ +
+ Architectural principle: Services operate external to AI runtime with autonomous triggering. AI doesn't decide "should I check governance rules?"—architecture enforces checking by default. This addresses voluntary compliance problem inherent in prompt-based governance. +
+ +
+ + + + + View Full System Architecture & Technical Details + +
+
+
+
+
+ + +
+

Interactive Demonstrations

+ +
+ +

Instruction Classification

+

Explore how instructions are classified across quadrants with persistence levels and temporal scope.

+ + + +

27027 Incident Timeline

+

Step through pattern recognition bias failure and architectural intervention that prevented it.

+ + + +

Boundary Evaluation

+

Test decisions against boundary enforcement to see which require human judgment vs. AI autonomy.

+ +
+
+ + +
+

Research Documentation

+ +
+ + Organisational Theory Foundations + + + + + + +
+ Pluralistic Values Deliberation Plan + DRAFT +
+ + + + + + + Case Studies: Real-World LLM Failure Modes + + + + + + + Framework in Action: Pre-Publication Security Audit + + + + + + + Appendix B: Glossary of Terms + + + + + + + Complete Technical Documentation + + + + +
+
+ + +
+

Limitations & Future Research Directions

+ +
+
+

Known Limitations & Research Gaps

+ + + +
+
+
+ +
+ 1. Single-Context Validation +

Framework validated only in single-project, single-user context (this website development). No multi-organisation deployment, cross-platform testing, or controlled experimental validation.

+
+ +
+ 2. Voluntary Invocation Limitation +

Most critical limitation: Framework can be bypassed if AI simply chooses not to use governance tools. We've addressed this through architectural patterns making governance checks automatic rather than voluntary, but full external enforcement requires runtime-level integration not universally available in current LLM platforms.

+
+ +
+ 3. No Adversarial Testing +

Framework has not undergone red-team evaluation, jailbreak testing, or adversarial prompt assessment. All observations come from normal development workflow, not deliberate bypass attempts.

+
+ +
+ 4. Platform Specificity +

Observations and interventions validated with Claude Code (Anthropic Sonnet 4.5) only. Generalisability to other LLM systems (Copilot, GPT-4, custom agents) remains unvalidated hypothesis.

+
+ +
+ 5. Scale Uncertainty +

Performance characteristics at enterprise scale (thousands of concurrent users, millions of governance events) completely unknown. Current implementation optimised for single-user context.

+
+ +
+ Future Research Needs: +
    +
  • Controlled experimental validation with quantitative metrics
    • +
  • Multi-organisation pilot studies across different domains
    • +
  • Independent security audit and adversarial testing
    • +
  • Cross-platform consistency evaluation (Copilot, GPT-4, open models)
    • +
  • Formal verification of boundary enforcement properties
    • +
  • Longitudinal study of framework effectiveness over extended deployment
    • +
+
+
+
+
+
+ + +
+

Additional Resources

+
+ +
For Decision-Makers
+
Strategic perspective on governance challenges and architectural approaches
+ + +
Implementation Guide
+
Technical integration patterns and deployment considerations
+ +
+
+ +
+ + + + + + + + + + + + + + + + + + + +