Core Framework

RIGOR Framework

Research, Inspect, Generate, Optimize, Review - The 5-phase execution framework governing all autonomous agent operations.

The Five Phases

Phase 1: Research

Gather context, validate assumptions, and identify constraints before taking action.

Activities

Analyze codebase structure and patterns
Retrieve relevant knowledge from graph
Identify dependencies and constraints
Validate initial assumptions
Build execution context

Outputs

Context analysisConstraint mapKnowledge retrievalAssumption validation

Phase 2: Inspect

Audit safety, verify constraints, and run pre-execution quality gates.

Activities

Run security audit checks
Verify preconditions met
Execute multi-dimensional quality gates
Check reversibility requirements
Validate bounded autonomy

Outputs

Security reportGate resultsRisk assessmentGo/no-go decision

Phase 3: Generate

Execute the task, produce artifacts with confidence scoring and decision documentation.

Activities

Execute primary operation
Generate artifacts (code, config, etc.)
Calculate confidence scores
Document decisions and reasoning
Select appropriate patterns

Outputs

Generated artifactConfidence scoreDecision logPattern selection

Phase 4: Optimize

Tune performance, minimize costs, and trigger learning from the execution.

Activities

Performance optimization
Cost minimization analysis
Feedback integration
Pattern effectiveness update
Learning trigger

Outputs

Optimized resultCost analysisLearning observationsFeedback loop

Phase 5: Review

Validate outcomes, run A/B tests, prepare rollback, and record success metrics.

Activities

Validate execution outcome
Run hypothesis testing
Prepare rollback plan
Record success metrics
Update knowledge graph

Outputs

Validation reportTest resultsRollback planSuccess metrics

Quality Gates (21 Total)

Pre-deployment validation gates that ensure operational quality and compliance.

v1.5 Gates (Operational Quality)

RIGOR Confidence

Minimum confidence score for execution

70%

Security Scan

Security vulnerability detection

Pass

Test Coverage

Minimum code test coverage

70%

Code Review

Automated code review checks

Approved

ACMF Validation

Maturity level compliance

Mode-appropriate

Performance Check

Performance baseline comparison

<5% regression

Compliance Check

Regulatory compliance validation

Pass

Dependency Audit

Dependency vulnerability scan

No critical CVEs

Schema Consistency

SQL query schema validation

100%

Docker Build Compliance

Build configuration validation

Platform match

Image Tag Consistency

Container image verification

ECR verified

v1.6 Gates (Enterprise Governance)

Runtime Confidence

Real-time confidence monitoring

70%

Context Quality

Context pollution detection

80%

Test Coverage Minimum

Enforced test coverage

70%

Audit Trail Present

EU AI Act compliance

100%

Model Drift

Output distribution drift detection

<15%

Cost Anomaly

Cost spike prevention

<2x baseline

Rollback Capability

Rollback mechanism verification

Exists

Human Approval

High-risk operation approval

Approved

Supply Chain Integrity

Dependency security

Verified

Cascade Protection

Circuit breaker verification

Configured

ACMF Integration

RIGOR works in conjunction with the ACMF (Agent Capability Maturity Framework) to control execution flow based on agent maturity level.

Execution Flow with ACMF

RESEARCH → INSPECT → GENERATE → [ACMF Check] → OPERATIONALIZE → REVIEW
                                    ↓
                        ┌─────────────────────────┐
                        │  OBSERVE/LEARNING Mode  │
                        │  ↓                      │
                        │  Status: awaiting_approval
                        │  (Pause until human approves)
                        └─────────────────────────┘
                                    ↓
                        ┌─────────────────────────┐
                        │  ASSISTED Mode          │
                        │  ↓                      │
                        │  Critical ops: await approval
                        │  Normal ops: continue
                        └─────────────────────────┘
                                    ↓
                        ┌─────────────────────────┐
                        │  AUTONOMOUS Mode        │
                        │  ↓                      │
                        │  Continue execution
                        │  (Audit trail only)
                        └─────────────────────────┘

Runtime Governance (ACMF)

• Controls execution during RIGOR phases
• Based on agent maturity level
• Automatic progression/regression
• Per-agent state persistence

Pre-Deploy Governance (Gates)

• Validates before deployment starts
• Based on operation risk level
• Cannot bypass for high-risk ops
• 24-hour approval timeout

Implementation Example

RIGOR Executor (Go)

// ExecuteWithRIGOR runs an operation through all 5 RIGOR phases
func (re *RIGORExecutor) ExecuteWithRIGOR(
    ctx context.Context,
    agentID string,
    capability string,
    acmfMode ACMFMode,
    input map[string]interface{},
    phases *RIGORPhaseHandlers,
) (*RIGORExecution, error) {

    execution := &RIGORExecution{
        ID:           generateExecutionID(agentID),
        AgentID:      agentID,
        Capability:   capability,
        ACMFMode:     acmfMode,
        CurrentPhase: PhaseResearch,
        Status:       "running",
    }

    // Phase 1: RESEARCH
    researchResult := re.executePhase(ctx, execution, PhaseResearch, phases.Research)
    if !researchResult.Success {
        return execution, fmt.Errorf("research phase failed")
    }

    // Phase 2: INSPECT (Quality Gates)
    inspectResult := re.executePhase(ctx, execution, PhaseInspect, phases.Inspect)
    if !inspectResult.Success {
        return execution, fmt.Errorf("inspect phase failed")
    }

    // Phase 3: GENERATE
    generateResult := re.executePhase(ctx, execution, PhaseGenerate, phases.Generate)

    // ACMF Check - Human approval for OBSERVE/LEARNING modes
    if acmfMode == ACMFModeShadow || acmfMode == ACMFModeLearning {
        execution.Status = "awaiting_approval"
        return execution, nil  // Pause until approved
    }

    // Phase 4: OPERATIONALIZE
    operationalizeResult := re.executePhase(ctx, execution, PhaseOperationalize, phases.Operationalize)

    // Phase 5: REVIEW
    reviewResult := re.executePhase(ctx, execution, PhaseReview, phases.Review)

    execution.Status = "completed"
    return execution, nil
}

Continue Exploring

Learn more about related architectural components

ACMF Maturity Model Safety Architecture Architecture Overview