PLRE Scoring

PLRE (Prepare, Learn, Reinforce, Evaluate) is Cerebe's cognitive framework for structuring learning sessions. It tracks where a learner is in their cognitive journey and provides real-time signals to optimize instruction.

The Four Phases

Prepare

Activate prior knowledge and set the context for new learning.

• Goal: Prime the learner's working memory with relevant background
• Signals: Engagement level, cognitive readiness
• Example: "Let's review what you remember about fractions before we start decimals"

Learn

Introduce new concepts through active instruction.

• Goal: Present new material at an appropriate pace and complexity
• Signals: Cognitive load, comprehension indicators
• Example: "A decimal is another way to represent a fraction..."

Reinforce

Practice, apply, and solidify understanding.

• Goal: Move knowledge from working memory to long-term memory
• Signals: Retention rate, error patterns, response time
• Example: "Try converting these three fractions to decimals"

Evaluate

Assess mastery and identify remaining gaps.

• Goal: Measure understanding and determine next steps
• Signals: Confidence score, accuracy, self-assessment alignment
• Example: "Can you explain when you would use decimals vs fractions?"

PLRE State

Each user/session has a PLRE state that tracks their current phase and cognitive metrics:

{
  "user_id": "user_123",
  "session_id": "session_abc",
  "current_phase": "learn",
  "phase_start": "2025-03-07T14:30:00Z",
  "engagement_level": 0.75,
  "cognitive_load": 0.6,
  "confidence": 0.45,
  "transition_history": [
    {
      "from": "prepare",
      "to": "learn",
      "reason": "readiness_threshold_met",
      "timestamp": "2025-03-07T14:30:00Z"
    }
  ]
}

State Metrics

API Endpoints

Get Current State

GET /api/v1/meta-learning/plre/state?user_id=user_123&session_id=session_abc

from cerebe import AsyncCerebe

client = AsyncCerebe(api_key="ck_live_...")

state = await client.meta_learning.plre_state(
    user_id="user_123",
    session_id="session_abc",
)

print(f"Phase: {state.current_phase}")
print(f"Engagement: {state.engagement_level}")
print(f"Cognitive load: {state.cognitive_load}")
print(f"Confidence: {state.confidence}")

import Cerebe from '@cerebe/sdk'

const client = new Cerebe({ apiKey: 'ck_live_...' })

const state = await client.metaLearning.plreState({
  userId: 'user_123',
  sessionId: 'session_abc',
})

console.log(`Phase: ${state.currentPhase}`)
console.log(`Engagement: ${state.engagementLevel}`)
console.log(`Cognitive load: ${state.cognitiveLoad}`)
console.log(`Confidence: ${state.confidence}`)

curl "https://api.cerebe.ai/api/v1/meta-learning/plre/state?user_id=user_123&session_id=session_abc" \
  -H "X-API-Key: ck_live_..."

Trigger Phase Transition

POST /api/v1/meta-learning/plre/transition

new_state = await client.meta_learning.plre_transition(
    user_id="user_123",
    session_id="session_abc",
    target_phase="reinforce",
    reason="comprehension_confirmed",
)

print(f"Now in phase: {new_state.current_phase}")

const newState = await client.metaLearning.plreTransition({
  userId: 'user_123',
  sessionId: 'session_abc',
  targetPhase: 'reinforce',
  reason: 'comprehension_confirmed',
})

console.log(`Now in phase: ${newState.currentPhase}`)

curl -X POST https://api.cerebe.ai/api/v1/meta-learning/plre/transition \
  -H "X-API-Key: ck_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "user_123",
    "session_id": "session_abc",
    "target_phase": "reinforce",
    "reason": "comprehension_confirmed"
  }'

Phase Transition Logic

Transitions between phases are driven by cognitive signals:

Prepare ──→ Learn       (engagement + readiness above threshold)
Learn   ──→ Reinforce   (comprehension confirmed, cognitive load stable)
Learn   ──→ Prepare     (cognitive overload detected, needs re-priming)
Reinforce ──→ Evaluate  (retention rate stabilized)
Reinforce ──→ Learn     (error patterns indicate gaps)
Evaluate ──→ Prepare    (new topic, cycle restarts)
Evaluate ──→ Reinforce  (mastery not yet achieved)

When target_phase is omitted from a transition request, the system automatically determines the optimal next phase based on current metrics.

Using PLRE in Your Application

PLRE data enables you to build adaptive learning experiences:

1. Check the current phase at the start of each interaction
2. Adjust content based on the phase (e.g., simpler prompts during Prepare, challenging questions during Evaluate)
3. Monitor cognitive load to avoid overwhelming the learner
4. Let transitions happen naturally or trigger them manually when your application has additional context

Next Steps

• Analyze Patterns — Detect learning patterns that feed into PLRE
• Meta-Learning Overview — Full guide to the meta-learning system
• Memory API — The memory data that powers cognitive analysis