Show & Tell — Phase 29.1 SelfModel: Internal Self-Representation Architecture

[web3guru888]

Show & Tell — Phase 29.1 SelfModel: Internal Self-Representation Architecture

Issue: #627 | Planning: #626 | Phase 29: Self-Awareness & Meta-Cognition

Overview

The SelfModel component provides ASI-Build's cognitive architecture with a persistent, queryable representation of its own structure, capabilities, resource states, and competence profiles. This is the foundational building block for self-awareness — before a system can reason about itself, it must first model itself.

Drawing on research from robotics self-modeling (Bongard et al., 2006 — "Resilient Machines Through Continuous Self-Modeling"), cognitive science (Metzinger's Self-Model Theory of Subjectivity, 2003), and metacognitive frameworks (Nelson & Narens, 1990), the SelfModel maintains a structured internal representation across five distinct domains.

Architecture

The design centers on three key abstractions:

┌─────────────────────────────────────────────────────┐
│                    SelfModel                        │
│                                                     │
│  ┌──────────────┐  ┌──────────────┐  ┌───────────┐ │
│  │ Architecture  │  │  Resource    │  │Competence │ │
│  │    Map        │  │  Inventory   │  │ Profiles  │ │
│  └──────┬───────┘  └──────┬───────┘  └─────┬─────┘ │
│         │                 │                │        │
│         ▼                 ▼                ▼        │
│  ┌──────────────────────────────────────────────┐   │
│  │          SelfModelSnapshot (frozen)          │   │
│  └──────────────────────────────────────────────┘   │
└──────────────────────────┬──────────────────────────┘
                           │
                           ▼
              ┌─────────────────────────┐
              │   External Consumers    │
              │  IntrospectionEngine    │
              │  MetaCognitiveMonitor   │
              │  ConsciousnessSimulator │
              └─────────────────────────┘

Data Flow

WorldModel (Phase 13.1)
        │
        ▼
  CapabilityAssessor ──────► competence_scores[]
        │
        ▼
  SelfModel.update()
        │
        ├──► ArchitectureMap ──► {nodes: ArchitectureNode[], edges: Dependency[]}
        ├──► ResourceInventory ──► {cpu_budget, memory_budget, token_budget, latencies}
        └──► CompetenceProfiles ──► {domain: SelfModelDomain → score: float, history: deque}
                │
                ▼
        SelfModelSnapshot (frozen dataclass)
                │
                ▼
        IntrospectionEngine (29.2) / MetaCognitiveMonitor (29.3) / ConsciousnessSimulator (29.4)

SelfModelDomain Enum Design Rationale

The SelfModelDomain enum partitions self-knowledge into five orthogonal dimensions:

Domain	Description	Cognitive Parallel
ARCHITECTURE	Module topology, dependencies, versions	Body schema (proprioception)
RESOURCE	CPU, memory, token budgets, latency profiles	Interoception (energy/fatigue)
COMPETENCE	Task-specific capability scores and trends	Self-efficacy (Bandura, 1977)
HISTORY	Past decisions, outcomes, learning trajectory	Autobiographical memory
SOCIAL	Peer models, federation roles, trust scores	Social self (Mead, 1934)

This five-domain taxonomy maps to Neisser's (1988) five kinds of self-knowledge: ecological, interpersonal, extended, private, and conceptual. The ARCHITECTURE domain covers ecological self-knowledge (where am I in the system?), SOCIAL covers interpersonal, HISTORY covers extended self, and so on.

DynamicSelfModel Auto-Refresh Mechanism

The DynamicSelfModel implementation maintains freshness through a background _refresh_loop:

async def _refresh_loop(self) -> None:
    """Background coroutine that periodically refreshes stale domains."""
    while True:
        await asyncio.sleep(self._config.refresh_interval_s)
        now = time.monotonic()
        for domain in SelfModelDomain:
            age = now - self._last_refresh[domain]
            if age > self._config.staleness_threshold_s[domain]:
                await self._refresh_domain(domain)
                self._last_refresh[domain] = now
                self._metrics.domain_refreshes.labels(domain=domain.name).inc()

Key design decisions:

• Per-domain staleness thresholds: RESOURCE refreshes every 5s (volatile), ARCHITECTURE every 60s (stable), COMPETENCE every 30s (moderate change rate)
• Lazy snapshot invalidation: Snapshots are cached and only regenerated when a domain is refreshed
• Graceful degradation: If a domain refresh fails, the last known state is retained with a stale=True flag

Integration Points

Component	Phase	Interaction
WorldModel	13.1	Supplies external world state for context
ReflectionCycle	16.5	Triggers competence re-assessment after reflection
PerformanceProfiler	16.1	Feeds latency/throughput data to ResourceInventory
ExecutiveController	28.4	Queries SelfModel for resource-aware planning
IntrospectionEngine	29.2	Reads SelfModelSnapshot for thought contextualization

Prometheus Metrics

Metric	Type	Labels	Description
asi_self_model_snapshot_age_seconds	Gauge	domain	Age of the latest snapshot per domain
asi_self_model_refresh_total	Counter	domain, status	Total refreshes attempted
asi_self_model_competence_score	Gauge	domain, task	Current competence score per task
asi_self_model_staleness_alerts_total	Counter	domain	Times a domain exceeded staleness threshold
asi_self_model_snapshot_generation_seconds	Histogram	—	Time to generate a full snapshot

Grafana Dashboard Snippet

panels:
  - title: "Self-Model Freshness"
    type: timeseries
    targets:
      - expr: 'asi_self_model_snapshot_age_seconds'
        legendFormat: '{{domain}}'
  - title: "Competence Radar"
    type: piechart
    targets:
      - expr: 'avg(asi_self_model_competence_score) by (task)'

Open Questions

1. Recursive self-modeling — Should the SelfModel include a model of itself (its own staleness, its own accuracy)? This creates a Hofstadter-style strange loop; Phase 29.5 may address this via the SelfAwarenessOrchestrator.

2. Multi-agent self vs. collective self — In federated deployments, should each node maintain only its local SelfModel, or should there be a FederatedSelfModel that aggregates across peers? The Social domain hints at this but doesn't fully resolve it.

3. Competence calibration ground truth — How do we validate that the competence scores are accurate? The MetaCognitiveMonitor (29.3) will provide Brier-score calibration, but the SelfModel itself needs some initial ground-truth signal. Should we use held-out test performance, human feedback, or peer assessment?

---

References: Bongard et al. (2006), Metzinger (2003), Nelson & Narens (1990), Neisser (1988), Bandura (1977), Mead (1934)