The BACON-AI
12-Phase Framework

Phase 1 -- Context Loading: Every session begins by loading the full project context: files, constraints, objectives, existing knowledge, and lessons learned from previous sessions. This ensures continuity across sessions.

Phase 2 -- Complexity Analysis: A weighted scoring system classifies tasks as TRIVIAL, STANDARD, or CRITICAL. This determines the level of governance, validation, and documentation required -- avoiding over-engineering simple tasks while ensuring rigour for complex ones.

Phase 3 -- Architecture Design: Solution architecture is designed with clear component boundaries, interfaces, and data flows. For CRITICAL tasks, this includes threat modelling and failure mode analysis.

Phase 4 -- Implementation Plan: A detailed execution plan with validation checkpoints is created before any code is written. This includes file-level change lists, test strategies, and rollback plans.

Phase 5 -- Progressive Build: Implementation proceeds in incremental stages. Each stage is verified before the next begins. This "shift-left" approach catches issues early when they're cheapest to fix.

Phase 6 -- Unit Validation: Individual components are tested against requirements and edge cases. Both automated tests and manual verification ensure each piece works correctly in isolation.

Phase 7 -- Integration Testing: Components are tested together to verify interactions, data flows, and end-to-end workflows. This catches interface mismatches and emergent bugs.

Phase 8 -- Self-Annealing: The methodology itself adjusts based on outcomes. If a phase consistently produces defects, the framework tightens its validation. If a phase is consistently clean, governance is relaxed. Three self-annealing rules (SA-001, SA-002, SA-003) govern this process.

Phase 9 -- Quality Gates: Automated checkpoints ensure standards are met before progression. These gates are non-negotiable -- no phase can be skipped, and failures must be resolved before moving forward.

Phase 10 -- Documentation: Comprehensive records of decisions, patterns, and outcomes are generated automatically. This includes architecture decision records (ADRs), change logs, and test evidence.

Phase 11 -- Knowledge Capture: Lessons learned are extracted from the session and integrated into the persistent knowledge base. This feeds back into Phase 1 for future sessions, creating a compounding learning effect.

Phase 12 -- Deployment & Review: The solution ships to production with monitoring and continuous improvement built in. A retrospective captures what went well and what could improve.

BACON-AI orchestrates multiple specialised AI agents working in concert. The Orchestrator Agent coordinates tasks, manages context propagation, and ensures coherent output across complex workflows.

Specialised agents include: Architects (system design), Builders (implementation), Testers (quality assurance), Researchers (information gathering), and Observers (process monitoring and retrospectives).

Each agent inherits full context through a standardised context package, ensuring no information is lost during handoffs. Voice-enabled status reporting (Elisabeth, Finn, Aoede, Fenrir) provides real-time progress updates.

The Natural Problem Solving Language (NPSL v3.0) defines 20 control points that govern AI agent behaviour. These range from context validation and complexity scoring to quality gates and deployment checks.

Self-Annealing Rules:

SA-001: If a validation gate fails twice consecutively, escalate governance level for that phase.

SA-002: If all gates pass for 5 consecutive runs, reduce mandatory evidence requirements by one level.

SA-003: If a new failure pattern is detected, create a prevention rule and add it to the knowledge base.

This creates a system that gets stricter where needed and more efficient where proven reliable -- like annealing metal to find its optimal strength.