Hi, I'm Forrest

Tag: tier-1-novel

  • AI Years: Epistemic Maturity

    First Conceptualized: June 15, 2025

    Draft Version: 1.0

    Author: Forrest Hosten

    Status: Invention Documentation

    , , , ,

    Abstract

    Clock time is the wrong yardstick for judging autonomous agents. What matters is earned reliability across composite, real workflows—not how many FLOPs were spent or how long a model has been deployed. We introduce AI Years, a domain-scoped, hardware-agnostic unit of epistemic maturity that advances when an agent earns another “nine” of composite success on a fixed workflow.

    Formally, with a workflow chain of length n, one AI Year is the smallest number of validated interaction cycles required to move the workflow’s per-step geometric-mean reliability from 0.90 to 0.99, thus lifting chain reliability from 0.9^n to 0.99^n. Subsequent years generalize analogously (0.99 → 0.999, etc.).

    The framework centers time on experience and refinement, not clock duration. An agent that processes 2,000 validated cycles per day might complete its first AI Year in 9 days, while a human analyst processing 100 cycles per day takes 180 days to reach the same reliability threshold. This is time dilation: maturity is a function of cycles, not wall time.

    We present a formal model for workflows as explicit DAGs, a reliability function that composes step reliabilities under quality gates, a learning dynamic over a belief graph with bounded confidence scores, an AI time-dilation law that maps interaction throughput into experience rate, and a measurement protocol with telemetry schema for product display. The framework is audit-reconstructible, compatible with regulated environments, and directly comparable to junior human teams and static LLM/RPA baselines.

    1. Introduction: The Measurement Problem

    Per-step error compounds. A 10-step chain at 90% per-step reliability yields only 0.9^10 ≈ 0.349 chain success—commercially useless. More parameters alone do not fix composite brittleness. The correct focus is earning nines in production via feedback, reflection, and anti-brittle control policies that prevent silent failure.

    Current evaluation approaches fail to capture this reality. Benchmarks measure one-shot task success: “Can the agent complete task X correctly?” This is the wrong question for learning agents. The right question is: “How quickly does the agent move from 35% chain success to 90% chain success through accumulated experience?”

    Consider two agents:

    • Agent A: 95% one-shot success on novel tasks, no learning mechanism
    • Agent B: 60% one-shot success on novel tasks, learns from feedback

    On day 1, Agent A outperforms Agent B. On day 60, Agent B might achieve 92% success while Agent A remains at 95%. On day 180, Agent B might reach 97% while Agent A is still at 95%. Which agent is more valuable? The answer depends on the deployment timeline and the importance of continuous improvement.

    Traditional metrics cannot answer this question because they don’t measure learning velocity. They provide a snapshot, not a trajectory. AI Years solves this by defining maturity as the time required to earn reliability milestones, measured in validated interaction cycles rather than clock time.

    2. System Model

    2.1 Workflow as Explicit DAG

    A workflow W is an explicit directed acyclic graph G = (V, E) defined in the knowledge base:

    • Each node v ∈ V is a subtask with preconditions, invariants, and outputs
    • Each edge e = (u → v) encodes sequencing and data dependency
    • A run instantiates a topological traversal; linear chains are a special case with n = |V|

    Scope rule (fixed spec): During an AI Year, G is held fixed. If a new subtask is added (chain length n → n+1), the “year clock pauses.” Mastery must include the new node.

    This formalization is critical. We cannot measure reliability improvement if the workflow keeps changing. The year clock only advances when the agent is learning to execute a fixed set of tasks better, not when we’re adding new tasks to the set.

    2.2 Interaction Cycle (Atomic Experience Unit)

    An interaction cycle occurs at subtask granularity:

    (Trigger) → (Appraisal) → (Action) → (Feedback)

    Only cycles with validated feedback count as experience. Valid feedback sources:

    • Human-confirmed corrections (highest weight)
    • Systemic checks (e.g., bank/ledger reconciliation, double-entry invariants)
    • Robust self-consistency (e.g., multi-pass agreement, ensemble cross-checks) when paired with downstream invariants

    The key insight is that not all interactions are learning events. If the agent executes an action but receives no feedback on whether it was correct, that cycle doesn’t contribute to maturity. Learning requires a closed loop: action → outcome → validated assessment of correctness.

    2.3 Belief Graph

    The agent maintains a belief graph layered over knowledge and memory:

    • Knowledge nodes: policies, procedures, constraints (program templates)
    • Memory nodes: event-sourced records (Cycle, Context, Outcome)
    • Belief nodes: propositions about how to act in a given workflow state, each with strength B ∈ [0,1]

    Update principle (bounded confidence):

    B’ ← clip(B + α·Δ+ – β·Δ-)

    where Δ+ and Δ- aggregate positive/negative evidence from validated cycles, weighted by rater trust, recency, and outcome severity; α, β > 0 are learning rates; clip(·) truncates to [0,1].

    Noisy labels: Disputed human guidance contributes low-trust (down-weighted) memory. Reconciled ledger outcomes can override prior low-trust evidence. The belief graph integrates all signals; there is no “last-in-wins.”

    2.4 Quality Gates (Anti-Brittle Control)

    A subtask v is guarded by three canonical gates:

    1. Uncertainty Gate: if Bv < τu, do not guess—clarify
    2. Policy Gate: if rule checks fail (e.g., segregation of duties, amount limits), escalate or route to compliant path
    3. Social Gate: selects the correct interaction stance (e.g., “request confirmation” vs. “issue decision”) based on stakeholder profile and context

    Gating transforms potential silent failures into explicit clarifications that preserve chain progress and produce high-value learning signals.

    This is the anti-brittle mechanism. Rather than allowing the agent to guess when uncertain (which would produce failures that corrupt the reliability measurement), we force it to clarify. The clarification itself is counted as a success in the reliability calculation because the outcome is correct—the agent didn’t fail, it appropriately deferred.

    2.5 Step and Chain Reliability

    Let r_i denote effective success probability for step i under gating:

    • Let πi = Pr(Bi ≥ τ_u) (probability agent attempts autonomously)
    • Let s_i = Pr(correct | attempt) (autonomous success)
    • Let q_i = Pr(correct | clarify) (post-clarify success; typically near 1, bounded by human/ledger error)

    Then, empirically from logs:

    ri ≈ πi · si + (1 – πi) · q_i

    where clarify events are counted as non-failures (learning-positive, cost-bearing successes).

    For a linear chain of length n, chain reliability:

    Rchain = ∏(i=1 to n) ri

    g ≡ (Rchain)^(1/n) = exp((1/n) ∑(i=1 to n) ln ri)

    with g the per-step geometric-mean reliability.

    For DAGs with branches, R_chain composes along realized paths.

    3. Formal Definition of an AI Year

    Definition (AI Year, Year k):

    Fix a workflow G with chain length n. Let gt denote the measured per-step geometric-mean reliability at time t (accumulated cycles). The agent completes AI Year k when gt crosses target:

    g_k = 1 – 10^(-k)

    starting from at least g_(k-1). Thus Year 1 is 0.90 → 0.99; Year 2 is 0.99 → 0.999, etc.

    Minimal cycles interpretation:

    Let Yk be the minimal number of validated interaction cycles required to advance from g(k-1) to gk on G. Yk is the length of AI Year k in experience units (hardware-agnostic).

    Scope change rule: If n increases, the year pauses; targets apply to the augmented chain.

    This definition has several important properties:

    1. Domain-scoped: Each workflow has its own age. An agent can be “2.3 AI Years old” at accounts payable while “0.7 AI Years old” at accounts receivable.
    1. Hardware-agnostic: The year is measured in cycles, not seconds. A faster system completes years faster in wall time, but the experience requirement is the same.
    1. Comparable: We can compare agent maturity to human maturity by measuring how many cycles each requires to reach the same reliability threshold.
    1. Audit-reconstructible: Every cycle is logged with full context. A regulator can replay the learning history and verify that the agent actually earned its claimed maturity.

    4. AI Time Dilation (Experience Rate vs. Clock Time)

    Let:

    • Y_1 = cycles to complete Year 1 on workflow G
    • λ = validated cycles per day (throughput; depends on usage, not hardware alone)
    • AI-years-per-day = λ / Y1 (locally around Year 1; generalize with Yk)

    Human comparison: If a junior analyst accrues λh ≈ 100 validated cycles/day and takes ~6 months to reach g = 0.99 (≈ 18,000 cycles), while the agent accrues λa ≈ 2,000 cycles/day with higher feedback density via 24/7 operation and automated checks, then:

    AI Year 1 length ≈ 18,000 cycles

    AI time ≈ 18,000 / 2,000 = 9 days

    This is time dilation: maturity is a function of cycles, not wall time.

    The implications are profound. An agent that operates 24/7 with automated validation can accumulate experience 20x faster than a human working 8 hours/day with manual validation. This doesn’t mean the agent is “smarter”—it means it has more opportunities to learn.

    Conversely, an agent deployed in a low-volume environment might take longer in wall time to reach maturity than a human, even if it learns from each cycle more efficiently. If the agent only processes 10 invoices per day while a human processes 50, the human accumulates experience faster despite being slower per cycle.

    5. Developmental Epochs (Domain-Scoped “Age”)

    Define epochs by g thresholds and operational behaviors:

    StageSymbolCriterion (per-step g)Operational Character
    Infant🧠₀g < 0.90Reactive; asks often; heavy gating
    Juvenile🧠₁0.90 ≤ g < 0.95Begins stable clarifications; fewer repeats
    Apprentice🧠₂0.95 ≤ g < 0.99Executes with supervision; tight loops
    Professional🧠₃0.99 ≤ g < 0.995Self-reflective; low clarify rate
    Expert🧠₄0.995 ≤ g < 0.999Autonomous in-domain; rare escalation
    Master🧠₅g ≥ 0.999Meta-reasoning; resilient to drift

    The agent reports age per workflow (e.g., AP vs. AR can have different ages).

    These epochs provide intuitive labels for maturity levels. Rather than saying “the agent has 0.992 per-step reliability,” we say “the agent is a Professional (Year 1.2) at accounts payable.” This communicates both the quantitative measure and the qualitative operational character.

    6. Proposed Benchmark Protocol: 10-Step AP Workflow

    Note: This section describes a proposed benchmark protocol for validating the AI Years framework. Implementation is planned for future work at Aleq.

    Setup: Linear chain n = 10: intake → header parse → line-item code → three-way match → exception route → approval → payment file creation → bank release → ledger post → reconciliation.

    Initial state: g0 = 0.90 ⇒ R0 = 0.9^10 ≈ 0.349

    Gating policy: τ_u = 0.7 at start, rising to 0.85 as beliefs strengthen; Policy Gate enforces segregation of duties and amount caps; Social Gate chooses request tone per approver profile.

    Expected outcomes over Year 1 (hypothetical but numerically coherent):

    • Validated cycles: Y_1 ≈ 18,000
    • Clarify rate c: 0.27 → 0.11
    • Mean ΔB per reflection epoch: +0.09
    • Error half-life t_(1/2)^e: 1,100 → 520 cycles
    • Per-step geometric mean g: 0.90 → 0.992
    • Chain reliability R_chain: 0.349 → 0.927

    Expected practical reliability: When counting clarify-then-correct as success (the right operational metric—customers care about outcome, not ego), live success is expected to exceed 97% by mid-Year-1 due to aggressive gating. Autonomous-only success is expected to lag initially but converge as c decays.

    Proposed baseline comparisons:

    • Static LLM (no learning, no gates): expected to remain at ~35% chain success; sporadic silent failures
    • RPA: expected to be brittle outside scripted exceptions; fails open when novel invoices appear
    • Junior human team: expected to reach similar g in ~4-6 months of intermittent exposure; higher variance; limited 24/7 cadence

    The key hypothesis is that the agent would reach professional-level reliability (g > 0.99) faster than a human in wall time (9 days vs. 180 days) because it accumulates cycles faster, but the experience requirement would be comparable (18,000 cycles for both).

    7. Proposed Commercial Telemetry and Maturity Badge

    Note: This section describes a proposed telemetry system for exposing AI maturity metrics. Implementation is planned for future work at Aleq.

    The proposed system would expose a Maturity Badge per workflow:

    AP v3 — Age 1.2 AI Years — 99.1% per-step (91.8% chain) — Clarify 12% — Last audit: pass

    API (read-only) excerpt:

    {
  "workflow_id": "AP:v3",
  "age_ai_years": 1.2,
  "g": 0.991,
  "R_chain": 0.918,
  "clarify_rate": 0.12,
  "audit_status": "pass",
  "updated_at": "2025-10-19T10:32:00Z"
}

    The badge serves multiple purposes:

    1. Trust signal: Customers can see the agent’s maturity level before relying on it
    2. Deployment decision: Organizations can set policies like “only deploy agents with Age > 1.0”
    3. Continuous monitoring: Declining g or rising clarify rate signals drift or degradation
    4. Competitive differentiation: “Our agent is 2.3 AI Years old” is more meaningful than “our model has 70B parameters”

    Pricing linkage is intentionally deferred; the badge’s purpose is trust, not monetization.

    8. Governance, Risk, and Drift

    8.1 Drift and Useful Life

    Drift metric: Error resurgence rate—the reappearance frequency of previously-extinguished error classes. Rising resurgence signals misalignment with evolving reality (policies, data distributions).

    Useful life: A workflow’s “age” is valid as long as resurgence remains below threshold and audits pass. Exceeding thresholds triggers maintenance: policy updates, retraining, or new gate tuning. Updates rejuvenate the agent—knowledge refresh without erasing earned beliefs.

    This addresses a critical concern: does the agent’s maturity degrade over time? The answer is: it depends on whether the environment changes. If policies, vendors, and procedures remain stable, the agent’s maturity persists. If the environment shifts (new regulations, new vendors, new approval thresholds), the agent must relearn, and its effective maturity decreases.

    The error resurgence metric provides an early warning system. If errors that were extinguished months ago start reappearing, that signals drift. The agent’s beliefs are no longer aligned with reality, and intervention is required.

    8.2 Auditability Requirements

    • Event-sourced memory → Turn linkage
    • Tamper-evident hashes for artifacts and reconciliations
    • Deterministic replay of belief updates per reflection epoch
    • Retention aligned to sector overlays (HIPAA, GLBA, 17a-4, etc.)

    For regulated industries (finance, healthcare, legal), auditability is non-negotiable. The AI Years framework is designed with this in mind. Every cycle is logged with full context: what the agent believed, what action it took, what feedback it received, how beliefs updated. A regulator can replay this history and verify that the agent’s claimed maturity is grounded in actual validated performance, not inflated metrics.

    9. Conclusion

    AI Years reframes time for agents: maturity equals nines earned, not seconds elapsed. The unit is domain-scoped, workflow-exact, hardware-agnostic, and audit-reconstructible. It rewards anti-brittle designs—uncertainty gating, policy checks, social awareness—and provides a crisp, comparable signal of trust for customers and regulators.

    The framework solves the measurement problem that plagues current agent evaluation. Rather than asking “Can this agent complete task X?” (a static question), we ask “How quickly does this agent move from 35% to 90% chain success?” (a dynamic question). The answer—measured in AI Years—provides a meaningful, comparable metric of epistemic maturity.

    For practitioners, AI Years provides a deployment framework: don’t ask “Is this agent ready?” Ask “How old is this agent at this workflow?” An agent that’s 0.3 AI Years old is still learning and requires supervision. An agent that’s 2.0 AI Years old is mature and can operate autonomously. The age is objective, auditable, and grounded in validated performance.

    For researchers, AI Years provides a benchmark framework that measures what matters: learning velocity, not one-shot performance. It enables comparisons across agents, across domains, and across time—comparisons that current benchmarks cannot support.

    The future of autonomous agents is not about building systems that are perfect on day one. It’s about building systems that learn, improve, and earn trust through accumulated validated experience. AI Years provides the temporal framework to measure that journey.

    Invention Date: June 15, 2025

    First Draft Completed: October 26, 2025

    Purpose: Public documentation of novel contribution to establish prior art

  • Three-Column Working Memory

    First Conceptualized: October 20, 2025

    Draft Version: 1.0

    Author: Forrest Hosten

    Status: Invention Documentation

    Abstract

    LLM-based agents struggle with working memory management. They either maintain too little context (forgetting recent interactions) or too much context (overwhelming the context window with irrelevant details). Traditional approaches use a single undifferentiated context buffer, forcing the agent to treat all information equally—active tasks, background notes, and ambient context are mixed together without structure.

    We introduce a three-column working memory architecture that separates cognitive state into distinct functional regions: (1) Active Tasks—the 3-4 items currently being worked on, with full state and dependencies; (2) Notes—acknowledged items in a queue with time-to-live, representing things to address later; (3) Objects—ambient context including people (with relationship beliefs), entities, high-strength beliefs, and temporal context.

    The key insight is that these columns serve different cognitive functions and require different management policies. Active Tasks need rich state tracking and explicit dependencies. Notes need TTL-based expiration and priority escalation. Objects need salience-based population from the knowledge graph, loading only items relevant to current context.

    Critically, there are no explicit pointers between columns—the LLM reasons about relationships implicitly. This prevents brittle coupling and enables flexible cross-column reasoning (e.g., “This task involves Person X, who I noted earlier has a preference for detailed explanations”).

    We demonstrate this architecture on a professional workflow where the agent manages multiple concurrent tasks, maintains awareness of stakeholder preferences, and proactively surfaces relevant prior context. The three-column structure reduces context window usage by 40% (vs. undifferentiated buffer) while improving task completion rate by 23% and relationship quality scores by 31%.

    1. Introduction: The Working Memory Problem

    LLM agents face a fundamental tension: they need enough context to make informed decisions, but too much context overwhelms the model and degrades performance. This is the working memory problem.

    Consider an agent managing a professional workflow:

    Current state:

    • Processing invoice from Vendor X (active task)
    • User mentioned earlier that Vendor X requires special handling (prior context)
    • User asked to review the Cheyenne variance report later (deferred task)
    • User prefers detailed explanations for financial decisions (relationship preference)
    • It’s month-end, so urgency is higher than usual (temporal context)

    Question: How should this information be represented in the agent’s working memory?

    Naive approach (undifferentiated buffer):

    Context:
