Nous：基于 Minsky《心智社会》的 AI 智能体认知架构框架

A cognitive architecture for AI agents, grounded in Minsky's Society of Mind.

Nous is a framework for building AI agents that think, learn, and grow — not just respond. It applies the decision intelligence principles proven by Cognition Engines, and implements Marvin Minsky's Society of Mind principles as first-class architectural components.

"To explain the mind, we have to show how minds are built from mindless stuff." — Marvin Minsky

Quickstart Guide → — Deploy Nous from scratch in minutes.

Why Nous?

Current AI agents are stateless reactors. They receive a prompt, generate a response, and forget. Even agents with "memory" just store and retrieve text — there's no structure, no learning, no growth.

Nous is different. It gives agents:

• Structured memory that mirrors how minds actually work (not just vector search)
• Decision intelligence that learns from past choices and calibrates confidence
• Self-monitoring that catches mistakes before they happen
• Proactive autonomy — agents notice things on their own, not only when prompted
• Administrative growth — agents get smarter by managing themselves better, not just accumulating more knowledge

Architecture Overview

graph TB
    subgraph "Nous Agent"
        A[Stimulus] --> B[Frame Selection]
        B --> C[Memory Recall]
        C --> D[Pre-Action Protocol]
        D --> E[Deliberation]
        E --> F[Action]
        F --> G[Self-Monitoring]
        G --> H[Memory Update]
    end

    subgraph "Brain (Decision Memory)"
        D <--> CE[Decisions & Calibration]
        G <--> CE
        H <--> CE
        CE --- PG[(PostgreSQL + pgvector)]
    end

    subgraph "Society of Mind Layers"
        B -.- FR[Frames & Censors]
        C -.- KL[K-Lines & Level-Bands]
        E -.- PB[Parallel Bundles]
        G -.- BB[B-Brain Monitor]
    end

    subgraph "Background Organs"
        HB[Heartbeat<br/>Proactive Checks]
        DAG[DAG Orchestrator<br/>Multi-Step Plans]
        OBS[Observability<br/>Context Log · Drift · Snapshots]
        HB -.- F
        DAG -.- F
        OBS -.- G
    end

Loading

Core Concepts

From Minsky

From Cognition Engines

The Nous Loop

Every agent action follows this cycle:

SENSE → FRAME → RECALL → DELIBERATE → ACT → MONITOR → LEARN

1. SENSE (Stimulus Reception)

The agent receives input — a message, an event, a timer. Raw perception.

2. FRAME (Interpretation)

Select a cognitive frame for interpreting the input. "Is this a bug report? A creative request? A decision point?" The frame determines which agencies activate.

