Hi, I'm Forrest

Category: Connecting

  • The Architecture Emerges

    Six months ago I started asking: why can’t AI agents remember?

    Now I have 18 papers drafted. Each one formalizes a piece of the puzzle.

    The architecture that emerged isn’t what I expected. I thought I’d be building better databases or smarter retrieval. Instead, I ended up designing a cognitive system: belief graphs, working memory, relationship dynamics, temporal reasoning.

    It turns out agent memory isn’t a storage problem. It’s a learning problem.

    Here’s the stack:

    Foundation: Beliefs with Strength Scores

    Every agent action is guided by beliefs about how the world works. Each belief has a confidence score (0 to 1) that adjusts based on validated feedback. This enables competence-based autonomy: the agent only acts when confident, otherwise it asks.

    Layer 1: Event-Sourced Updates

    All belief updates are logged as immutable events. This provides audit trails, enables temporal analysis, and prevents silent corruption. Failures weigh more than successes (moral asymmetry), so the agent learns faster from mistakes.

    Layer 2: Hierarchical Belief Structure

    Beliefs aren’t flat—they’re organized in hierarchies. Abstract principles support specific procedures. When evidence challenges a low-level belief, updates can cascade upward. This mirrors how humans revise understanding: you don’t throw out everything, just the pieces that broke.

    Layer 3: Context-Conditional Beliefs

    The same action can be right in one context and wrong in another. The agent maintains independent belief states per context (e.g., “month-end close” vs. “routine processing”). This prevents overgeneralization while enabling transfer learning.

    Layer 4: Working Memory (Three Columns)

    Not everything belongs in long-term memory. The agent has a three-column workspace: Active Tasks (what you’re doing now), Notes (things to remember soon), and Objects (people/entities currently relevant). This separates operational state from episodic memory.

    Layer 5: Social Awareness

    Professional work involves relationships. The agent tracks authority, interaction history, and context for every person. It learns who can approve what, who prefers which communication style, and how to resolve conflicting guidance.

    Layer 6: Temporal Reasoning

    The agent estimates task duration based on historical performance, adjusts scheduling based on urgency and relationships, and pre-loads context before predictable interactions (meetings, deadlines).

    Integration: The Learning Loop

    Every interaction produces feedback. Feedback updates beliefs. Beliefs guide future actions. Competence increases. Autonomy expands. The agent gets better at its job.

    This isn’t speculative. I’m implementing it at Aleq. The papers starting next month document the concepts, the evaluation protocols, and the novel contributions. They establish prior art. They make the ideas citable.

    But the real test is production: does it work? Does the agent actually learn from experience? Does autonomy increase safely? Does it earn trust?

    I believe it will. The architecture is sound. The foundations are solid. Now it’s time to prove it.

    The papers begin next week.

  • Building Belief Systems That Learn

    The core challenge isn’t making agents do tasks. It’s making them remember how tasks went.

    Most AI systems are stateless. You ask a question, get an answer, repeat. No memory of what worked before. No adjustment based on past failures. Each interaction starts from zero.

    That’s not how professionals work.

    When you’ve processed 200 invoices, you develop intuitions. You know which vendors always have discrepancies. You remember that the CFO prefers morning approvals. You’ve learned which GL codes map to which expense types without checking the chart every time.

    That’s competence. And competence requires memory—not just facts, but beliefs about how the world works, weighted by accumulated evidence.

    Here’s what I’m building: agents with belief graphs. Each belief has a strength score (0 to 1) that updates based on experience. When the agent tries something and it works, belief strength increases. When it fails, belief strength decreases—and failures weigh more than successes (moral asymmetry).

    The agent doesn’t act autonomously until belief strength crosses a threshold. Early on, it asks for guidance constantly. As beliefs strengthen through validated feedback, autonomy increases. This happens task-by-task, not globally. The agent might be confident at invoice processing but uncertain about month-end close.

    This is the opposite of how most “AI autonomy” works today. Current systems either assume full autonomy (and fail catastrophically) or require human supervision for everything (and never improve). Neither scales.

    Competence-based autonomy solves this: the agent earns trust through demonstrated reliability, measured in belief strength, tracked per task. It’s objective, auditable, and safe.

    The system I’m designing treats beliefs as first-class entities. Each belief has:

    • A proposition (e.g., “vendor X always has price discrepancies”)
    • A strength score (how confident the agent is)
    • An event history (what evidence supports or contradicts it)
    • Contextual scope (when does this belief apply?)

    When new evidence arrives—through feedback, system checks, or self-validation—the agent updates relevant beliefs. Not all beliefs, just the ones causally connected to the outcome. This prevents the “innocent bystander” problem where unrelated beliefs get corrupted by random errors.

    The architecture emerging from this is surprisingly elegant: a hierarchical belief graph, event-sourced updates, configurable moral asymmetry, and working memory that separates active tasks from ambient context.

    It’s complex, but it’s also how humans actually learn. We don’t start over each day. We accumulate experience, refine our models, and adjust our confidence based on what happened before.

    That’s what I’m building. Agents that learn like professionals, not parlor tricks that reset after every interaction.

  • From Narratives to Numbers

    I’ve spent the last five months writing about AI memory in stories. Why beliefs matter. How time shapes experience. What happens when expectations meet reality.

    Now it’s time to turn those stories into systems.

    The narrative posts were necessary—they forced me to think through why before worrying about how. But stories aren’t architecture. Intuition isn’t implementation. If I want agents that actually learn from experience, I need formal models, not just compelling metaphors.

    So here’s what’s changing: starting next month, I’m shifting from narrative exploration to technical documentation. Each concept I’ve outlined—competence-based autonomy, belief strength, moral asymmetry, working memory—needs to become a paper. Not because I love academic writing (I don’t), but because precision matters.

    When I say “agents should adjust their autonomy based on confidence,” that’s a nice idea. When I formalize it as a three-level system with belief-strength thresholds and task-specific competence tracking, that’s something you can build.

    The difference is everything.

    I’m documenting these concepts now because they’re genuinely novel. I checked—thoroughly. No one else is building learning agents with hierarchical belief graphs, event-sourced updates, and relationship-aware working memory. This work establishes priority. It makes the ideas citable. It transforms “what if” into “here’s how.”

    The papers won’t be as readable as these posts. They’ll have formulas and benchmarks and references to other academic work. That’s intentional. The goal isn’t entertainment—it’s clarity. I want other researchers to understand exactly what I’m proposing, how it differs from existing approaches, and what it enables.

    Some of you will miss the narrative style. I get it. But the story was always leading here: to systems that work, to agents that earn trust through accumulated experience, to architecture that makes learning possible.

    The next ten weeks are about making that real.