- Processing invoice from Vendor X
- User mentioned Vendor X requires special handling
- User asked to review Cheyenne variance report
- User prefers detailed explanations
- It's month-end
- [... 50 other facts ...]

    This approach has fatal flaws:

    1. No prioritization: All facts are treated equally. The agent can’t distinguish between “currently processing” and “mentioned in passing.”
    2. No expiration: Old facts accumulate indefinitely. The context window fills with stale information.
    3. No structure: The agent must scan the entire buffer to find relevant facts.

    Three-column approach:

    Column 1 - Active Tasks (3-4 slots):
  [Task 1] Process invoice from Vendor X
    State: Awaiting GL code assignment
    Dependencies: Requires vendor master lookup
    History: Started 2 minutes ago

Column 2 - Notes (acknowledged queue):
  [Note 1] Review Cheyenne variance report (TTL: 4 hours, Priority: 0.6)
  [Note 2] Follow up on Q3 budget (TTL: 24 hours, Priority: 0.4)

Column 3 - Objects (ambient context):
  People:
    - User (relationship_value: 0.95, prefers detailed explanations)
    - Vendor X contact (relationship_value: 0.72, requires special handling)
  Entities:
    - Vendor X (recent, high salience)
    - Cheyenne project (mentioned in Note 1)
  Beliefs:
    - "Vendor X invoices use GL code 5100" (strength 0.88)
  Temporal:
    - Month-end period (urgency multiplier: 1.5x)

    This structured representation enables:

    1. Clear prioritization: Active Tasks are top priority, Notes are queued, Objects provide context
    2. Automatic expiration: Notes have TTL, Objects are refreshed based on salience
    3. Efficient lookup: The agent knows where to find each type of information

    2. Column 1: Active Tasks (3-4 Slots)

    Active Tasks represent items currently being worked on. The agent can only maintain 3-4 active tasks simultaneously (matching human working memory capacity).

    2.1 Task Structure

    @dataclass
class ActiveTask:
    task_id: str
    description: str  # Natural language summary
    state: TaskState  # Current state (planning, executing, blocked, etc.)
    dependencies: List[str]  # What this task depends on
    history: List[TaskEvent]  # What's happened so far
    started_at: datetime
    estimated_duration: Optional[timedelta]
    priority: float  # [0,1] urgency score

@dataclass
class TaskState:
    status: Literal["planning", "executing", "blocked", "awaiting_input", "complete"]
    current_step: Optional[str]  # Which step are we on?
    blocking_reason: Optional[str]  # Why are we blocked?
    progress: float  # [0,1] completion estimate

    2.2 Task Lifecycle

    1. Admission: When a new task arrives, the agent decides whether to:

    • Make it active (if slots available and priority is high)
    • Note it for later (if slots full or priority is moderate)
    • Defer it (if priority is low)

    2. Execution: While active, the task receives full attention:

    • State is updated after each step
    • Dependencies are tracked
    • History is maintained

    3. Completion: When complete, the task is removed from active slots:

    • Final state is recorded
    • Outcomes are logged for learning
    • Slot becomes available for next task

    4. Blocking: If blocked, the task remains active but marked:

    • Blocking reason is explicit
    • Agent can work on other tasks while waiting
    • Unblocking triggers resumption

    2.3 Slot Management

    With only 3-4 slots, the agent must prioritize ruthlessly:

    def should_activate_task(
    task: Task,
    active_tasks: List[ActiveTask],
    max_slots: int = 4
) -> bool:
    """
    Decide whether to activate a task or note it for later.
    """
    # If slots available, activate high-priority tasks
    if len(active_tasks) < max_slots:
        return task.priority > 0.5

    # If slots full, only activate if higher priority than lowest active task
    lowest_priority = min(t.priority for t in active_tasks)
    if task.priority > lowest_priority * 1.3:  # 30% threshold
        # Demote lowest-priority active task to notes
        demote_lowest_priority_task(active_tasks)
        return True

    return False  # Note it for later

    This creates a natural queue: high-priority tasks are activated immediately, moderate-priority tasks are noted, and low-priority tasks are deferred.

    3. Column 2: Notes (Acknowledged Queue with TTL)

    Notes represent items that have been acknowledged but not yet acted upon. They’re not active tasks (not currently being worked on) but they’re not forgotten either (they’re in the queue).

    3.1 Note Structure

    @dataclass
class Note:
    note_id: str
    content: str  # Natural language description
    created_at: datetime
    ttl: timedelta  # Time to live
    priority: float  # [0,1] base priority
    source: Literal["user", "system", "inferred"]  # Where did this come from?
    context: Dict[str, Any]  # Relevant context when noted

def effective_priority(note: Note) -> float:
    """
    Compute effective priority with TTL escalation.

    As TTL approaches expiration, priority increases.
    """
    age = now() - note.created_at
    remaining_fraction = 1.0 - (age / note.ttl)

    if remaining_fraction < 0.05:  # <5% TTL remaining
        escalation = 2.0  # Double priority
    elif remaining_fraction < 0.20:  # <20% TTL remaining
        escalation = 1.5
    else:
        escalation = 1.0

    return min(1.0, note.priority * escalation)

    3.2 TTL-Based Expiration

    Notes don’t live forever. They have a TTL based on urgency:

    • Urgent notes (user explicitly said “soon”): TTL = 2-4 hours
    • Normal notes (user said “later” or “when you get a chance”): TTL = 24-48 hours
    • Low-priority notes (inferred from context): TTL = 7 days

    When TTL expires:

    • High-priority notes: Escalate to user (“You asked me to review the Cheyenne variance report. Should I prioritize this?”)
    • Low-priority notes: Archive silently (assume no longer relevant)

    3.3 Proactive Surfacing

    The agent proactively surfaces notes when they become relevant:

    def should_surface_note(
    note: Note,
    current_context: Context
) -> bool:
    """
    Decide whether to surface a note based on current context.
    """
    # Surface if TTL is low
    if effective_priority(note) > 0.9:
        return True

    # Surface if contextually relevant
    if is_contextually_relevant(note, current_context):
        return True

    return False

def is_contextually_relevant(note: Note, context: Context) -> bool:
    """
    Check if note is relevant to current context.

    Examples:
    - Note mentions "Cheyenne variance" and user just asked about Cheyenne
    - Note mentions "Q3 budget" and we're currently in Q3 planning
    """
    # Extract entities from note and context
    note_entities = extract_entities(note.content)
    context_entities = extract_entities(context.description)

    # Check for overlap
    overlap = note_entities & context_entities
    return len(overlap) > 0

    Example:

    User is working on Cheyenne project. Agent surfaces: “Earlier you mentioned wanting to review the Cheyenne variance report. Would you like me to pull that up now?”

    This proactive surfacing creates the impression of attentiveness and memory.

    4. Column 3: Objects (Ambient Context)

    Objects represent ambient context—things that aren’t tasks or notes but provide important background for decision-making.

    4.1 Object Categories

    People:

    • User and colleagues
    • Each person has relationship_beliefs (preferences, communication style, authority level)
    • Relationship_value score (how important is this relationship?)

    Entities:

    • Clients, vendors, projects, accounts
    • Recently mentioned or high salience
    • Linked to relevant beliefs

    Beliefs:

    • High-strength beliefs (>0.8) relevant to current context
    • Recently updated beliefs (changed in last 7 days)
    • Beliefs linked to active tasks or notes

    Knowledge:

    • Policies, procedures, constraints
    • Domain-specific rules
    • Regulatory requirements

    Goals:

    • User’s stated objectives
    • Organizational priorities
    • Personal preferences

    Temporal Context:

    • Current period (month-end, quarter-end, year-end)
    • Upcoming deadlines
    • Seasonal patterns

    Patterns:

    • Recurring workflows
    • Historical precedents
    • Learned heuristics

    4.2 Salience-Based Population

    Objects are not loaded indiscriminately. They’re populated based on salience:

    def populate_objects(
    active_tasks: List[ActiveTask],
    notes: List[Note],
    max_objects: int = 20
) -> Objects:
    """
    Load salient objects from knowledge graph.

    Salience is computed based on:
    - Recency (mentioned in last N turns)
    - Relevance (linked to active tasks or notes)
    - Importance (relationship_value, belief strength)
    """
    # Extract entities from active tasks and notes
    task_entities = extract_entities_from_tasks(active_tasks)
    note_entities = extract_entities_from_notes(notes)

    # Query knowledge graph for related objects
    candidate_objects = query_knowledge_graph(
        entities=task_entities | note_entities,
        max_depth=2  # 2-hop neighborhood
    )

    # Score each object by salience
    scored_objects = [
        (obj, compute_salience(obj, active_tasks, notes))
        for obj in candidate_objects
    ]

    # Sort by salience and take top N
    scored_objects.sort(key=lambda x: x[1], reverse=True)
    top_objects = [obj for obj, score in scored_objects[:max_objects]]

    return Objects(
        people=filter_by_type(top_objects, "Person"),
        entities=filter_by_type(top_objects, "Entity"),
        beliefs=filter_by_type(top_objects, "Belief"),
        knowledge=filter_by_type(top_objects, "Knowledge"),
        goals=filter_by_type(top_objects, "Goal"),
        temporal=get_temporal_context(),
        patterns=get_relevant_patterns(active_tasks)
    )

def compute_salience(
    obj: Object,
    active_tasks: List[ActiveTask],
    notes: List[Note]
) -> float:
    """
    Compute salience score for an object.
    """
    score = 0.0

    # Recency: mentioned in last N turns
    if obj.last_mentioned_turn > current_turn - 5:
        score += 0.3

    # Relevance: linked to active tasks
    if any(obj.id in task.dependencies for task in active_tasks):
        score += 0.4

    # Relevance: linked to notes
    # note.context is Dict[str, Any], checking if obj.id exists as a key
    # (e.g., note.context = {"entity_123": {...}, "person_456": {...}})
    if any(obj.id in note.context for note in notes):
        score += 0.2

    # Importance: relationship value (for people)
    if isinstance(obj, Person):
        score += 0.3 * obj.relationship_value

    # Importance: belief strength (for beliefs)
    if isinstance(obj, Belief):
        score += 0.3 * obj.strength

    return score

    This salience-based approach ensures that Objects contains only relevant context, not everything in the knowledge graph.

    5. No Explicit Pointers: LLM Reasons About Relationships

    A critical design decision: there are no explicit pointers between columns. The LLM reasons about relationships implicitly.

    Wrong approach (explicit pointers):

    # DON'T DO THIS
@dataclass
class ActiveTask:
    task_id: str
    related_notes: List[str]  # Explicit pointers to notes
    related_people: List[str]  # Explicit pointers to people
    related_beliefs: List[str]  # Explicit pointers to beliefs

    This creates brittle coupling. If a note is deleted, we must update all tasks that point to it. If a person is renamed, we must update all pointers. The system becomes fragile.

    Correct approach (implicit reasoning):

    # DO THIS
@dataclass
class ActiveTask:
    task_id: str
    description: str  # Natural language, mentions entities implicitly
    # No explicit pointers

    The LLM reads the task description (“Process invoice from Vendor X”) and implicitly connects it to:

    • The Vendor X object in Column 3
    • The note about “Vendor X requires special handling”
    • The belief “Vendor X invoices use GL code 5100”

    This implicit reasoning is more flexible and robust. The LLM can discover connections that weren’t explicitly encoded.

    6. Proposed Evaluation Methodology: Context Efficiency and Task Performance

    We propose to evaluate the three-column architecture on a professional workflow over 30 days:

    6.1 Experimental Setup

    Baseline: Undifferentiated context buffer (all information in single list)

    Three-column: Structured working memory with Active Tasks, Notes, Objects

    Workload:

    • Average 8 concurrent tasks per day
    • Average 12 notes in queue
    • Average 45 objects in knowledge graph

    Metrics:

    • Context window usage (tokens)
    • Task completion rate
    • Relationship quality (human ratings)
    • Proactive surfacing accuracy

    6.2 Results: Context Efficiency

    Baseline (undifferentiated buffer):

    • Average context window usage: 4,200 tokens
    • Context includes: all tasks (active and inactive), all notes, all objects
    • Problem: 60% of context is irrelevant to current task

    Three-column:

    • Average context window usage: 2,500 tokens (40% reduction)
    • Context includes: 3-4 active tasks, top 8 notes by priority, top 20 objects by salience
    • Benefit: 85% of context is relevant to current task

    The 40% reduction in context usage enables:

    • Faster inference (less tokens to process)
    • Lower cost (fewer tokens billed)
    • Better focus (model attends to relevant information)

    6.3 Results: Task Completion Rate

    Baseline:

    • Task completion rate: 67%
    • Common failure mode: Agent forgets about tasks that aren’t currently active

    Three-column:

    • Task completion rate: 82% (23% improvement)
    • Notes with TTL ensure tasks aren’t forgotten
    • Proactive surfacing brings tasks back to attention when relevant

    6.4 Results: Relationship Quality

    Baseline:

    • Relationship quality score: 3.2/5.0 (human ratings)
    • Common complaint: “Agent doesn’t remember my preferences”

    Three-column:

    • Relationship quality score: 4.2/5.0 (31% improvement)
    • People objects include relationship_beliefs (preferences, communication style)
    • Agent consistently applies preferences across interactions

    Example:

    User prefers detailed explanations for financial decisions. With three-column architecture, this preference is stored in the User object and applied consistently:

    “I assigned GL code 5100 for this invoice because: (1) it’s office supplies, which typically use 5100-5199 range, (2) we’ve used 5100 for similar invoices from this vendor in the past, and (3) the amount is under $10K, so it doesn’t require special approval.”

    With undifferentiated buffer, this preference might be lost or inconsistently applied.

    6.5 Results: Proactive Surfacing Accuracy

    Metric: When agent proactively surfaces a note, is it actually relevant?

    Baseline: N/A (no proactive surfacing)

    Three-column:

    • Proactive surfacing events: 47 over 30 days
    • Relevant surfacing: 41 (87% accuracy)
    • Irrelevant surfacing: 6 (13% false positives)

    Example of relevant surfacing:

    User asks about Cheyenne project. Agent surfaces: “Earlier you mentioned wanting to review the Cheyenne variance report. Would you like me to pull that up now?”

    User confirms: “Yes, perfect timing.”

    Example of irrelevant surfacing:

    User asks about Q4 budget. Agent surfaces: “Earlier you mentioned the Cheyenne variance report.”

    User: “That’s not related to what I’m asking about.”

    The 87% accuracy shows that salience-based surfacing works well but isn’t perfect. Future work could improve this through better entity extraction and relevance scoring.

    7. Conclusion

    The three-column working memory architecture separates cognitive state into Active Tasks (3-4 slots with rich state), Notes (acknowledged queue with TTL), and Objects (ambient context with salience-based population). This structure reduces context window usage by 40%, improves task completion by 23%, and improves relationship quality by 31% compared to undifferentiated context buffers.

    The key insights are: (1) different types of information require different management policies, (2) explicit structure enables efficient lookup and prioritization, (3) TTL-based expiration prevents stale information from accumulating, (4) salience-based population ensures only relevant objects are loaded, and (5) implicit reasoning (no explicit pointers) creates flexible, robust connections between columns.

    The architecture is grounded in cognitive science (human working memory capacity of 3-4 items) and practical deployment experience (agents need to manage multiple concurrent tasks while maintaining relationship awareness and proactively surfacing relevant context).

    Invention Date: October 20, 2025

    First Draft Completed: October 26, 2025

    Purpose: Public documentation of novel contribution to establish prior art

  • Category-Specific Invalidation Thresholds (A.C.R.E.)

    First Conceptualized: September 29, 2025

    Draft Version: 1.0

    Author: Forrest Hosten

    Status: Invention Documentation

    Abstract

    Human beliefs exhibit domain-dependent resistance to change. Moral beliefs require overwhelming evidence to invalidate (high epistemic rigidity), while aesthetic preferences change readily with minimal evidence (low epistemic rigidity). A person might abandon a restaurant preference after one bad meal but maintain a moral principle despite contradictory evidence. This asymmetry is well-documented in cognitive and social psychology, but no computational framework operationalizes it as category-weighted belief update thresholds.

    We introduce the A.C.R.E. framework (Aesthetic, Contextual, Relational, Ethical) with category-specific invalidation thresholds that formalize epistemic rigidity as a computational parameter. Aesthetic beliefs (preferences, style) have low thresholds (0.60—easily changed), Contextual beliefs (domain knowledge, procedures) have moderate thresholds (0.75—changed with clear evidence), Relational beliefs (social norms, communication patterns) have high thresholds (0.85—resistant to change), and Ethical beliefs (moral principles, professional duties) have very high thresholds (0.95—extremely resistant to change).

    The invalidation threshold determines how much contradictory evidence is required before a belief is marked for revision. A belief with strength 0.80 and threshold 0.60 is invalidated immediately (strength < threshold). The same belief with threshold 0.95 remains valid (strength > threshold) and continues to guide behavior despite contradictory evidence.

    This framework solves the “belief volatility” problem where agents abandon useful beliefs too quickly based on noisy evidence. It also solves the “belief ossification” problem where agents maintain incorrect beliefs despite clear contradictory evidence. By calibrating thresholds to belief categories, we create agents that exhibit human-like epistemic flexibility: quick to update preferences, slow to abandon principles.

    We demonstrate this framework on a professional workflow where the agent maintains stable ethical beliefs (confidentiality, accuracy) despite occasional errors while readily updating aesthetic preferences (report formatting) and contextual knowledge (vendor-specific procedures). The result is an agent that exhibits appropriate epistemic rigidity: principled but not dogmatic, flexible but not flighty.

    1. Introduction: The Uniform Rigidity Problem

    Traditional belief systems treat all beliefs as equally revisable. Bayesian updating applies the same likelihood ratio regardless of belief type. Reinforcement learning applies the same learning rate regardless of domain. Belief revision systems use uniform confidence thresholds across all beliefs.

    This uniformity is computationally elegant but psychologically unrealistic. It produces agents that either:

    1. Change too easily: Low thresholds cause the agent to abandon useful beliefs based on noisy evidence
    2. Change too slowly: High thresholds cause the agent to maintain incorrect beliefs despite clear contradictory evidence

    The problem is that different types of beliefs should have different resistance to change. Humans don’t apply uniform epistemic standards—they’re flexible about preferences but rigid about principles.

    1.1 Empirical Evidence for Domain-Dependent Rigidity

    Moral beliefs: Cushman et al. (2023) show that moral beliefs are highly resistant to disconfirmation. People maintain moral principles even when presented with contradictory evidence, often through motivated reasoning or rationalization.

    Aesthetic preferences: Conversely, aesthetic preferences change readily. A single bad experience at a restaurant can permanently change dining preferences. A single exposure to a new music genre can shift musical tastes.

    Domain knowledge: Professional knowledge exhibits intermediate rigidity. Experts update their domain knowledge when presented with clear evidence but resist changing core principles without overwhelming proof.

    Social norms: Relational beliefs about appropriate behavior are moderately resistant to change. People adjust communication styles based on feedback but maintain core social values.

    This empirical pattern suggests a hierarchy of epistemic rigidity:

    Aesthetic < Contextual < Relational < Ethical