Minsky insight: You can only hold one frame at a time (Necker cube). Frame-switching is explicit, not automatic. For important decisions, spawn parallel frames via sub-agents (Devil's Advocate, Optimist, etc.).

3. RECALL (Hybrid Memory Search)

Activate relevant K-lines — context bundles that reconstruct the mental state needed for this type of work. K-lines connect at three levels:

• Upper fringe (goals): weakly attached, may not apply
• Core (patterns & tools): strongly attached, the transferable knowledge
• Lower fringe (implementation details): easily displaced by current context

Minsky insight: Memory is reconstruction, not retrieval. You don't "find" old knowledge — you become a version of yourself that had it.

4. DELIBERATE (Pre-Action Protocol)

Before acting, query the decision memory:

1. Query similar past decisions — what happened when I faced this before?
2. Check guardrails — am I allowed to do this?
3. Record intent — capture the deliberation trace BEFORE acting
4. Assess confidence — how sure am I? (calibration feedback loop)

Minsky insight: Consciousness is menu lists, not deep access. The deliberation trace IS the thinking, not a record of it.

5. ACT (Execution)

Do the thing. While working, capture reasoning with micro-thoughts — the B-brain watches the A-brain work.

6. MONITOR (Self-Assessment)

After acting, the B-brain evaluates:

• Did the action match the intent?
• Were there unexpected consequences?
• Should a censor be activated for next time?

Minsky insight: Keep the watcher simple and rule-based. Meta-decisions about decision-making are recursive and dangerous.

7. LEARN (Memory Update)

Update memory at all levels:

• Decision memory — finalize the decision record with outcome
• K-lines — create or update context bundles if new patterns emerged
• Calibration — feed confidence vs outcome back into the system
• Guardrails — add new censors if a failure mode was discovered

Memory Architecture

graph TB
    subgraph "Slow (Identity)"
        ID["Agent Identity (DB)<br/>Character · Values · Protocols<br/><i>F018 — shipped</i>"]
    end

    subgraph "Medium (Knowledge)"
        FACTS[Facts<br/>Learned Knowledge]
        KL["Procedures / K-Lines<br/>Context Bundles<br/><i>F012 — shipped</i>"]
        EP[Episodes<br/>Multi-Session Projects]
    end

    subgraph "Fast (Working)"
        WM[Working Memory<br/>Current Turn Context]
        EV[Events<br/>Raw Activity Log]
    end

    subgraph "Persistent (Intelligence)"
        DEC[Decisions<br/>Brain Memory]
        CAL[Calibration<br/>Confidence Learning]
    end

    ID -->|shapes| FACTS
    FACTS --> KL
    KL --> WM
    EV -->|distills into| FACTS
    DEC -->|calibrates| CAL
    KL -->|activates for| DEC
    CAL -->|improves| ID

Loading

Key principle: Each layer learns to exploit the last, then stabilizes and becomes a foundation. Layers become substrates. The slowest-changing layers provide the most continuity.

Memory is stored in PostgreSQL with pgvector across three schemas — brain (decisions, calibration, graph), heart (facts, procedures, episodes, censors, working memory, subtasks, schedules), and nous_system (agents, identity, events, DAGs, dynamic checks, config). Every row is agent_id-scoped so a single database can host many agents.

Growth Model

Nous agents grow through Papert's Principle: the most crucial steps in mental growth are based on acquiring new administrative ways to use what one already knows.

This means:

• Don't add more knowledge when an agent fails — add a better manager
• Build detours, not replacements — intercept existing behavior, don't rip it out
• Friction beats reminders — reduce the steps to do the right thing
• Censors > modifications — when something fails, add a blocker, don't alter the method

graph LR
    subgraph "Growth Levels"
        L1[Level 1<br/>React to input ✅]
        L2[Level 2<br/>Remember past actions ✅]
        L3[Level 3<br/>Learn from outcomes ✅ ← current]
        L4[Level 4<br/>Monitor own thinking 🔄]
        L5[Level 5<br/>Improve own processes 🔄]
    end

    L1 -->|add memory| L2
    L2 -->|add calibration| L3
    L3 -->|add B-brain| L4
    L4 -->|add administrative growth| L5

Loading

Most AI agents operate at Level 1-2. Nous is currently at Level 3 (learning from outcomes via calibration). Levels 4-5 require a fully autonomous B-Brain and administrative growth — Phase 0 of the Critic Agent (F024) is shipped, the rest is planned.

Confidence & Calibration

Nous agents track their confidence and learn from it:

• Every decision records a confidence score (0.0 - 1.0)
• Outcomes are reviewed and compared to predictions
• Brier scores measure calibration accuracy over time
• Agents that say "80% confident" should be right ~80% of the time

A separate write-time calibration scale (F058) shrinks agent-recorded confidence toward observed accuracy — the original factor (0.7627) was derived empirically from a 401-decision audit, but was retired to 1.0 (pass-through) on 2026-09-20 after a refit on 802 resolved decisions showed the overconfidence it corrected had ended; it remains tunable per deployment via NOUS_CONFIDENCE_CALIBRATION_FACTOR. The pre-calibration value is preserved in brain.decisions.confidence_raw.

Fredkin's Paradox: When two options seem equally good, the choice matters least. Stop agonizing at 0.50 confidence — pick one and move. Save deliberation energy for decisions where options are actually different.

Frame-Splitting Protocol (🔄 Planned)

For important decisions, Nous will support parallel cognitive frames via sub-agents. The subtask infrastructure (and now a full DAG orchestrator) is in place; the multi-frame synthesis protocol is the remaining work:

graph TB
    MAIN[Main Agent<br/>Coordination Frame] -->|spawn| DA[Devil's Advocate<br/>Failure Frame]
    MAIN -->|spawn| OPT[Optimist<br/>Opportunity Frame]
    MAIN -->|spawn| HIST[Historian<br/>Pattern Frame]
    DA -->|findings| MAIN
    OPT -->|findings| MAIN
    HIST -->|findings| MAIN
    MAIN -->|synthesize| DEC[Decision]

Loading

Each sub-agent will be locked into a single interpretive frame. The main agent will synthesize their perspectives. This will overcome Minsky's "one frame at a time" limitation through parallel processing. spawn_task and the DAG orchestrator already provide the spawning fabric — what's needed is the frame-locking and synthesis protocol on top.

Relationship to Cognition Engines

Nous applies the same decision intelligence principles proven by Cognition Engines — decisions, deliberation traces, calibration, guardrails, bridge definitions — but is a completely independent implementation.

Same ideas, not same code.

Cognition Engines is a standalone server for any AI agent that needs decision memory. Nous's Brain module is a purpose-built embedded implementation of those principles, optimized for in-process use with zero network overhead.

Cognition Engines  →  proved the ideas work (standalone server, MCP/JSON-RPC)
Nous Brain         →  applies those ideas as an embedded organ (Python library, Postgres)

Both projects evolve independently. The shared asset is the philosophy, not the codebase.

Research Questions

1. How much structure is optimal? Too little and the agent doesn't learn. Too much and it's rigid. Where's the sweet spot?

2. Can administrative growth be automated? Papert's Principle says growth is about better managers. Can an agent bootstrap its own management layer?

3. What's the minimum viable Society? Which Minsky concepts are essential vs nice-to-have? What's the smallest set that produces emergent intelligence?

4. How do frame conflicts resolve? When parallel frames disagree, what's the arbitration mechanism?

5. Does calibration plateau? As decisions accumulate, does calibration continue improving or hit diminishing returns?

6. Can K-lines transfer between agents? If Agent A learns a K-line, can Agent B use it? What's lost in translation?

7. How does Fredkin's Paradox interact with stakes? Low-stakes decisions should resolve fast. High-stakes decisions need more deliberation. What's the mapping?

Configuration

Key environment variables. See the Quickstart Guide and the environment variable reference for the full list — Nous exposes 150+ env vars covering retrieval, calibration, heartbeat, DAGs, and the eval harness.

Retrieval & context quality:

Decision intelligence:

For the full set — heartbeat tuning, DAG timeouts, sleep cycle, eval harness — see the environment variable reference.

Known heartbeat false positives

Findings already diagnosed as recurring false positives can be closed at ingest instead of being triaged again. Put rules in the JSON file at NOUS_HEARTBEAT_KNOWN_FP_PATH (default /tmp/nous-workspace/heartbeat/known_false_positives.json); edits are picked up on the next tick, no restart needed. Start from docs/examples/known_false_positives.example.json. Each rule has:

All match criteria given must hold. Nothing is hidden: auto-closed findings keep state auto_closed_known_fp and their rule id in GET /heartbeat/findings, and stats.auto_closed_by_rule counts them per rule. High-urgency or escalated findings are never auto-closed. A missing file means no rules. A malformed file keeps the last good rules and never stops the heartbeat.

Status

🚀 v1.0.0 — released 2026-09-05 (see CHANGELOG.md).

All core architecture is implemented and running. Recent work focuses on retrieval quality, background reliability, and orchestration.

Core architecture

Retrieval & memory quality

Proactive autonomy & orchestration

See Feature Index for the full breakdown including planned and shelved work.

Stats

Measured against the current main branch:

• ~53,400 lines of production Python (nous/, 129 modules across 12 sub-packages: api, brain, cognitive, dag, handlers, heart, heartbeat, identity, integrations, observability, skills, storage), plus a sibling nous_eval/ retrieval-eval harness
• ~75,900 lines of tests (tests/, 227 files, 2,200+ top-level test functions)
• 25 agent tools registered in the dispatcher: record_decision, learn_fact, recall_deep, recall_recent, learn_skill, get_procedure, create_censor, cache_retrieve, bash, read_file, write_file, web_search, web_fetch, run_python, spawn_task, schedule_task, list_tasks, cancel_task, send_file, store_identity, complete_initiation, heartbeat_check_create, heartbeat_check_manage, dag_create, dag_manage
• 81 REST endpoints (/chat, /decisions, /episodes, /facts, /identity, /heartbeat, /rubric, /dashboard/*, …) + 5 MCP tools (nous_chat, nous_recall, nous_status, nous_teach, nous_decide) + Telegram bot
• 37 PostgreSQL tables across 3 schemas (brain, heart, nous_system) with 38 migrations in sql/migrations/
• Docker deployment: PostgreSQL + pgvector container, Nous agent container, optional Telegram bot container, optional eval-DB container

License

Apache 2.0

Acknowledgments

• Marvin Minsky — Society of Mind (1986) provides the theoretical foundation
• Cognition Engines — proved the decision intelligence principles that Nous applies independently
• Built with curiosity and too much coffee ☕