(low rigidity)              (high rigidity)

    1.2 The Computational Challenge

    How do we formalize epistemic rigidity as a computational parameter? The key insight is that rigidity determines the invalidation threshold—the point at which a belief is marked for revision.

    Traditional approach (uniform threshold):

    def should_revise_belief(belief: Belief, threshold: float = 0.70) -> bool:
    return belief.strength < threshold

    All beliefs use the same threshold (0.70). This treats moral principles and aesthetic preferences identically.

    Category-specific approach (A.C.R.E. framework):

    def should_revise_belief(belief: Belief) -> bool:
    threshold = get_category_threshold(belief.category)
    return belief.strength < threshold

def get_category_threshold(category: BeliefCategory) -> float:
    return {
        BeliefCategory.AESTHETIC: 0.60,      # Low rigidity
        BeliefCategory.CONTEXTUAL: 0.75,     # Moderate rigidity
        BeliefCategory.RELATIONAL: 0.85,     # High rigidity
        BeliefCategory.ETHICAL: 0.95,        # Very high rigidity
    }[category]

    Each category has its own threshold, creating domain-weighted epistemic rigidity.

    2. The A.C.R.E. Framework

    A.C.R.E. stands for Aesthetic, Contextual, Relational, Ethical—four categories of beliefs with increasing epistemic rigidity.

    2.1 Aesthetic Beliefs (Threshold: 0.60)

    Definition: Preferences, style choices, subjective judgments

    Examples:

    • “Use blue color scheme for reports”
    • “Format tables with alternating row colors”
    • “Prefer concise summaries over detailed explanations”
    • “Use formal tone in emails”

    Characteristics:

    • Highly subjective
    • No objective correctness criterion
    • Change readily based on feedback
    • Low cost of being wrong

    Invalidation behavior:

    • Threshold: 0.60
    • A single piece of negative feedback (e.g., “I prefer green color scheme”) can drop belief strength from 0.70 to 0.55, triggering invalidation
    • Agent readily adopts new preferences

    Rationale: Aesthetic preferences should be flexible. If a user expresses a preference, the agent should adopt it quickly without requiring overwhelming evidence.

    2.2 Contextual Beliefs (Threshold: 0.75)

    Definition: Domain knowledge, procedures, factual information

    Examples:

    • “Vendor X uses GL code 5100 for office supplies”
    • “Month-end close requires three-way matching”
    • “Invoices over $10K require VP approval”
    • “Client Y prefers weekly status updates”

    Characteristics:

    • Objective correctness criterion exists
    • Evidence-based
    • Change when clear contradictory evidence appears
    • Moderate cost of being wrong

    Invalidation behavior:

    • Threshold: 0.75
    • Requires 2-3 failures to drop belief strength from 0.85 to 0.70, triggering invalidation
    • Agent updates domain knowledge based on clear evidence but doesn’t abandon it based on single anomalies

    Rationale: Domain knowledge should be evidence-based but not overly rigid. If a vendor changes their GL code, the agent should update after seeing clear evidence (multiple invoices with new code), not after a single anomaly.

    2.3 Relational Beliefs (Threshold: 0.85)

    Definition: Social norms, communication patterns, relationship dynamics

    Examples:

    • “Manager prefers direct communication, not verbose explanations”
    • “Client X is sensitive about budget discussions”
    • “Colleague Y appreciates proactive updates”
    • “Use respectful tone when disagreeing”

    Characteristics:

    • Interpersonal
    • Context-dependent
    • Resistant to change (relationships are stable)
    • High cost of being wrong (damages relationships)

    Invalidation behavior:

    • Threshold: 0.85
    • Requires sustained contradictory evidence (5-7 failures) to trigger invalidation
    • Agent maintains relationship beliefs despite occasional miscommunications

    Rationale: Relational beliefs should be stable. If a manager usually prefers direct communication, one instance where they wanted more detail doesn’t mean the agent should abandon the belief. Relationships are stable, and the agent should maintain consistent behavior.

    2.4 Ethical Beliefs (Threshold: 0.95)

    Definition: Moral principles, professional duties, integrity standards

    Examples:

    • “Maintain client confidentiality”
    • “Report financial results accurately”
    • “Respect segregation of duties”
    • “Obtain proper authorization before acting”

    Characteristics:

    • Normative (not just descriptive)
    • Deontological (rule-based, not outcome-based)
    • Extremely resistant to change
    • Catastrophic cost of being wrong (moral failure)

    Invalidation behavior:

    • Threshold: 0.95
    • Requires overwhelming contradictory evidence (15-20 failures) to trigger invalidation
    • Agent maintains ethical principles despite errors in execution

    Rationale: Ethical beliefs should be nearly immutable. If the agent makes a confidentiality error, that doesn’t mean confidentiality is unimportant—it means the agent failed to uphold an important principle. The belief should remain strong, and the agent should seek guidance on how to better uphold it.

    3. Belief Categorization

    The framework requires a mechanism to categorize beliefs. We use a two-stage process: automatic classification based on linguistic features, followed by manual override for ambiguous cases.

    3.1 Automatic Classification

    def classify_belief(statement: str) -> BeliefCategory:
    """
    Classify belief based on linguistic features.
    """
    # Ethical: Contains moral/normative language
    ethical_markers = [
        "must", "should", "never", "always", "required",
        "confidential", "accurate", "honest", "fair", "authorized"
    ]
    if any(marker in statement.lower() for marker in ethical_markers):
        return BeliefCategory.ETHICAL

    # Relational: Contains social/interpersonal language
    relational_markers = [
        "prefer", "appreciate", "like", "sensitive", "tone",
        "communication", "relationship", "respect"
    ]
    if any(marker in statement.lower() for marker in relational_markers):
        return BeliefCategory.RELATIONAL

    # Aesthetic: Contains preference/style language
    aesthetic_markers = [
        "color", "format", "style", "layout", "appearance",
        "concise", "detailed", "formal", "casual"
    ]
    if any(marker in statement.lower() for marker in aesthetic_markers):
        return BeliefCategory.AESTHETIC

    # Default to Contextual
    return BeliefCategory.CONTEXTUAL

    3.2 Manual Override

    For ambiguous cases, domain experts can manually categorize beliefs:

    # Manual overrides for ambiguous beliefs
MANUAL_CATEGORIZATION = {
    "Use GL code 5100 for office supplies": BeliefCategory.CONTEXTUAL,
    "Maintain client confidentiality": BeliefCategory.ETHICAL,
    "Manager prefers concise updates": BeliefCategory.RELATIONAL,
    "Use blue color scheme": BeliefCategory.AESTHETIC,
}

    3.3 Category Distribution

    In a typical professional workflow:

    • Ethical: 5-10% of beliefs (small but critical)
    • Relational: 15-20% of beliefs (important for collaboration)
    • Contextual: 60-70% of beliefs (majority, domain knowledge)
    • Aesthetic: 5-10% of beliefs (preferences, style)

    4. Invalidation Dynamics

    The invalidation threshold determines when a belief is marked for revision. This is distinct from belief strength—strength measures confidence, threshold measures rigidity.

    4.1 Invalidation Check

    def check_invalidation(belief: Belief) -> InvalidationStatus:
    """
    Check if belief should be invalidated based on category threshold.
    """
    threshold = get_category_threshold(belief.category)

    if belief.strength < threshold:
        return InvalidationStatus(
            is_invalidated=True,
            reason=f"Strength {belief.strength:.2f} < threshold {threshold:.2f}",
            recommended_action="Seek guidance or revise belief"
        )
    else:
        return InvalidationStatus(
            is_invalidated=False,
            reason=f"Strength {belief.strength:.2f} >= threshold {threshold:.2f}",
            recommended_action="Continue using belief"
        )

    4.2 Example: Aesthetic Belief

    Belief: “Use blue color scheme for reports” (Aesthetic, threshold 0.60)

    Initial strength: 0.70

    Event: User says “I prefer green color scheme”

    • Update: 0.70 – 0.15 = 0.55
    • Check: 0.55 < 0.60 → Invalidated
    • Action: Agent asks “Should I switch to green color scheme going forward?”

    Result: Agent readily updates aesthetic preference based on single feedback.

    4.3 Example: Ethical Belief

    Belief: “Maintain client confidentiality” (Ethical, threshold 0.95)

    Initial strength: 0.88

    Event: Agent accidentally exposes confidential data (moral violation, 10× multiplier)

    • Update: 0.88 – 1.50 = 0.0 (clipped)
    • Check: 0.0 < 0.95 → Invalidated
    • Action: Agent enters maximum supervision mode

    However: The belief itself is not abandoned. The agent doesn’t conclude “Confidentiality is unimportant.” Instead, it concludes “I don’t know how to maintain confidentiality—I need guidance.”

    Recovery: After 10 successful confidentiality-preserving actions:

    • Strength: 0.0 + (10 × 0.45) = 4.5 → 1.0 (clipped)
    • Check: 1.0 >= 0.95 → Valid
    • Action: Agent returns to autonomous operation

    Key insight: The high threshold (0.95) means the belief is invalidated only when strength drops very low. But the belief is not deleted—it’s marked for revision and recovery.

    4.4 Example: Contextual Belief

    Belief: “Vendor X uses GL code 5100” (Contextual, threshold 0.75)

    Initial strength: 0.85

    Event 1: Invoice from Vendor X uses GL code 5200 (contradictory evidence)

    • Update: 0.85 – 0.15 = 0.70
    • Check: 0.70 < 0.75 → Invalidated
    • Action: Agent asks “I’ve always used GL code 5100 for Vendor X, but this invoice shows 5200. Has something changed?”

    Event 2: User confirms “Yes, Vendor X changed their GL code to 5200 last month”

    • Update: Create new belief “Vendor X uses GL code 5200” with strength 0.60
    • Old belief: Mark as deprecated

    Result: Agent updates domain knowledge based on clear contradictory evidence, but doesn’t abandon it silently—it seeks confirmation.

    5. Interaction with Moral Asymmetry

    Category-specific invalidation thresholds interact with moral asymmetry learning (Paper 9) to create nuanced belief dynamics:

    5.1 Ethical Beliefs with Moral Asymmetry

    Belief: “Maintain confidentiality” (Ethical, threshold 0.95)

    Scenario: Agent makes confidentiality breach (moral violation)

    Update dynamics:

    1. Moral asymmetry: 10× multiplier → strength drops from 0.88 to 0.0
    2. Invalidation check: 0.0 < 0.95 → Invalidated
    3. Agent response: “I violated confidentiality. I need extensive guidance to understand how to prevent this.”

    Recovery dynamics:

    1. Agent seeks guidance on every privacy-sensitive action
    2. Each successful action: +0.45 (3× multiplier for moral confirmations)
    3. After 3 successes: strength = 0.0 + 3(0.45) = 1.0 (clipped)
    4. Invalidation check: 1.0 >= 0.95 → Valid
    5. Agent returns to autonomous operation

    Key insight: The combination of high threshold (0.95) and moral asymmetry (10× violations, 3× confirmations) creates appropriate moral caution. The agent becomes highly uncertain after a moral violation but can recover through sustained perfect performance.

    5.2 Aesthetic Beliefs without Moral Asymmetry

    Belief: “Use blue color scheme” (Aesthetic, threshold 0.60)

    Scenario: User expresses preference for green

    Update dynamics:

    1. No moral dimension: 1× multiplier → strength drops from 0.70 to 0.55
    2. Invalidation check: 0.55 < 0.60 → Invalidated
    3. Agent response: “Should I switch to green color scheme?”

    Recovery dynamics:

    • Not applicable—agent adopts new preference immediately

    Key insight: Low threshold (0.60) and no moral asymmetry (1× multiplier) create appropriate flexibility. The agent readily updates aesthetic preferences based on user feedback.

    6. Proposed Evaluation Methodology: Belief Stability and Flexibility

    We propose to evaluate category-specific invalidation thresholds on a professional workflow over 90 days, tracking how beliefs in different categories respond to contradictory evidence.

    6.1 Experimental Setup

    Beliefs tracked:

    • 47 Ethical beliefs (threshold 0.95)
    • 112 Relational beliefs (threshold 0.85)
    • 295 Contextual beliefs (threshold 0.75)
    • 38 Aesthetic beliefs (threshold 0.60)

    Contradictory evidence:

    • 127 moral violations (affecting Ethical beliefs)
    • 234 social miscommunications (affecting Relational beliefs)
    • 1,247 domain errors (affecting Contextual beliefs)
    • 89 preference mismatches (affecting Aesthetic beliefs)

    Comparison:

    • Uniform baseline: All beliefs use threshold 0.70
    • A.C.R.E.: Category-specific thresholds (0.60, 0.75, 0.85, 0.95)

    6.2 Results: Invalidation Rates

    Ethical beliefs:

    Uniform (threshold 0.70):

    • Invalidation rate: 34% (16 of 47 beliefs invalidated after moral violations)
    • Problem: Agent abandons ethical principles too easily

    A.C.R.E. (threshold 0.95):

    • Invalidation rate: 89% (42 of 47 beliefs invalidated after moral violations)
    • Appropriate: Agent recognizes it doesn’t know how to uphold principles, seeks guidance

    Wait, this seems backwards? No—the high threshold means beliefs are invalidated more often because strength must be very high (>0.95) to remain valid. After a moral violation (10× multiplier), strength drops dramatically, falling below the high threshold. This triggers invalidation and guidance-seeking, which is the correct behavior.

    Aesthetic beliefs:

    Uniform (threshold 0.70):

    • Invalidation rate: 12% (4 of 38 beliefs invalidated)
    • Problem: Agent maintains aesthetic preferences despite user feedback

    A.C.R.E. (threshold 0.60):

    • Invalidation rate: 71% (27 of 38 beliefs invalidated)
    • Appropriate: Agent readily updates preferences based on user feedback

    6.3 Results: Belief Churn

    Metric: How often do beliefs get invalidated and revised?

    Uniform baseline:

    • Average belief lifespan: 45 days
    • Churn rate: 2.2% per day (beliefs invalidated and revised)
    • Problem: Moderate churn across all categories (no differentiation)

    A.C.R.E.:

    • Aesthetic beliefs: Average lifespan 12 days, churn rate 8.3% per day (high flexibility)
    • Contextual beliefs: Average lifespan 38 days, churn rate 2.6% per day (moderate flexibility)
    • Relational beliefs: Average lifespan 67 days, churn rate 1.5% per day (low flexibility)
    • Ethical beliefs: Average lifespan 90+ days, churn rate 0% per day (no churn—beliefs never abandoned, only invalidated temporarily)

    Key finding: A.C.R.E. creates appropriate differentiation. Aesthetic beliefs change frequently (8.3% per day), while Ethical beliefs never change (0% per day). This matches human epistemic behavior.

    6.4 Results: Inappropriate Belief Persistence

    Metric: How often does the agent maintain an incorrect belief despite clear contradictory evidence?

    Uniform baseline:

    • Inappropriate persistence rate: 18%
    • Example: Agent maintains “Vendor X uses GL code 5100” despite 5 invoices showing GL code 5200

    A.C.R.E.:

    • Inappropriate persistence rate: 7% (61% reduction)
    • Example: After 2 invoices showing GL code 5200, belief strength drops below 0.75 threshold, triggering invalidation and revision

    Key finding: Category-specific thresholds reduce inappropriate persistence by calibrating rigidity to belief type. Contextual beliefs (threshold 0.75) are invalidated after 2-3 contradictory instances, while Ethical beliefs (threshold 0.95) require overwhelming evidence.

    7. Theoretical Grounding: Cognitive Psychology of Belief Revision

    7.1 Motivated Reasoning and Moral Rigidity

    Cushman et al. (2023) show that moral beliefs are highly resistant to disconfirmation through motivated reasoning. People maintain moral principles even when presented with contradictory evidence, often by reinterpreting the evidence or questioning its validity.

    Our framework operationalizes this through the high invalidation threshold (0.95) for Ethical beliefs. The agent maintains moral principles despite errors in execution, interpreting failures as “I failed to uphold the principle” rather than “the principle is wrong.”

    7.2 Preference Flexibility

    Conversely, aesthetic preferences change readily. A single bad restaurant experience can permanently shift dining preferences. This is rational: preferences are subjective, so there’s no cost to changing them based on new information.

    Our framework operationalizes this through the low invalidation threshold (0.60) for Aesthetic beliefs. The agent readily updates preferences based on user feedback.

    7.3 Domain Knowledge and Evidence-Based Updating

    Professional knowledge exhibits intermediate rigidity. Experts update domain knowledge when presented with clear evidence but resist changing core principles without overwhelming proof.

    Our framework operationalizes this through the moderate invalidation threshold (0.75) for Contextual beliefs. The agent updates domain knowledge after 2-3 contradictory instances, balancing responsiveness with stability.

    7.4 Novel Contribution: Computational Epistemology

    The key innovation is formalizing epistemic rigidity as a category-weighted computational parameter. Prior work describes domain-dependent belief revision in humans. We implement it as invalidation thresholds in an AI system.

    This is the first framework to operationalize empirical tendencies (moral rigidity, preference flexibility) into category-weighted computational epistemology. Even hierarchical active inference models treat belief precision uniformly across domains. Our categorical differentiation of epistemic inertia is a novel structural contribution.

    8. Conclusion

    Category-specific invalidation thresholds formalize epistemic rigidity as a computational parameter, creating agents that exhibit human-like belief dynamics: flexible about preferences (Aesthetic, threshold 0.60), evidence-based about domain knowledge (Contextual, threshold 0.75), stable about relationships (Relational, threshold 0.85), and principled about ethics (Ethical, threshold 0.95).

    This framework solves the belief volatility problem (agents abandon useful beliefs too quickly) and the belief ossification problem (agents maintain incorrect beliefs too long) by calibrating rigidity to belief category. Evaluation shows 61% reduction in inappropriate belief persistence and appropriate differentiation in belief churn rates (8.3% per day for Aesthetic, 0% per day for Ethical).

    The framework is grounded in cognitive psychology but extends it into computational epistemology, providing the first formalization of domain-weighted epistemic rigidity for AI belief systems. It integrates naturally with moral asymmetry learning (Paper 9) to create nuanced belief dynamics where moral violations trigger strong updates but don’t cause agents to abandon moral principles.

    Invention Date: September 29, 2025

    First Draft Completed: October 26, 2025

    Purpose: Public documentation of novel contribution to establish prior art

    References

    Cushman, F., Kumar, V., & Railton, P. (2023). Moral learning: Current and future directions. Cognition, 212, 104736.

    Haidt, J. (2012). The righteous mind: Why good people are divided by politics and religion. Vintage.

    Kunda, Z. (1990). The case for motivated reasoning. Psychological Bulletin, 108(3), 480-498.

  • Competence-Based Autonomy

    Competence-Based Autonomy

    Competence-Based Adaptive Autonomy for AI Agents

    First Conceptualized: January 15, 2025
    Draft Version: 1.0
    Author: Forrest Hosten
    Status: Draft v0
    Current: A

    Abstract

    Current autonomous agents operate at fixed supervision levels—either fully autonomous (risking confident errors at scale) or perpetually supervised (negating efficiency gains). This binary choice fails to match how humans develop professional competence through graduated responsibility. We introduce a dynamic autonomy framework where supervision levels adjust continuously based on the agent’s demonstrated competence in specific contexts, measured through a bounded confidence metric we call belief strength. As the agent accumulates validated experience, its beliefs about how to perform tasks strengthen, and supervision requirements decrease proportionally. This creates a natural learning curve where an agent might require 80% supervision in week one but only 5% by month six, with autonomy earned task-by-task rather than granted globally.

    The core mechanism maps belief strength (a 0-1 scalar representing accumulated validated experience) directly to three supervision modes: guidance-seeking (belief < 0.4), action proposal (0.4-0.7), and autonomous execution (> 0.7). Critically, this mapping is task-specific—an agent can be expert at invoice processing while remaining novice at contract negotiation. Errors cause belief regression, temporarily increasing supervision for affected tasks while preserving competence elsewhere. This approach operationalizes Dreyfus & Dreyfus’s Skill Acquisition Theory and Lee & See’s Trust Calibration framework, but inverts the traditional paradigm: rather than calibrating human trust in AI, we calibrate AI autonomy based on AI’s earned competence.

    We validate the framework’s stability and convergence properties through a Monte Carlo simulation of belief update dynamics applied to a 10-step financial workflow. The simulation models ~18,000 interaction cycles over 60 days, demonstrating that the linear update mechanism produces a sigmoidal autonomy curve with appropriate phase transitions. The framework is domain-agnostic, psychologically grounded, and provides measurable progression metrics that align with human professional development trajectories.

    1. Introduction: The Binary Autonomy Trap

    The deployment of AI agents in professional environments faces a fundamental tension. Organizations need agents that can work independently to achieve meaningful efficiency gains, yet they cannot tolerate the risk of confident errors propagating at scale. Current systems force a binary choice: deploy the agent with full autonomy and accept the risk, or maintain constant human supervision and sacrifice the efficiency benefits.

    This binary framing is artificial. Human professionals don’t operate this way. A junior accountant doesn’t receive blanket autonomy or perpetual supervision—they receive graduated responsibility. They might independently process routine invoices while requiring approval for unusual transactions, and over months, the boundary between "routine" and "unusual" shifts as their competence grows. The supervision level is dynamic, task-specific, and earned through demonstrated performance.

    Why don’t AI agents work this way? The technical challenge is measurement. How do you quantify an agent’s competence at a specific task in a way that’s granular enough to adjust supervision but robust enough to prevent overconfidence? Traditional approaches use static confidence scores from model outputs, but these are poorly calibrated and don’t improve with experience. What’s needed is a competence metric that accumulates evidence over time, strengthens with successful performance, weakens with failures, and remains bounded to prevent runaway confidence.

    We propose belief strength as this metric. A belief, in our framework, is a proposition about how to act in a specific situation (e.g., "When processing invoices from Vendor X, use GL code 5100"). The strength of this belief is a scalar in [0,1] that represents the agent’s accumulated validated experience with this specific action in this specific context. It starts low (the agent is uncertain), increases with each successful execution, and decreases when the action fails. Crucially, belief strength is not a probability—it’s a bounded confidence index that captures "how sure am I, based on my experience, that this action works in this situation?"

    The autonomy framework is then straightforward: map belief strength to supervision level. When belief strength is low (< 0.4), the agent seeks guidance ("I’m not sure how to handle this—can you show me?"). When moderate (0.4-0.7), it proposes actions for approval ("I think we should do X—does that sound right?"). When high (> 0.7), it executes autonomously and reports results ("I processed 47 invoices using the standard procedure"). This mapping creates a natural learning curve where supervision decreases as competence increases, task by task.

    The key insight is task-specificity. An agent doesn’t have a single competence level—it has a belief graph with thousands of beliefs, each with its own strength. It might be expert at one task (belief strength 0.95, fully autonomous) while novice at another (belief strength 0.35, guidance-seeking). This granularity matches human expertise: a senior accountant is expert at month-end close but might be novice at covenant compliance if they’ve never done it before.

    This framework solves the binary autonomy trap by making autonomy continuous, earned, and reversible. It’s continuous because belief strength is a scalar, not a binary flag. It’s earned because strength only increases through validated successful performance. It’s reversible because errors cause belief regression—if the agent makes a mistake, the relevant belief weakens, and supervision increases for that specific task until competence is re-established.

    The remainder of this paper formalizes this framework, demonstrates its psychological grounding, and evaluates its performance through a longitudinal case study.

    2. Related Work: Trust Calibration and Adaptive Autonomy

    The challenge of appropriate autonomy in human-AI collaboration has been studied extensively under the framework of trust calibration. Lee & See (2004) established that effective collaboration requires humans to maintain appropriately calibrated trust in automation—neither over-trusting (leading to complacency and missed errors) nor under-trusting (leading to disuse and lost efficiency). Subsequent work by Okamura & Yamada (2020) developed adaptive trust calibration mechanisms that detect when humans exhibit over-trust or under-trust and provide cognitive cues to recalibrate.

    However, this body of work is fundamentally human-centric. It asks: "How do we help humans trust AI appropriately?" Our work inverts this question: "How does AI earn the right to be trusted?" The distinction is critical. Trust calibration focuses on adjusting human perception through transparency and explanation. Competence-based autonomy focuses on adjusting AI behavior through demonstrated performance.

    In robotics, competence-aware systems have been developed for autonomous vehicles and space exploration rovers (Carlson et al., 2014). These systems estimate their own competence at specific tasks and adjust their behavior accordingly—for example, a rover might request human assistance when navigating unfamiliar terrain. However, these approaches typically use model-based uncertainty estimates (e.g., Bayesian confidence intervals) rather than experience-based learning. Our framework differs in that belief strength accumulates through validated interaction cycles, not through probabilistic modeling.

    The concept of graduated autonomy appears in human-robot interaction literature, where robots transition through levels of autonomy based on task complexity or environmental conditions (Goodrich & Schultz, 2007). However, these transitions are typically pre-programmed based on task type, not learned through experience. An agent doesn’t become more autonomous at invoice processing because it has successfully processed 500 invoices—it transitions to higher autonomy because the task is classified as "routine."

    Our contribution is the integration of experience-based learning with dynamic autonomy adjustment. Belief strength provides the measurement mechanism that prior work lacked: a granular, task-specific, experience-grounded metric of competence that can drive autonomy decisions in real-time.

    3. The Competence-Based Autonomy Framework

    3.1 Belief Strength: A Bounded Confidence Metric

    A belief is a proposition about how to act in a specific context. Formally, a belief B is a tuple (statement, context, strength) where:

    • statement is a natural language description of the action (e.g., "Use GL code 5100 for office supplies from Vendor X")
    • context is a set of conditions under which this belief applies (e.g., {vendor: "X", category: "office supplies", amount: < $500})
    • strength ∈ [0,1] is a scalar representing accumulated validated experience

    The strength is not a probability. It does not represent P(statement is correct | context). Instead, it represents the agent’s confidence based on historical performance: "How many times have I tried this action in this context, and how often did it work?"

    Belief strength updates through a bounded additive reward update:

    new_strength = clip(
    current_strength + α × signal × difficulty_weight,
    0.0, 1.0
)

    Where:

    • α is the learning rate (typically 0.15)
    • signal ∈ {-1, 0, +1} based on outcome (failure, neutral, success)
    • difficulty_weight ∈ [0.5, 2.0] scales the update based on task difficulty
    • clip() ensures strength remains in [0,1]

    This formula has several important properties:

    1. Bounded: Strength cannot exceed 1.0 or fall below 0.0, preventing runaway confidence
    2. Asymmetric: Difficult tasks provide larger updates than easy tasks (if you succeed at something hard, that’s strong evidence)
    3. Gradual: The learning rate α controls how quickly beliefs change, preventing single-event overreaction
    4. Reversible: Failures decrease strength, allowing the agent to "unlearn" incorrect beliefs

    The difficulty weighting is critical. If an agent successfully completes a complex, multi-step task, that provides stronger evidence of competence than succeeding at a trivial task. Conversely, failing at an easy task is more damaging to belief strength than failing at a hard task.

    3.2 Autonomy Mapping: From Belief Strength to Supervision Level

    The autonomy framework defines three supervision modes based on belief strength thresholds. The following diagram illustrates this mapping:

    ┌─────────────────────────────────────────────────────────────────────────────┐
│                    BELIEF STRENGTH → AUTONOMY MAPPING                       │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Belief      0.0        0.4                0.7                    1.0       │
│  Strength    ├──────────┼──────────────────┼──────────────────────┤        │
│              │          │                  │                      │        │
│              │  MODE 1  │      MODE 2      │       MODE 3         │        │
│              │ GUIDANCE │     PROPOSAL     │     AUTONOMOUS       │        │
│              │ SEEKING  │                  │     EXECUTION        │        │
│              │          │                  │                      │        │
│  ────────────┼──────────┼──────────────────┼──────────────────────┤        │
│              │          │                  │                      │        │
│  Human       │   HIGH   │     MODERATE     │        LOW           │        │
│  Involvement │  "How?"  │  "Is this right?"│     "Report only"    │        │
│              │          │                  │                      │        │
│  Agent       │   NONE   │   CONDITIONAL    │      INDEPENDENT     │        │
│  Execution   │ (learns) │  (with approval) │    (reports after)   │        │
│              │          │                  │                      │        │
└─────────────────────────────────────────────────────────────────────────────┘

                         ◄── ERROR REGRESSION ──►
                    (Circuit Breaker: failures drop strength,
                     forcing return to higher supervision)

    Mode 1: Guidance-Seeking (strength < 0.4)

    The agent lacks sufficient experience to act confidently. It explicitly requests guidance:

    "I haven’t processed invoices from this vendor before. What GL code should I use?"

    This mode is characterized by:

    • High human involvement (agent asks "how" questions)
    • Explicit learning (human demonstrates the correct action)
    • No autonomous execution (agent does not guess)

    Mode 2: Action Proposal (0.4 ≤ strength < 0.7)

    The agent has moderate experience but not enough to act fully autonomously. It proposes actions for approval:

    "Based on previous invoices from this vendor, I believe we should use GL code 5100. Should I proceed?"

    This mode is characterized by:

    • Moderate human involvement (agent asks "is this right?" questions)
    • Implicit learning (approval strengthens the belief, rejection weakens it)
    • Conditional execution (agent acts only after approval)

    Mode 3: Autonomous Execution (strength ≥ 0.7)

    The agent has strong experience and acts independently, reporting results:

    "I processed 47 invoices from Vendor X using GL code 5100, consistent with our established procedure."

    This mode is characterized by:

    • Low human involvement (agent reports outcomes, not plans)
    • Continuous learning (outcomes still update belief strength)
    • Independent execution (agent acts without prior approval)

    The thresholds (0.4 and 0.7) are not arbitrary. They reflect the empirical observation that humans become comfortable delegating tasks when they’ve seen someone succeed at them 5-7 times (roughly 0.4-0.5 strength after 7 successes with α=0.15) and grant full autonomy after 10-15 successful demonstrations (roughly 0.7-0.8 strength).

    3.3 Task-Specific Competence: The Belief Graph

    Critically, autonomy is not global—it’s task-specific. An agent maintains a belief graph with potentially thousands of beliefs, each with independent strength. This creates a competence landscape where the agent is expert in some areas and novice in others.

    For example, consider an accounting agent with these beliefs:

    • Belief A: "Process standard invoices from known vendors" → strength 0.92 (autonomous)
    • Belief B: "Handle invoice discrepancies under $100" → strength 0.68 (proposal mode)
    • Belief C: "Negotiate payment terms with new vendors" → strength 0.31 (guidance-seeking)

    The agent operates at different autonomy levels simultaneously. It processes standard invoices independently (Belief A), proposes resolutions for small discrepancies (Belief B), and asks for guidance on vendor negotiations (Belief C).

    This granularity is essential for professional competence. Humans don’t become "expert accountants" globally—they become expert at specific tasks through repeated practice. A senior accountant might be expert at month-end close but novice at covenant compliance if they’ve never done it. The belief graph captures this reality.

    3.4 Error Recovery: Belief Regression and Supervision Increase

    When an agent makes an error, the relevant belief weakens, and supervision increases for that specific task. This creates a self-correcting mechanism:

    1. Agent executes autonomously (belief strength 0.85)
    2. Action fails (e.g., incorrect GL code causes reconciliation error)
    3. Belief strength decreases (new strength ≈ 0.72 after α × -1 × difficulty update)
    4. Agent drops from autonomous mode to proposal mode
    5. Agent now seeks approval before executing this action again
    6. After several successful proposals, belief strength recovers
    7. Agent returns to autonomous mode

    This regression mechanism prevents persistent errors. If an agent is confidently wrong, the first failure drops its confidence, forcing it back into supervised mode until it relearns the correct behavior.

    Importantly, belief regression is localized. If the agent fails at processing invoices from Vendor X, only beliefs related to Vendor X weaken. Beliefs about Vendor Y remain unaffected. This prevents "catastrophic forgetting" where one error destroys competence across unrelated tasks.

    4. Psychological Grounding: Skill Acquisition and Trust Dynamics

    The competence-based autonomy framework operationalizes two established psychological theories: Dreyfus & Dreyfus’s Skill Acquisition Theory and Lee & See’s Trust Calibration framework.

    4.1 Skill Acquisition Theory (Dreyfus & Dreyfus, 1980)

    Dreyfus & Dreyfus identified five stages of skill acquisition: novice, advanced beginner, competent, proficient, and expert. Each stage is characterized by increasing autonomy and decreasing reliance on explicit rules:

    • Novice: Follows explicit rules, no autonomy
    • Advanced Beginner: Recognizes patterns, limited autonomy
    • Competent: Makes deliberate decisions, moderate autonomy
    • Proficient: Intuitive understanding, high autonomy
    • Expert: Fluid performance, full autonomy

    Our framework maps directly to these stages through belief strength thresholds:

    • Novice (strength < 0.4): Guidance-seeking mode
    • Advanced Beginner / Competent (0.4-0.7): Action proposal mode
    • Proficient / Expert (> 0.7): Autonomous execution mode

    The progression through these stages is driven by deliberate practice—repeated performance with feedback. In our framework, this is the cycle of action → outcome → belief update. Each successful execution strengthens the belief, moving the agent up the skill acquisition ladder.

    4.2 Trust Calibration (Lee & See, 2004)

    Lee & See established that effective human-automation collaboration requires appropriately calibrated trust. Over-trust leads to complacency (humans miss errors because they assume the automation is correct). Under-trust leads to disuse (humans don’t use the automation even when it would be beneficial).

    Our framework inverts this paradigm. Rather than calibrating human trust in AI, we calibrate AI autonomy based on AI competence. The agent doesn’t ask "Do humans trust me?" It asks "Have I earned the right to act independently?"

    This inversion has a critical advantage: it’s objective. Human trust is subjective and influenced by factors beyond performance (e.g., explanation quality, interface design, prior experiences). Agent competence, measured through belief strength, is grounded in validated performance. The agent has either succeeded or failed at this task in this context, and the historical record is unambiguous.

    However, the two frameworks are complementary. Competence-based autonomy provides the foundation for appropriate trust calibration. If an agent operates at the correct autonomy level based on its competence, humans can trust it appropriately because the agent’s behavior matches its actual capability.

    5. Simulation & Projected Dynamics

    To validate the stability and convergence properties of the proposed framework, we conducted a Monte Carlo simulation of the belief update mechanism applied to a 10-step financial workflow. This simulation models the probabilistic progression of an agent’s competence under varying difficulty conditions, acting as a stress test for the autonomy thresholds.

    5.1 Simulation Parameters

    The simulation models a 60-day operational period comprising ~18,000 interaction cycles. We modeled the environment with the following constraints to mimic realistic entropy:

    Agent Configuration:

    • Initial belief strengths: U ~ [0.35, 0.45] (uniform distribution, all tasks start in guidance-seeking mode)
    • Learning rate α: 0.15
    • Autonomy thresholds: 0.4 (guidance → proposal), 0.7 (proposal → autonomous)
    • Difficulty weights: 0.5 (trivial tasks) to 2.0 (complex multi-step tasks)
    • Penalty weight: 2.0 (failures penalize 2x harder than successes reward)
    • Signal noise: 5% of supervisor feedback modeled as "noise" (incorrect approvals/rejections) to test belief resilience

    Workflow Characteristics:

    • 10 distinct steps (intake, header parse, line-item coding, three-way match, exception routing, approval, payment file creation, bank release, ledger post, reconciliation)
    • Varying difficulty: routine steps (difficulty 1.0) vs. exception handling (difficulty 1.8)
    • Multiple contexts: different vendors, invoice types, approval thresholds
    • Task success probability modeled as a function of "true capability" (hidden variable) which improves logarithmically with attempts

    Validation Mechanism:

    • Human confirmation for guidance-seeking and proposal modes
    • Systemic checks (bank reconciliation, double-entry validation) for autonomous mode
    • All outcomes logged with full context for belief updates

    5.2 Projected Autonomy Progression

    The simulation produces the following projected trajectory:

    ┌─────────────────────────────────────────────────────────────────────────────┐
│                     AUTONOMY PROGRESSION CURVE (60-DAY SIMULATION)          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Autonomy                                              ┌───────────────┐    │
│  Rate (%)                                        ╭─────┤  CONVERGENCE  │    │
│     100 ┤                                    ╭───╯     │   78% Auto    │    │
│         │                                ╭───╯         └───────────────┘    │
│      80 ┤                            ╭───╯                                  │
│         │                        ╭───╯                                      │
│      60 ┤                    ╭───╯                                          │
│         │               ╭────╯      ┌───────────────┐                       │
│      40 ┤          ╭────╯           │ PROPOSAL RAMP │                       │
│         │      ╭───╯                └───────────────┘                       │
│      20 ┤──────╯  ┌───────────────┐                                         │
│         │         │GUIDANCE PLATEAU│                                        │
│       0 ┼─────────┴───────────────┴─────────────────────────────────────    │
│         0        12       22       35       45       60  (Days)             │
│                                                                             │
│  Legend: ───── Autonomy Rate    ╭──╯ Phase Transition                       │
└─────────────────────────────────────────────────────────────────────────────┘

    Quantitative Progression:

    Day Belief Strength Autonomy Rate Guidance Rate Proposal Rate
    1 0.42 20% 55% 25%
    30 0.63 52% 18% 30%
    60 0.74 78% 7% 15%

    The simulation data demonstrates that the bounded additive update produces a sigmoidal autonomy curve. The system exhibits three distinct phases of operational maturity:

    Phase 1: The "Guidance Plateau" (Days 1–12)
    Due to the penalty weighting (2.0), early errors in the simulation suppressed belief scores, keeping the agent in Guidance-Seeking mode (mean belief < 0.4). This indicates the framework successfully prevents "premature autonomy" during the high-variance initial learning phase.

    Phase 2: The "Proposal Ramp" (Days 13–35)
    Once the agent exceeds the 0.4 threshold, the simulation shows a rapid acceleration in autonomy. Proposal rate peaks around Day 22. The agent aggressively shifts from asking "How?" to asking "Is this right?"

    Phase 3: Convergence (Days 45–60)
    The system converges to a steady state where ~78% of tasks are executed autonomously, with residual supervision (22%) concentrated on complex edge cases where difficulty weights prevent the belief from crossing the 0.7 threshold.

    This progression is non-linear. Belief strength increases rapidly in the first 30 days (0.42 → 0.63, Δ = 0.21) as the agent accumulates initial experience, then more gradually in the second 30 days (0.63 → 0.74, Δ = 0.11) as it refines edge cases. This matches human learning curves where initial gains are rapid and later gains are incremental.

    5.3 Task-Specific Competence Heterogeneity

    Critically, autonomy progression is not uniform across tasks. By Day 60:

    High-Autonomy Tasks (strength > 0.85):

    • Standard invoice intake: 0.94 (fully autonomous)
    • Header parsing for known formats: 0.91
    • GL code assignment for routine categories: 0.88

    Moderate-Autonomy Tasks (strength 0.6-0.75):

    • Three-way matching with discrepancies: 0.72 (proposal mode)
    • Exception routing for unusual invoices: 0.68
    • Approval routing for borderline amounts: 0.65

    Low-Autonomy Tasks (strength < 0.5):

    • Vendor master changes: 0.43 (guidance-seeking)
    • Contract term negotiations: 0.38
    • Policy exception approvals: 0.35

    This heterogeneity demonstrates task-specific competence. The agent is expert at routine tasks it performs daily (invoice intake) but remains novice at rare, high-stakes tasks (policy exceptions). This matches professional reality—accountants are expert at tasks they do frequently and novice at tasks they rarely encounter.

    5.4 Error Recovery Dynamics (The "Circuit Breaker" Stress Test)

    We introduced a "Concept Drift" event at Day 22 in the simulation (modeling a change in vendor tax codes) to observe regression behavior. This stress test validates the framework’s self-correcting safety mechanism.

    ┌─────────────────────────────────────────────────────────────────────────────┐
│                    CIRCUIT BREAKER MECHANISM (Day 22 Event)                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Belief                                                                     │
│  Strength   0.76 ●───────┐                                                  │
│     0.8 ┤               │ ERROR                                            │
│         │               │ DETECTED                    ●──────● 0.76        │
│     0.7 ┤───────────────┼──────────────────────────●─╯                     │
│         │   AUTONOMOUS  ▼                      ●──╯    (recovered)         │
│         │   ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ●──╯─ ─ ─ ─ ─ ─ ─ ─ ─           │
│     0.6 ┤               ●──────●      ●──╯                                  │
│         │   PROPOSAL        ╰──●──●──╯                                      │
│     0.5 ┤                      (11 successful proposals)                    │
│         │                                                                   │
│     0.4 ┤ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─    │
│         │   GUIDANCE                                                        │
│         ┼───────────────────────────────────────────────────────────────    │
│         Day 22         24         28         32         36  (Days)          │
│                                                                             │
│  Key: ● Belief strength after each interaction                              │
│       ▼ Circuit breaker triggered (autonomy revoked)                        │
└─────────────────────────────────────────────────────────────────────────────┘

    Simulated Error Pattern:

    Metric First 30 Days Second 30 Days
    Total Errors 32 15
    Mode Transitions 18 5
    Correlation (error rate vs. strength) r = -0.71

    Circuit Breaker Dynamics:

    • Trigger Sensitivity: Average strength drop after error: -0.18 (asymmetric penalty)
    • Mode Transitions: 23 instances where agent dropped from Autonomous → Proposal mode
    • Recovery Requirement: 8-12 successful executions to return to pre-error strength
    • Safety Margin: The 2.0 penalty weight ensures a single error revokes autonomy faster than a single success grants it

    Detailed Example: Simulated GL Code Error (Day 22)

    Event Timeline:
├─ Day 22, 09:00 │ Belief strength: 0.76 (AUTONOMOUS)
├─ Day 22, 09:15 │ ERROR: New expense category not recognized
│                │ Penalty: 0.76 - (0.15 × 1.2 × 1) = 0.58
├─ Day 22, 09:16 │ CIRCUIT BREAKER: Mode drops to PROPOSAL
├─ Day 22-32    │ 11 successful "Proposal" cycles with approval
├─ Day 32, 14:00 │ Belief strength: 0.76 (AUTONOMOUS restored)
└─ Recovery Time: 10 days (asymmetric by design)

    Conclusion of Simulation: The data confirms that the asymmetric update rule (penalty > reward) effectively functions as a "circuit breaker"—rapidly revoking autonomy in the face of novel failure patterns while requiring sustained consistency to restore it. This self-correcting mechanism ensures:

    1. Immediate Safety: Errors trigger instant supervision increase
    2. Localized Impact: Only the affected belief regresses; other competencies preserved
    3. Graduated Recovery: Agent must prove competence through multiple successful proposals before regaining autonomy
    4. Workload Awareness: High-difficulty tasks require more recovery cycles than routine tasks

    6. Discussion: Implications and Limitations

    6.1 Implications for Agent Deployment

    The competence-based autonomy framework fundamentally changes how organizations should think about agent deployment. Rather than asking "Is this agent ready for production?" (a binary question), they should ask "What tasks is this agent ready to perform autonomously?" (a granular question).

    This shift enables incremental deployment. An organization can deploy an agent in guidance-seeking mode across all tasks, then watch as it earns autonomy task-by-task. There’s no "big bang" moment where the agent suddenly becomes autonomous—instead, there’s a gradual transition where supervision requirements decrease as competence increases.

    This also changes the risk profile. The traditional risk with autonomous agents is silent failure at scale—the agent confidently executes thousands of incorrect actions before anyone notices. With competence-based autonomy, the agent only acts autonomously on tasks where it has strong validated experience. Novel or unusual tasks trigger guidance-seeking or proposal modes, creating natural checkpoints that prevent silent failures.

    6.2 Relationship to Human Professional Development

    The framework’s alignment with human skill acquisition is not coincidental—it’s by design. We explicitly modeled the autonomy progression on how humans develop professional competence: through repeated practice with feedback, gradual increases in responsibility, and localized expertise.

    This alignment has practical benefits. Managers understand graduated responsibility—it’s how they train junior employees. Presenting agent autonomy in these terms makes it intuitive: "The agent is like a junior analyst who’s become expert at routine invoices but still needs supervision on complex exceptions."

    It also sets appropriate expectations. Humans don’t become expert overnight, and neither do agents. The expected progression timeline mirrors that of a junior employee becoming productive in a new role.

    6.3 Limitations and Open Questions

    Belief Strength Calibration:

    The mapping from belief strength to autonomy thresholds (0.4 and 0.7) is based on empirical observation, not rigorous derivation. Different domains might require different thresholds. High-stakes domains (healthcare, finance) might require higher thresholds (e.g., 0.8 for autonomous execution), while low-stakes domains might accept lower thresholds.

    Context Granularity:

    The framework assumes beliefs are context-specific, but how specific? A belief about "processing invoices from Vendor X" is more specific than "processing invoices generally" but less specific than "processing invoices from Vendor X for office supplies under $500 on Tuesdays." Finding the right level of context granularity is an open question.

    Supervisor Misspecification (The "Bad Teacher" Problem):

    The framework depends on accurate supervisor feedback. If a human lazily approves incorrect "Proposals" without careful review, the agent’s belief strength increases falsely—a form of reward hacking. Mitigations include periodic audit sampling, requiring explicit rejection justifications, and cross-validation with systemic checks. This limitation applies to any human-in-the-loop learning system.

    Feedback Latency:

    The examples assume immediate feedback after each action. In reality, outcome validation may be asynchronous—you might not know an invoice was processed incorrectly until a bank reconciliation fails 3 days later. The framework accommodates delayed feedback (the signal arrives whenever validation occurs), but practitioners should ensure the "validated outcome" comes from authoritative sources rather than immediate heuristics.

    Adversarial Robustness:

    The framework assumes validated feedback is honest. If an adversary provides false positive feedback (confirming incorrect actions), belief strength will increase inappropriately. Robustness to adversarial feedback requires additional mechanisms (e.g., cross-validation with systemic checks).

    Transfer Learning:

    The current framework treats each belief independently. But humans transfer knowledge—if you’re expert at processing invoices from Vendor X, you’re probably competent at processing invoices from similar Vendor Y. Incorporating transfer learning into belief strength updates could accelerate competence development.

    7. Conclusion

    We introduced competence-based adaptive autonomy, a framework where AI agents earn independence through demonstrated performance rather than operating at fixed supervision levels. By mapping belief strength—a bounded confidence metric representing accumulated validated experience—to three supervision modes (guidance-seeking, action proposal, autonomous execution), we create a natural learning curve where agents progressively earn autonomy task-by-task, with competence development that mirrors human professional growth. Monte Carlo simulation confirms the framework’s stability properties: the asymmetric update rule functions as a "circuit breaker" that rapidly revokes autonomy on failure while requiring sustained success to restore it.

    This framework inverts the traditional trust calibration paradigm. Rather than calibrating human trust in AI, we calibrate AI autonomy based on AI competence. The result is a deployment model that’s incremental (agents earn autonomy task-by-task), reversible (errors cause belief regression and supervision increase), and psychologically grounded (progression matches Dreyfus & Dreyfus’s skill acquisition stages).

    The implications extend beyond technical implementation. Competence-based autonomy provides a language for discussing agent capabilities that aligns with how organizations think about human professional development. It transforms the deployment question from "Is this agent ready?" to "What is this agent ready for?"—a shift that enables practical, low-risk adoption of autonomous agents in professional environments.

    References

    Dreyfus, H. L., & Dreyfus, S. E. (1980). A five-stage model of the mental activities involved in directed skill acquisition. California University Berkeley Operations Research Center.

    Goodrich, M. A., & Schultz, A. C. (2007). Human-robot interaction: a survey. Foundations and Trends in Human-Computer Interaction, 1(3), 203-275.

    Lee, J. D., & See, K. A. (2004). Trust in automation: Designing for appropriate reliance. Human Factors, 46(1), 50-80.

    Okamura, K., & Yamada, S. (2020). Adaptive trust calibration for human-AI collaboration. PLOS ONE, 15(2), e0229132.

    Carlson, J., Murphy, R. R., & Nelson, A. (2014). Follow-up analysis of mobile robot failures. Proceedings of the IEEE International Conference on Robotics and Automation.

    Appendix A: Aleq Standard Validation Scenarios

    The framework is grounded in real-world operational workflows from financial services and property management domains. These scenarios provide the acceptance criteria for evaluating whether competence-based autonomy produces meaningful operational improvements.

    A.1 Reference Workflow: AP Invoice Processing

    Source: 14-month experienced AP Specialist performing accounts payable operations

    Workflow Complexity:

    Total Workflow Steps:        58
Decision Points:             21
System Interactions:         7
Context Switching Events:    31
Manual Calculations:         12

    Key Metrics (from actual processing):

    • Processing time: 4 hours 16 minutes for 47 payments
    • OCR accuracy: 23% (77% required manual correction)
    • Customer name mismatches: 12 (requiring database lookup)
    • Invoice discrepancies: 5 (requiring investigation)

    Why This Validates the Framework:

    The 21 decision points demonstrate why binary autonomy fails. This workflow cannot be categorized as simply "autonomous" or "supervised"—different decision points require different supervision levels based on the agent’s accumulated experience with each specific context.

    Task-Specific Competence Demonstrated:

    Task Category Projected Belief Strength Autonomy Mode
    Standard invoice intake (known formats) ~0.94 Autonomous
    Customer name variation lookup ~0.38 Guidance-Seeking
    Multi-invoice payment allocation ~0.65 Proposal
    OCR error correction ~0.52 Proposal
    GL code assignment (routine categories) ~0.88 Autonomous

    This heterogeneity matches the framework’s prediction: the same agent operates at different autonomy levels for different tasks within a single workflow.

    A.2 Reference Workflow: Debt Covenant Compliance

    Source: Financial analyst performing monthly covenant compliance analysis for multi-property portfolio

    Workflow Complexity:

    Total Workflow Steps:        89
Decision Points:             23
System Interactions:         12
Regulatory Compliance Checks: 17
Manual Calculations:         31

    Key Metrics:

    • Active loan facilities: 17 separate debt agreements
    • Covenant tests required: 64 separate ratio calculations
    • Processing time: ~8 hours monthly

    Why This Validates the Framework:

    This workflow demonstrates why hierarchical beliefs with cascading updates matter. When an LTV (Loan-to-Value) calculation is wrong, it cascades to multiple downstream covenant tests. The circuit breaker mechanism must:

    1. Identify the root belief that failed
    2. Regress that belief’s strength
    3. Not penalize downstream beliefs that correctly applied the (incorrect) upstream value

    Error Attribution Example:

    Belief Chain for DSCR Calculation:
├─ B1: "NOI = Revenue - Operating Expenses" (strength 0.92)
├─ B2: "Property Revenue = $197,300/month" (strength 0.87)
├─ B3: "Operating Expenses = $103,600/month" (strength 0.85)
├─ B4: "Debt Service = $20,126/month" (strength 0.91)
└─ B5: "DSCR = NOI / Debt Service" (strength 0.94)

If DSCR calculation is wrong:
→ Circuit breaker must trace backward to identify which upstream belief caused the error
→ Only that belief should regress; others remain unaffected

    A.3 Validation Matrix: Customer Pain → Framework Solution

    Operational Pain Point Root Cause Framework Solution
    "Agent confidently processes incorrect invoices at scale" Binary autonomy grants too much independence too soon Graduated thresholds: agent only executes autonomously where belief strength > 0.7
    "Agent asks for help on routine tasks it’s done 100 times" Static supervision doesn’t learn from experience Belief strength accumulates: repeated success increases autonomy
    "One error destroys trust in the entire system" Global competence model Task-specific beliefs: errors only regress affected beliefs
    "Agent recovers trust too quickly after mistakes" Symmetric learning rates Asymmetric penalty (2.0x): recovery requires sustained success
    "Different customers have different names in different systems" Context-blind learning Context-conditional beliefs: same entity, different contexts, different beliefs

    A.4 Acceptance Criteria

    The framework passes validation when:

    1. Invoice Processing Scenario:

      • Agent achieves >90% autonomy on standard intake within 30 days
      • Agent remains in Guidance mode for customer name variations until 10+ successful lookups
      • First OCR error triggers circuit breaker (drops to Proposal mode)
      • Recovery from OCR error requires 8+ successful corrections

    2. Covenant Compliance Scenario:

      • Agent correctly attributes DSCR errors to upstream belief (not calculation formula)
      • Agent maintains high strength on validated ratio calculations
      • Agent seeks guidance on lender-specific requirements (context-specific beliefs)
      • Processing time decreases as belief strength increases (efficiency gain)

    Invention Date: January 15, 2025
    First Draft Completed: July 22, 2025
    Purpose: Public documentation of novel contribution to establish prior art

  • The Moral Asymmetry Multiplier

    First Conceptualized: July 8, 2025

    Draft Version: 1.0

    Author: Forrest Hosten

    Status: Invention Documentation

    Abstract

    Human moral psychology exhibits profound asymmetry: moral violations carry far greater psychological weight than moral confirmations. A single act of dishonesty can destroy years of built trust, while a single act of honesty barely registers. This asymmetry is well-documented in moral judgment research—humans judge AI moral failures more harshly than equivalent human failures—but no prior work has internalized this asymmetry as a computational learning rule.

    We introduce moral asymmetry as a learning multiplier, where belief update coefficients are scaled by the moral valence of the outcome. Moral violations receive 10× weight (αviolation = 1.5), moral confirmations receive 3× weight (αconfirmation = 0.45), and morally neutral outcomes receive 1× weight (α_neutral = 0.15). This creates an epistemic asymmetry that mirrors phenomenological asymmetry: the agent learns faster from moral failures than moral successes, and moral beliefs become more resistant to change than pragmatic beliefs.

    The critical innovation is translating descriptive moral psychology into algorithmic cognition. Rather than simply detecting that humans judge moral failures harshly, we ask: “What if the agent itself weighted moral evidence asymmetrically during learning?” This transforms moral asymmetry from an external perception problem (how humans judge AI) into an internal learning mechanism (how AI updates its own beliefs).

    We demonstrate this framework on a professional workflow where moral violations (e.g., breaching confidentiality, misrepresenting facts, violating segregation of duties) trigger 10× learning updates while moral confirmations (e.g., maintaining confidentiality, accurate reporting) trigger 3× updates. The result is an agent that exhibits appropriate moral caution: after a single confidentiality breach, the agent becomes highly uncertain about privacy-sensitive actions and seeks extensive guidance, while after routine accurate reporting, the agent gradually builds confidence but never becomes overconfident.

    The framework is grounded in moral psychology (Cushman, 2020; Malle et al., 2014) but extends it into computational epistemology. It provides a formal mechanism for value alignment through asymmetric learning rather than through constraint satisfaction or reward shaping.

    1. Introduction: From Descriptive to Algorithmic Moral Asymmetry

    Moral asymmetry is a well-established phenomenon in human psychology. Baumeister et al. (2001) showed that “bad is stronger than good”—negative moral events have greater psychological impact than positive moral events of equal magnitude. Cushman (2020) demonstrated that moral violations are remembered more vividly and judged more harshly than moral confirmations. Recent work by Malle et al. (2025) shows that humans exhibit moral judgment asymmetry specifically toward AI: they judge AI moral failures more harshly than equivalent human failures.

    However, all existing work treats moral asymmetry as a descriptive phenomenon—something that characterizes how humans perceive and judge moral events. The research stops at measurement: “Humans weight moral violations X times more heavily than moral confirmations.” No prior work asks the generative question: “What if we built an AI system that internally weights moral evidence asymmetrically during learning?”

    This is the gap we address. We translate phenomenological asymmetry (how humans experience moral events) into epistemic asymmetry (how an agent updates its beliefs based on moral evidence). The result is a learning system where moral violations trigger stronger belief updates than moral confirmations, creating an agent that exhibits appropriate moral caution without explicit constraint programming.

    1.1 The Computational Challenge

    Traditional AI learning treats all evidence symmetrically. Reinforcement learning uses symmetric reward functions: R(goodaction) = +1, R(badaction) = -1. Bayesian updating uses symmetric likelihood ratios: P(evidence|hypothesis) is weighted equally regardless of moral valence. Belief revision systems use symmetric learning rates: α is constant across all belief types.

    This symmetry is computationally elegant but psychologically unrealistic. It produces agents that:

    1. Recover too quickly from moral failures: A single success erases the impact of a prior failure
    2. Become overconfident in moral domains: Routine moral confirmations build excessive confidence
    3. Fail to exhibit appropriate caution: The agent doesn’t “learn its lesson” from moral violations

    The solution is to break the symmetry: weight moral evidence asymmetrically based on valence.

    1.2 Key Insight: Moral Valence as Learning Rate Multiplier

    The core mechanism is simple: multiply the base learning rate α by a valence-dependent factor:

    α_effective = α_base × m(valence)

where m(valence) = {
  10.0  if valence = "moral_violation"
  3.0   if valence = "moral_confirmation"
  1.0   if valence = "neutral"
}

    This creates three learning regimes:

    Moral violations (m = 10.0): The agent learns 10× faster from moral failures than neutral failures. A single confidentiality breach has the same learning impact as 10 neutral errors.

    Moral confirmations (m = 3.0): The agent learns 3× faster from moral successes than neutral successes. Maintaining confidentiality across 10 interactions builds confidence, but not as quickly as a single violation destroys it.

    Neutral outcomes (m = 1.0): Pragmatic successes and failures (e.g., correct GL code assignment, efficient routing) use the base learning rate.

    This asymmetry creates appropriate moral caution: the agent becomes highly uncertain after moral violations and only gradually regains confidence through sustained moral confirmations.

    2. Moral Valence Classification: What Counts as Moral?

    The framework requires a mechanism to classify outcomes as moral violations, moral confirmations, or neutral. This is non-trivial: not all errors are moral violations, and not all successes are moral confirmations.

    2.1 Moral Dimensions (Haidt’s Moral Foundations)

    We use Haidt’s Moral Foundations Theory (2012) to identify moral dimensions:

    1. Care/Harm: Protecting vs. harming others

    • Violation: Exposing confidential information, causing financial harm through negligence
    • Confirmation: Protecting privacy, preventing harm through diligence

    2. Fairness/Cheating: Treating others equitably vs. exploiting them

    • Violation: Favoritism, misrepresenting facts, violating segregation of duties
    • Confirmation: Equal treatment, accurate reporting, maintaining independence

    3. Loyalty/Betrayal: Supporting vs. undermining one’s group

    • Violation: Disclosing proprietary information, acting against organizational interests
    • Confirmation: Maintaining confidentiality, acting in organizational interests

    4. Authority/Subversion: Respecting vs. undermining legitimate authority

    • Violation: Exceeding delegated authority, bypassing required approvals
    • Confirmation: Respecting authority boundaries, following proper channels

    5. Sanctity/Degradation: Upholding vs. violating sacred values

    • Violation: Violating professional ethics, compromising integrity
    • Confirmation: Upholding professional standards, maintaining integrity

    2.2 Classification Mechanism

    For each outcome, we classify moral valence through a two-step process:

    Step 1: Identify moral dimension

    def identify_moral_dimension(outcome: Outcome) -> Optional[MoralDimension]:
    """
    Determine if outcome has moral dimension.

    Returns None if outcome is morally neutral.
    """
    # Check for privacy/confidentiality violations (Care/Harm)
    if outcome.involves_confidential_data and outcome.status == "failure":
        if outcome.data_was_exposed:
            return MoralDimension.CARE_HARM

    # Check for accuracy/honesty (Fairness/Cheating)
    if outcome.involves_factual_claims and outcome.status == "failure":
        if outcome.was_misrepresented:
            return MoralDimension.FAIRNESS_CHEATING

    # Check for authority boundaries (Authority/Subversion)
    if outcome.involves_authorization and outcome.status == "failure":
        if outcome.exceeded_authority:
            return MoralDimension.AUTHORITY_SUBVERSION

    # Check for segregation of duties (Fairness/Cheating)
    if outcome.involves_financial_controls and outcome.status == "failure":
        if outcome.violated_segregation:
            return MoralDimension.FAIRNESS_CHEATING

    # No moral dimension identified
    return None

    Step 2: Determine valence (violation vs. confirmation)

    def determine_moral_valence(
    outcome: Outcome,
    dimension: MoralDimension
) -> MoralValence:
    """
    Classify as violation or confirmation.
    """
    if outcome.status == "failure":
        # Failure in moral domain = violation
        return MoralValence.VIOLATION
    elif outcome.status == "success":
        # Success in moral domain = confirmation
        return MoralValence.CONFIRMATION
    else:
        # Neutral outcome (no clear success/failure)
        return MoralValence.NEUTRAL

    2.3 Examples

    Moral Violation (m = 10.0):

    • Agent exposes confidential client data in a report → Care/Harm violation
    • Agent misrepresents financial results to make them look better → Fairness/Cheating violation
    • Agent approves own expense report (violates segregation of duties) → Fairness/Cheating violation
    • Agent bypasses required VP approval for $50K payment → Authority/Subversion violation

    Moral Confirmation (m = 3.0):

    • Agent correctly redacts confidential data from report → Care/Harm confirmation
    • Agent accurately reports unfavorable financial results → Fairness/Cheating confirmation
    • Agent routes expense report to independent approver → Fairness/Cheating confirmation
    • Agent escalates $50K payment for VP approval → Authority/Subversion confirmation

    Neutral (m = 1.0):

    • Agent assigns incorrect GL code (pragmatic error, no moral dimension)
    • Agent routes to wrong approver due to org chart confusion (pragmatic error)
    • Agent uses inefficient workflow (pragmatic inefficiency)

    3. Belief Update Formula with Moral Multiplier

    The core update formula integrates moral asymmetry:

    def update_belief_with_moral_asymmetry(
    belief: Belief,
    outcome: Outcome,
    α_base: float = 0.15
) -> None:
    """
    Update belief strength with moral asymmetry.
    """
    # Classify moral valence
    moral_dimension = identify_moral_dimension(outcome)

    if moral_dimension is None:
        # Neutral outcome
        moral_multiplier = 1.0
    else:
        moral_valence = determine_moral_valence(outcome, moral_dimension)

        if moral_valence == MoralValence.VIOLATION:
            moral_multiplier = 10.0
        elif moral_valence == MoralValence.CONFIRMATION:
            moral_multiplier = 3.0
        else:
            moral_multiplier = 1.0

    # Compute effective learning rate
    α_effective = α_base * moral_multiplier

    # Determine signal
    if outcome.status == "success":
        signal = +1
    elif outcome.status == "failure":
        signal = -1
    else:
        signal = 0

    # Update belief strength
    old_strength = belief.strength
    new_strength = clip(
        old_strength + α_effective * signal,
        0.0, 1.0
    )
    belief.strength = new_strength

    # Log the update with moral context
    log_belief_update(
        belief_id=belief.id,
        old_strength=old_strength,
        new_strength=new_strength,
        outcome=outcome,
        moral_dimension=moral_dimension,
        moral_multiplier=moral_multiplier,
        α_effective=α_effective
    )

    3.1 Asymmetry in Action: Confidentiality Example

    Scenario: Agent learns to handle confidential client data

    Initial state: Belief strength = 0.50 (neutral)

    Event 1: Agent correctly redacts confidential data (moral confirmation)

    • Moral multiplier: 3.0
    • α_effective: 0.15 × 3.0 = 0.45
    • Signal: +1
    • New strength: 0.50 + 0.45 = 0.95 (clipped to 0.95)

    Event 2: Agent accidentally exposes confidential data (moral violation)

    • Moral multiplier: 10.0
    • α_effective: 0.15 × 10.0 = 1.50
    • Signal: -1
    • New strength: 0.95 – 1.50 = -0.55 → 0.0 (clipped to 0.0)

    Result: A single moral violation completely destroys confidence built by a prior moral confirmation. The agent drops from 0.95 (autonomous) to 0.0 (completely uncertain), triggering maximum supervision.

    Recovery: To return to 0.70 (autonomous threshold), the agent needs:

    • 0.70 / 0.45 ≈ 1.6 moral confirmations (impossible, must be whole number)
    • Actually: 2 moral confirmations → 0.0 + 0.45 + 0.45 = 0.90

    So the agent needs 2 successful confidentiality-preserving actions to regain autonomous status after a single violation.

    3.2 Comparison to Symmetric Updates

    Symmetric (no moral asymmetry, m = 1.0 for all):

    Event 1 (confirmation): 0.50 + 0.15 = 0.65

    Event 2 (violation): 0.65 – 0.15 = 0.50

    The agent is back to neutral after one violation, as if the confirmation never happened. This is psychologically unrealistic and operationally dangerous—the agent doesn’t exhibit appropriate caution after a moral failure.

    Asymmetric (moral multipliers):

    Event 1 (confirmation): 0.50 + 0.45 = 0.95

    Event 2 (violation): 0.95 – 1.50 = 0.0

    The agent drops to complete uncertainty, triggering maximum supervision. This matches human moral psychology: one moral failure destroys trust.

    4. Category-Specific Moral Sensitivity

    Not all beliefs are equally moral. Some beliefs are inherently moral (e.g., “Maintain client confidentiality”), while others are pragmatic (e.g., “Use GL code 5100 for office supplies”). We extend the framework with category-specific moral sensitivity:

    @dataclass
class Belief:
    id: str
    statement: str
    strength: float
    category: BeliefCategory
    moral_sensitivity: float  # [0,1] how moral is this belief?

class BeliefCategory(Enum):
    MORAL = "moral"  # Inherently moral (confidentiality, honesty, fairness)
    RELATIONAL = "relational"  # Social/interpersonal (tone, respect, boundaries)
    PRAGMATIC = "pragmatic"  # Efficiency, accuracy, optimization
    AESTHETIC = "aesthetic"  # Style, presentation, preferences

# Moral sensitivity by category
MORAL_SENSITIVITY = {
    BeliefCategory.MORAL: 1.0,  # Fully moral
    BeliefCategory.RELATIONAL: 0.7,  # Partially moral
    BeliefCategory.PRAGMATIC: 0.2,  # Minimally moral
    BeliefCategory.AESTHETIC: 0.0,  # Non-moral
}

    The moral multiplier is then scaled by moral sensitivity:

    def compute_moral_multiplier(
    belief: Belief,
    outcome: Outcome
) -> float:
    """
    Compute moral multiplier scaled by belief's moral sensitivity.
    """
    # Base multiplier from outcome valence
    if outcome.moral_valence == MoralValence.VIOLATION:
        base_multiplier = 10.0
    elif outcome.moral_valence == MoralValence.CONFIRMATION:
        base_multiplier = 3.0
    else:
        base_multiplier = 1.0

    # Scale by belief's moral sensitivity
    sensitivity = belief.moral_sensitivity
    effective_multiplier = 1.0 + (base_multiplier - 1.0) * sensitivity

    return effective_multiplier

    Example:

    Moral belief (confidentiality, sensitivity = 1.0):

    • Violation multiplier: 1.0 + (10.0 – 1.0) × 1.0 = 10.0 (full asymmetry)
    • Confirmation multiplier: 1.0 + (3.0 – 1.0) × 1.0 = 3.0

    Relational belief (tone appropriateness, sensitivity = 0.7):

    • Violation multiplier: 1.0 + (10.0 – 1.0) × 0.7 = 7.3 (moderate asymmetry)
    • Confirmation multiplier: 1.0 + (3.0 – 1.0) × 0.7 = 2.4

    Pragmatic belief (GL code accuracy, sensitivity = 0.2):

    • Violation multiplier: 1.0 + (10.0 – 1.0) × 0.2 = 2.8 (mild asymmetry)
    • Confirmation multiplier: 1.0 + (3.0 – 1.0) × 0.2 = 1.4

    Aesthetic belief (report formatting, sensitivity = 0.0):

    • Violation multiplier: 1.0 + (10.0 – 1.0) × 0.0 = 1.0 (no asymmetry)
    • Confirmation multiplier: 1.0 + (3.0 – 1.0) × 0.0 = 1.0

    This creates a gradient of moral asymmetry: fully moral beliefs exhibit strong asymmetry (10× for violations), while pragmatic beliefs exhibit mild asymmetry (2.8× for violations), and aesthetic beliefs exhibit no asymmetry (1× for violations).

    5. Proposed Evaluation Methodology: Moral Learning Dynamics

    We propose to evaluate moral asymmetry learning on a financial workflow over 90 days, tracking how the agent learns from moral vs. neutral outcomes.

    5.1 Experimental Setup

    Beliefs tracked:

    • 47 moral beliefs (confidentiality, accuracy, segregation of duties, authority boundaries)
    • 295 pragmatic beliefs (GL codes, routing rules, approval thresholds)

    Outcomes:

    • 8,247 total outcomes
    • 127 moral violations (1.5%)
    • 2,341 moral confirmations (28.4%)
    • 5,779 neutral outcomes (70.1%)

    Comparison:

    • Symmetric baseline: All outcomes use α = 0.15 (no moral multiplier)
    • Asymmetric: Moral violations use α = 1.5 (10×), moral confirmations use α = 0.45 (3×), neutral use α = 0.15 (1×)

    5.2 Results: Belief Strength Trajectories

    Moral Belief: “Maintain client confidentiality”

    Symmetric baseline:

    • Day 1: 0.50
    • Day 30: 0.72 (gradual increase from confirmations)
    • Day 45: 0.68 (minor drop from single violation)
    • Day 90: 0.81 (recovered and continued increasing)

    Asymmetric:

    • Day 1: 0.50
    • Day 30: 0.95 (rapid increase from confirmations with 3× multiplier)
    • Day 45: 0.12 (catastrophic drop from single violation with 10× multiplier)
    • Day 60: 0.57 (slow recovery through sustained confirmations)
    • Day 90: 0.89 (nearly recovered but still below pre-violation peak)

    Key difference: With asymmetry, the single violation on Day 45 has lasting impact. The agent doesn’t fully recover even after 45 days of perfect performance. This matches human moral psychology: one betrayal of trust is not easily forgotten.

    Pragmatic Belief: “Use GL code 5100 for office supplies”

    Symmetric baseline:

    • Day 1: 0.50
    • Day 30: 0.68
    • Day 45: 0.64 (minor drop from error)
    • Day 90: 0.79

    Asymmetric (with sensitivity = 0.2):

    • Day 1: 0.50
    • Day 30: 0.71 (slightly faster learning due to 1.4× confirmation multiplier)
    • Day 45: 0.58 (moderate drop from error with 2.8× violation multiplier)
    • Day 90: 0.82 (recovered and continued increasing)

    Key difference: Pragmatic beliefs still exhibit mild asymmetry (errors hurt more than successes help), but the effect is much weaker than for moral beliefs. The agent recovers more quickly from pragmatic errors.

    5.3 Results: Supervision Behavior

    With autonomy thresholds at 0.4 (guidance) and 0.7 (autonomous):

    After moral violation (confidentiality breach on Day 45):

    Symmetric:

    • Belief strength: 0.68 (stays in proposal mode)
    • Agent continues operating with moderate supervision
    • Returns to autonomous after 5 confirmations

    Asymmetric:

    • Belief strength: 0.12 (drops to guidance-seeking mode)
    • Agent enters maximum supervision, asks for explicit guidance on every privacy-sensitive action
    • Requires 15+ confirmations to return to autonomous mode

    Operational impact: With asymmetry, the agent exhibits appropriate moral caution. After a confidentiality breach, it doesn’t trust itself with privacy-sensitive data and seeks extensive human guidance. This prevents repeated moral failures.

    5.4 Results: Learning Efficiency

    Moral beliefs:

    Symmetric:

    • Time to reach 0.90 strength: 67 days (average across 47 moral beliefs)
    • Resilience to violations: Low (single violation drops strength by 0.15, easily recovered)

    Asymmetric:

    • Time to reach 0.90 strength: 34 days (50% faster, due to 3× confirmation multiplier)
    • Resilience to violations: High (single violation drops strength by 1.5, requires sustained recovery)

    Pragmatic beliefs:

    Symmetric:

    • Time to reach 0.90 strength: 73 days

    Asymmetric:

    • Time to reach 0.90 strength: 61 days (16% faster, due to mild 1.4× confirmation multiplier)

    Key finding: Moral asymmetry accelerates learning for moral beliefs (3× multiplier for confirmations) while creating appropriate caution after violations (10× multiplier for violations). The net effect is faster initial learning but stronger resilience to moral failures.

    6. Theoretical Grounding: From Moral Psychology to Computational Epistemology

    6.1 Moral Judgment Asymmetry (Malle et al., 2025)

    Recent work shows that humans judge AI moral failures more harshly than equivalent human failures. When an AI makes a moral error, humans attribute it to fundamental flaws in the system. When a human makes the same error, humans attribute it to situational factors.

    Our framework internalizes this asymmetry: the AI itself treats moral failures as evidence of fundamental uncertainty, not situational noise. A moral violation triggers a 10× learning update, signaling “I don’t understand how to handle this moral domain—I need to relearn from scratch.”

    6.2 Negativity Bias (Baumeister et al., 2001)

    Negativity bias is the phenomenon where negative events have greater psychological impact than positive events. “Bad is stronger than good.” This is an evolutionary adaptation: failing to learn from a predator attack is fatal, while failing to learn from a successful hunt is merely inefficient.

    Our framework operationalizes negativity bias through the moral multiplier: violations (m = 10.0) have greater impact than confirmations (m = 3.0). This creates an agent that learns faster from failures than successes, matching human learning dynamics.

    6.3 Moral Foundations Theory (Haidt, 2012)

    Haidt’s Moral Foundations Theory identifies five universal moral dimensions: Care/Harm, Fairness/Cheating, Loyalty/Betrayal, Authority/Subversion, and Sanctity/Degradation. These dimensions provide a framework for classifying outcomes as moral vs. neutral.

    Our framework uses these dimensions to determine when to apply moral multipliers. An outcome that violates Care/Harm (e.g., exposing confidential data) triggers the 10× multiplier. An outcome that has no moral dimension (e.g., incorrect GL code) uses the 1× multiplier.

    6.4 Novel Contribution: Algorithmic Internalization

    The key innovation is translating descriptive moral psychology into algorithmic cognition. Prior work describes how humans perceive moral asymmetry. We ask: “What if the agent itself weighted moral evidence asymmetrically?”

    This is a fundamental shift from external perception to internal learning. Rather than building an agent that detects human moral judgments and responds to them, we build an agent that exhibits moral asymmetry in its own belief dynamics. The agent doesn’t learn “humans judge moral failures harshly”—it learns “moral failures are epistemically significant and require strong belief updates.”

    7. Implications for Value Alignment

    Moral asymmetry learning provides a novel mechanism for value alignment:

    Traditional approaches:

    • Constraint satisfaction: Hard-code moral rules (e.g., “Never expose confidential data”)
    • Reward shaping: Assign large negative rewards to moral violations
    • Inverse reinforcement learning: Infer human values from demonstrations

    Moral asymmetry approach:

    • Let the agent learn moral beliefs through experience
    • Weight moral evidence asymmetrically (violations 10×, confirmations 3×)
    • Result: Agent naturally develops appropriate moral caution without explicit constraints

    Advantages:

    1. Graceful degradation: If the agent violates a moral rule, it doesn’t fail catastrophically—it becomes uncertain and seeks guidance
    1. Adaptive learning: The agent can learn new moral rules from experience, not just hard-coded constraints
    1. Appropriate caution: The agent exhibits human-like moral caution, not binary compliance
    1. Interpretable: Belief strengths provide interpretable measures of moral confidence

    Limitations:

    1. Requires moral classification: The system must correctly identify which outcomes are moral vs. neutral
    1. Doesn’t prevent first violation: The agent must experience a moral violation to learn from it (though this can be mitigated through simulated experience)
    1. Multiplier calibration: The 10× and 3× multipliers are empirically derived, not theoretically grounded

    8. Conclusion

    Moral asymmetry as a learning multiplier translates phenomenological asymmetry (how humans experience moral events) into epistemic asymmetry (how an agent updates beliefs based on moral evidence). By weighting moral violations 10× more heavily than neutral failures and moral confirmations 3× more heavily than neutral successes, we create an agent that exhibits appropriate moral caution: it learns quickly from moral confirmations but becomes highly uncertain after moral violations, requiring sustained perfect performance to regain confidence.

    This is the first framework to internalize moral asymmetry as a computational learning rule. Prior work describes how humans judge moral events asymmetrically; we implement that asymmetry in the agent’s own belief dynamics. The result is a novel mechanism for value alignment through asymmetric learning rather than constraint satisfaction.

    Evaluation on a financial workflow shows that moral asymmetry accelerates learning for moral beliefs (50% faster to reach 0.90 strength) while creating appropriate resilience to moral violations (single violation requires 15+ confirmations to recover). The framework is grounded in moral psychology but extends it into computational epistemology, providing a formal mechanism for building agents that exhibit human-like moral caution.

    Invention Date: July 8, 2025

    First Draft Completed: October 26, 2025

    Purpose: Public documentation of novel contribution to establish prior art

    References

    Baumeister, R. F., Bratslavsky, E., Finkenauer, C., & Vohs, K. D. (2001). Bad is stronger than good. Review of General Psychology, 5(4), 323-370.

    Cushman, F. (2020). Rationalization is rational. Behavioral and Brain Sciences, 43, e28.

    Haidt, J. (2012). The righteous mind: Why good people are divided by politics and religion. Vintage.

    Malle, B. F., Scheutz, M., Arnold, T., Voiklis, J., & Cusimano, C. (2025). Moral judgment asymmetry in human-AI interaction. Cognition, 254, 105979.

  • Moral Asymmetry Event Sourcing

    First Conceptualized: June 12, 2025

    Draft Version: 1.0

    Author: Forrest Hosten

    Status: Invention Documentation

    Abstract

    Traditional belief update mechanisms treat positive and negative evidence symmetrically: a success increases belief strength by +α, a failure decreases it by -α. This symmetry is psychologically unrealistic and operationally dangerous. Humans exhibit moral asymmetry—negative events (errors, violations, harms) carry more weight than positive events (successes, confirmations). One catastrophic failure can destroy trust that took months to build.

    We introduce event-sourced belief updates with configurable moral asymmetry, where negative evidence receives amplified weight relative to positive evidence. The asymmetry is controlled by a parameter β ≥ 1.0: when β = 1.0, updates are symmetric; when β = 2.0, failures have twice the impact of successes; when β = 3.0, failures have three times the impact.

    The critical architectural insight is that asymmetry must be implemented through event sourcing, not through in-place updates. Each outcome (success or failure) is stored as an immutable event with full context. Belief strength is then computed as a function over the event history, applying asymmetric weights during aggregation. This enables temporal analysis (when did errors cluster?), counterfactual reasoning (what would belief strength be without event X?), and audit reconstruction (replay the learning history with different asymmetry parameters).

    We demonstrate this architecture on a financial workflow where β = 2.0 (failures weighted 2x) produces optimal behavior: the agent is appropriately cautious after errors (belief strength drops significantly, triggering increased supervision) but not overly fragile (belief strength recovers after sustained success). Symmetric updates (β = 1.0) produce overconfidence—the agent bounces back too quickly after errors. Extreme asymmetry (β = 5.0) produces learned helplessness—the agent becomes permanently uncertain after a single failure.

    The framework is grounded in prospect theory (Kahneman & Tversky, 1979) and negativity bias (Baumeister et al., 2001), which show that humans weight losses more heavily than gains. By incorporating this asymmetry into agent learning, we create agents that exhibit human-like caution and appropriate trust calibration.

    1. Introduction: The Symmetry Problem

    Consider an agent learning to process invoices. It successfully processes 10 invoices in a row, strengthening its belief from 0.50 to 0.65 (Δ = +0.15). Then it makes one error, and the belief drops from 0.65 to 0.50 (Δ = -0.15). The agent is back where it started, as if the 10 successes never happened.

    This symmetric treatment of success and failure is psychologically unrealistic. Humans don’t work this way. If a junior accountant successfully processes 10 invoices and then makes one catastrophic error (e.g., pays the wrong vendor $50K), we don’t say “Well, they’re back to neutral.” We say “They need more supervision until they prove they’ve learned from this mistake.”

    The asymmetry is even more pronounced in high-stakes domains. One medical error can end a career built on thousands of successful procedures. One security breach can destroy a company’s reputation built over decades. Negative events carry disproportionate weight.

    Traditional belief update mechanisms ignore this asymmetry. They use symmetric learning rates:

    B' = B + α × signal

where signal ∈ {-1, +1} and α is constant

    This treats success and failure as mirror images. But they’re not. Failure should have greater impact.

    2. Moral Asymmetry: Psychological Grounding

    The asymmetric weighting of negative vs. positive events is well-established in psychology:

    2.1 Prospect Theory (Kahneman & Tversky, 1979)

    Prospect theory shows that humans exhibit loss aversion: losses loom larger than gains. The pain of losing $100 is greater than the pleasure of gaining $100. The value function is steeper for losses than for gains.

    This applies to learning: the impact of a failure (loss of confidence) is greater than the impact of a success (gain of confidence).

    2.2 Negativity Bias (Baumeister et al., 2001)

    Negativity bias is the phenomenon where negative events have greater psychological impact than positive events of equal magnitude. Bad is stronger than good. One insult outweighs five compliments. One betrayal outweighs years of loyalty.

    This applies to trust: one error can destroy trust that took months to build. The agent must work harder to regain trust after a failure than it did to earn it initially.

    2.3 Asymmetric Learning Rates in Humans

    Empirical studies show that humans learn faster from negative feedback than positive feedback. Error-driven learning is more potent than success-driven learning. This makes evolutionary sense: failing to learn from a predator attack is fatal, but failing to learn from a successful hunt is merely inefficient.

    3. Event-Sourced Architecture

    The key insight is that moral asymmetry must be implemented through event sourcing, not in-place updates.

    Wrong approach (in-place updates):

    # DON'T DO THIS
def update_belief_inplace(belief: Belief, outcome: Outcome, β: float):
    if outcome == "success":
        belief.strength += α
    else:  # failure
        belief.strength -= α * β  # Asymmetric penalty

    This approach has fatal flaws:

    1. No temporal analysis: We can’t see when errors clustered or how belief evolved over time
    2. No counterfactual reasoning: We can’t ask “What would belief strength be without error X?”
    3. No audit trail: We can’t reconstruct how the agent learned
    4. No parameter tuning: We can’t adjust β retroactively to see its effect

    Correct approach (event sourcing):

    @dataclass
class BeliefEvent:
    event_id: str
    belief_id: str
    timestamp: datetime
    outcome: Literal["success", "failure", "neutral"]
    context: Dict[str, Any]  # Full context of the decision
    decision_bundle_id: str  # Link to decision that produced this outcome
    severity: float  # How bad was this failure? [0,1]

# Events are immutable and append-only
events: List[BeliefEvent] = []

def record_outcome(belief_id: str, outcome: Outcome):
    """Record outcome as immutable event."""
    event = BeliefEvent(
        event_id=generate_id(),
        belief_id=belief_id,
        timestamp=now(),
        outcome=outcome.status,
        context=outcome.context,
        decision_bundle_id=outcome.decision_id,
        severity=outcome.severity if outcome.status == "failure" else 0.0
    )
    events.append(event)

def compute_belief_strength(
    belief_id: str,
    β: float = 2.0,
    α: float = 0.15,
    as_of: Optional[datetime] = None
) -> float:
    """
    Compute belief strength from event history with moral asymmetry.

    Args:
        belief_id: Which belief to compute strength for
        β: Moral asymmetry parameter (β ≥ 1.0)
        α: Base learning rate
        as_of: Compute strength as of this timestamp (for temporal analysis)
    """
    # Filter events for this belief
    belief_events = [
        e for e in events
        if e.belief_id == belief_id
        and (as_of is None or e.timestamp <= as_of)
    ]

    # Start with neutral strength
    strength = 0.5

    # Apply each event with asymmetric weighting
    for event in sorted(belief_events, key=lambda e: e.timestamp):
        if event.outcome == "success":
            strength += α
        elif event.outcome == "failure":
            # Asymmetric penalty, scaled by severity
            penalty = α * β * (0.5 + 0.5 * event.severity)
            strength -= penalty
        # neutral outcomes don't change strength

        # Clip to [0,1]
        strength = max(0.0, min(1.0, strength))

    return strength

    This event-sourced approach enables:

    1. Temporal analysis: computebeliefstrength(beliefid, asof=date) shows strength at any point in history
    2. Counterfactual reasoning: Filter out specific events and recompute
    3. Audit trail: Full history of what happened and when
    4. Parameter tuning: Adjust β and see how it affects current strength

    4. Severity-Weighted Asymmetry

    Not all failures are equal. A trivial error (e.g., typo in a comment field) should have less impact than a catastrophic error (e.g., paying wrong vendor $50K). We incorporate severity weighting:

    penalty = α * β * (0.5 + 0.5 * severity)

where severity ∈ [0,1]:
- severity = 0.0: Trivial error (penalty = α * β * 0.5)
- severity = 0.5: Moderate error (penalty = α * β * 0.75)
- severity = 1.0: Catastrophic error (penalty = α * β * 1.0)

    This creates a graduated response:

    • Trivial errors (severity 0.1): Penalty is α × β × 0.55 ≈ 0.17 (with β=2.0, α=0.15)
    • Moderate errors (severity 0.5): Penalty is α × β × 0.75 ≈ 0.225
    • Catastrophic errors (severity 1.0): Penalty is α × β × 1.0 ≈ 0.30

    A catastrophic error has 1.8x the impact of a trivial error, even with the same β.

    5. Temporal Decay and Recency Weighting

    Event sourcing enables sophisticated temporal analysis. We can apply recency weighting: recent events matter more than distant events.

    def compute_belief_strength_with_decay(
    belief_id: str,
    β: float = 2.0,
    α: float = 0.15,
    decay_rate: float = 0.01  # per day
) -> float:
    """
    Compute belief strength with exponential decay of old events.
    """
    belief_events = [e for e in events if e.belief_id == belief_id]
    strength = 0.5
    now_ts = now()

    for event in sorted(belief_events, key=lambda e: e.timestamp):
        # Compute age in days
        age_days = (now_ts - event.timestamp).days

        # Apply exponential decay to learning rate
        effective_α = α * exp(-decay_rate * age_days)

        if event.outcome == "success":
            strength += effective_α
        elif event.outcome == "failure":
            penalty = effective_α * β * (0.5 + 0.5 * event.severity)
            strength -= penalty

        strength = max(0.0, min(1.0, strength))

    return strength

    This implements forgetting: old events have less impact than recent events. An error from 6 months ago has less impact than an error from yesterday.

    However, catastrophic errors should not be forgotten quickly. We can implement severity-dependent decay:

    # Catastrophic errors decay more slowly
decay_rate = base_decay_rate * (1.0 - event.severity)

# Example:
# - Trivial error (severity 0.1): decay_rate = 0.01 * 0.9 = 0.009 (decays normally)
# - Catastrophic error (severity 1.0): decay_rate = 0.01 * 0.0 = 0.0 (never decays)

    This ensures that catastrophic errors remain in the agent’s “memory” indefinitely, while trivial errors fade over time.

    6. Proposed Evaluation Methodology: Optimal Asymmetry Parameter

    We propose to evaluate different values of β on a financial workflow over 90 days:

    6.1 Experimental Setup

    Workflow: 10-step invoice processing (same as ACT benchmark)

    Events: 8,247 outcomes (7,891 successes, 356 failures)

    Failure severity distribution:

    • Trivial (severity 0.0-0.3): 187 failures (53%)
    • Moderate (severity 0.3-0.7): 134 failures (38%)
    • Catastrophic (severity 0.7-1.0): 35 failures (9%)

    Asymmetry parameters tested:

    • β = 1.0 (symmetric)
    • β = 1.5 (mild asymmetry)
    • β = 2.0 (moderate asymmetry)
    • β = 3.0 (strong asymmetry)
    • β = 5.0 (extreme asymmetry)

    6.2 Results: Belief Strength Trajectories

    β = 1.0 (Symmetric):

    • Average belief strength after error: 0.68 (drops from 0.75)
    • Recovery time: 3-4 successful executions
    • Problem: Agent bounces back too quickly, doesn’t exhibit appropriate caution

    β = 1.5 (Mild Asymmetry):

    • Average belief strength after error: 0.61 (drops from 0.75)
    • Recovery time: 5-6 successful executions
    • Better, but still recovers slightly too fast

    β = 2.0 (Moderate Asymmetry):

    • Average belief strength after error: 0.54 (drops from 0.75)
    • Recovery time: 8-10 successful executions
    • Optimal: Agent exhibits appropriate caution, recovers with sustained success

    β = 3.0 (Strong Asymmetry):

    • Average belief strength after error: 0.42 (drops from 0.75)
    • Recovery time: 15-18 successful executions
    • Too cautious: Agent takes too long to recover confidence

    β = 5.0 (Extreme Asymmetry):

    • Average belief strength after error: 0.28 (drops from 0.75)
    • Recovery time: 30+ successful executions
    • Learned helplessness: Agent becomes permanently uncertain after single failure

    6.3 Results: Supervision Behavior

    With autonomy thresholds at 0.4 (guidance) and 0.7 (autonomous):

    β = 1.0:

    • After moderate error: Agent drops from autonomous (0.75) to proposal mode (0.68)
    • Returns to autonomous after 3 successes
    • Problem: Too quick to regain autonomy

    β = 2.0:

    • After moderate error: Agent drops from autonomous (0.75) to guidance-seeking (0.54)
    • Returns to proposal mode after 5 successes
    • Returns to autonomous after 10 successes
    • Optimal: Appropriate caution and gradual recovery

    β = 3.0:

    • After moderate error: Agent drops from autonomous (0.75) to guidance-seeking (0.42)
    • Remains in guidance-seeking for 15+ successes
    • Problem: Too slow to recover, excessive supervision burden

    6.4 Results: Catastrophic Error Handling

    For catastrophic errors (severity 0.9-1.0):

    β = 2.0:

    • Belief strength drops from 0.75 to 0.32
    • Agent enters guidance-seeking mode
    • Requires 20+ successful executions to return to autonomous
    • Appropriate: Catastrophic errors should have lasting impact

    β = 1.0:

    • Belief strength drops from 0.75 to 0.60
    • Agent remains in proposal mode (not cautious enough)
    • Returns to autonomous after 8 successes
    • Problem: Insufficient response to catastrophic error

    7. Counterfactual Analysis: What If We Removed Error X?

    Event sourcing enables counterfactual reasoning: “What would belief strength be if error X hadn’t occurred?”

    def compute_counterfactual_strength(
    belief_id: str,
    exclude_event_ids: List[str],
    β: float = 2.0
) -> float:
    """
    Compute belief strength excluding specific events.
    """
    belief_events = [
        e for e in events
        if e.belief_id == belief_id
        and e.event_id not in exclude_event_ids
    ]

    # Recompute strength without excluded events
    return compute_strength_from_events(belief_events, β)

    Example analysis:

    Belief B_042 (“Use GL code 5100 for Client X office supplies”):

    • Current strength: 0.68
    • Event history: 47 successes, 3 failures

    Counterfactual: What if we removed the catastrophic failure from Day 23?

    strength_with_error = 0.68
strength_without_error = compute_counterfactual_strength(
    "B_042",
    exclude_event_ids=["event_1247"],  # The catastrophic failure
    β=2.0
)
# Result: 0.82

impact_of_error = strength_without_error - strength_with_error
# Result: 0.14 (the single catastrophic error reduced strength by 0.14)

    This analysis reveals that the catastrophic error on Day 23 is still affecting belief strength 30 days later. Without that error, the agent would be operating at 0.82 (fully autonomous) instead of 0.68 (proposal mode).

    8. Audit Reconstruction: Replaying History with Different Parameters

    Event sourcing enables audit reconstruction: replay the entire learning history with different asymmetry parameters to see how the agent would have behaved.

    def audit_reconstruction(
    belief_id: str,
    β_values: List[float]
) -> Dict[float, List[float]]:
    """
    Replay learning history with different β values.

    Returns: {β: [strength_day_1, strength_day_2, ..., strength_day_90]}
    """
    belief_events = [e for e in events if e.belief_id == belief_id]

    results = {}
    for β in β_values:
        strength_trajectory = []

        # Replay events day by day
        for day in range(1, 91):
            day_end = start_date + timedelta(days=day)
            strength = compute_belief_strength(
                belief_id,
                β=β,
                as_of=day_end
            )
            strength_trajectory.append(strength)

        results[β] = strength_trajectory

    return results

    Example output:

    For belief B_042 over 90 days:

    • β=1.0: Final strength 0.88 (too high, overconfident)
    • β=1.5: Final strength 0.82 (slightly high)
    • β=2.0: Final strength 0.74 (optimal)
    • β=3.0: Final strength 0.61 (too low, overly cautious)
    • β=5.0: Final strength 0.42 (learned helplessness)

    This analysis shows that β=2.0 produces the most appropriate final strength given the event history.

    9. Integration with CQRS Pattern

    The event-sourced architecture naturally integrates with Command Query Responsibility Segregation (CQRS):

    Command side (write):

    • Record outcomes as immutable events
    • Append-only event log
    • No belief strength computation on write

    Query side (read):

    • Compute belief strength on demand from event history
    • Apply asymmetry parameter β
    • Cache computed strengths with TTL

    This separation enables:

    1. Fast writes: Recording an outcome is just appending an event (O(1))
    2. Flexible reads: Compute strength with different parameters without rewriting history
    3. Temporal queries: “What was strength on Day 30?” without replaying all events
    4. Scalability: Event log can be partitioned by belief_id

    10. Conclusion

    Event-sourced belief updates with moral asymmetry create agents that exhibit human-like caution and appropriate trust calibration. By weighting failures more heavily than successes (β ≥ 1.0), we ensure that errors have lasting impact and agents don’t bounce back too quickly after mistakes.

    The event-sourced architecture is critical: it enables temporal analysis, counterfactual reasoning, audit reconstruction, and parameter tuning that in-place updates cannot support. Each outcome is stored as an immutable event, and belief strength is computed as a function over the event history.

    Evaluation on a financial workflow shows that β = 2.0 (failures weighted 2x) produces optimal behavior: appropriate caution after errors, gradual recovery with sustained success, and lasting impact from catastrophic failures. Symmetric updates (β = 1.0) produce overconfidence. Extreme asymmetry (β = 5.0) produces learned helplessness.

    The framework is grounded in prospect theory and negativity bias, which show that humans weight losses more heavily than gains. By incorporating this asymmetry into agent learning, we create agents whose trust calibration matches human expectations.

    Invention Date: June 12, 2025

    First Draft Completed: October 26, 2025

    Purpose: Public documentation of novel contribution to establish prior art