Skip to content

Collective Cognition ​

Cortexa's collective cognition layer transforms your vault from a passive memory store into an active thinking system. Three interconnected features work together: background reflection analyzes your thoughts for patterns, cross-user synthesis combines perspectives from Hive peers, and confidence decay ensures stale knowledge gets flagged for review.

All three features are off by default and opt-in via the Settings > Cognition group (Reflection, Confidence, Observability, Social Memory, Procedures, Type Actions).

Background Reflection ​

When enabled, Cortexa periodically analyzes your recent thoughts as a collection — looking for cross-cutting patterns that you might not notice when capturing one thought at a time.

What it produces ​

Each reflection pass generates a type:reflection item containing:

  • Themes: 3-7 recurring topics across your recent thoughts, with the specific item IDs involved.
  • Contradictions: Pairs of thoughts that conflict with each other.
  • Patterns: What you're spending the most cognitive energy on.
  • Gaps: Unanswered questions and adjacent topics worth exploring.
  • Connections: Thoughts that should be linked but aren't.
  • Narrative: A 2-3 paragraph synthesis of what your recent thoughts collectively reveal.

Configuration ​

In Settings > Cognition > Reflection:

SettingDefaultDescription
EnabledOffToggle background reflection on/off
Interval (hours)6How often to run a reflection pass
Recent items30How many recent items to include in each pass

Click Run now to trigger a reflection immediately without waiting for the next scheduled interval.

How it works ​

  1. The scheduler checks every 60 seconds whether it's time for a reflection.
  2. It loads the most recent N items captured since the last reflection.
  3. For each item, it reads the content, summary, and thesis core (if available).
  4. Everything is sent to your configured LLM with a structured analysis prompt.
  5. The LLM response is parsed for themes, contradictions, patterns, etc.
  6. The output is stored as a new thought tagged type:reflection and auto:reflection.
  7. If confidence scoring is enabled, the decay calculation runs during this pass.

Reflection items appear in your normal feed and are searchable. They participate in the knowledge graph just like any other thought.

Cross-User Thesis Synthesis ​

When you share thoughts with peers through Hive, each person develops their own thesis on a topic. Cross-user synthesis automatically combines these perspectives when related theses arrive from peers.

How it works ​

  1. You import a thought from a Hive peer that includes thesis data.
  2. Cortexa embeds the peer's content and searches your local vault for similar thoughts that also have theses.
  3. If a strong match is found, an LLM synthesizes both perspectives into a cross-synthesis.
  4. The output includes: agreements, disagreements, novel combinations, and a unified synthesis.
  5. The result is stored as a type:cross-synthesis item with links to both source thoughts.

Configuration ​

Cross-user synthesis is controlled by a single toggle in Settings > Cognition > Reflection:

SettingDefaultDescription
Cross-user thesis synthesisOffEnable automatic synthesis when importing peer theses

This feature requires both reflection to be enabled and at least one Hive connection with auto-import active.

Memory Confidence & Decay ​

Knowledge gets stale. A decision you made 6 months ago might no longer apply. Confidence scoring adds a numerical quality signal to every thought that naturally decays over time, flagging old, unreviewed knowledge for attention.

How scoring works ​

Every thought gets an initial confidence score based on its source:

SourceInitial Score
Manual capture0.80
MCP / API / CLI0.70
Hive shared0.60
Telegram0.50

How decay works ​

Each week, every thought's confidence decays by a configurable rate:

new_score = current_score × (decay_rate ^ weeks_since_last_validated)

With the default rate of 95% per week:

  • After 5 weeks: ~77% of original score
  • After 10 weeks: ~60% of original score
  • After ~23 weeks: approaches the stale threshold

Stale tagging ​

Thoughts that fall below the stale threshold (default 30%) are automatically tagged confidence:stale. You can filter by this tag to review aging knowledge. Items above the threshold have the tag removed automatically.

Resetting decay ​

User interactions that show engagement with a thought reset the decay clock:

  • Pinning a thought resets last_validated_at to now.

This means thoughts you actively reference stay confident, while forgotten ones naturally age.

Contradiction penalties ​

When the reflection pass detects contradicting thoughts, both items receive a confidence penalty (default 20% reduction). This surfaces conflicting knowledge faster.

Configuration ​

In Settings > Cognition > Confidence:

SettingDefaultDescription
EnabledOffToggle confidence scoring on/off
Decay rate (per week)95%Higher = slower decay
Stale threshold30%Items below this are tagged confidence:stale
Contradiction penalty20%Score reduction when contradictions are found

Visual indicators ​

When confidence is enabled, item cards show a colored badge:

  • confident (green): score >= 70%
  • aging (yellow): score 40-70%
  • stale (red): score < 40%

How the three features interact ​

The three features form a reinforcing loop:

  1. You capture thoughts throughout the week.
  2. Reflection runs every N hours, analyzing patterns and detecting contradictions.
  3. Confidence decay runs during each reflection pass, aging unreviewed knowledge.
  4. When a Hive peer shares a thought with a thesis, cross-synthesis finds your related thoughts and produces a combined view.
  5. The synthesis and reflection outputs are themselves thoughts — they get embedded, searched, and eventually reflected upon in future passes.

Over time, your vault develops a meta-layer of self-awareness: it knows what themes dominate your thinking, where your knowledge conflicts, what's getting stale, and how your perspectives compare to your peers.

Tool Observability ​

Every LLM call, embedding operation, and orchestration step is logged to a persistent tool_invocations table. This gives you visibility into what Cortexa is doing behind the scenes.

What it tracks ​

  • Tool name and category (llm, embed, search, tts)
  • Success/failure status
  • Duration in milliseconds
  • Token usage (for LLM calls)
  • Associated item and job IDs

Configuration ​

In Settings > Cognition > Observability:

SettingDefaultDescription
EnabledOffToggle tool invocation logging
Retention (days)30Auto-purge invocations older than this

Social Memory ​

When you connect to Hive peers, Cortexa tracks their expertise and contribution patterns over time.

What it tracks ​

Per-peer profiles auto-update on every import:

  • Item count — how many thoughts this peer has shared
  • Thesis count — how many of their shares included thesis analysis
  • Average thesis confidence — quality signal for their contributions
  • Trust score — synthesized credibility (starts at 0.5, increases with quality contributions)

Configuration ​

In Settings > Cognition > Social Memory:

SettingDefaultDescription
EnabledOffToggle peer tracking
Track expertiseOffDerive expertise from thesis quality
Initial trust score50%Starting trust for new peers

Procedural Memory ​

Cortexa learns from how the orchestration engine solves problems. Every orchestrator execution logs its tool sequence and outcome. Over time, successful patterns emerge.

How it works ​

  1. The orchestrator runs a tool sequence for a thought (e.g., decompose → challenge_claims → synthesize_brief).
  2. The sequence and outcome are logged to procedure_log.
  3. Patterns that repeat successfully are promoted to learned_procedures with confidence scores.
  4. When "suggest procedures" is enabled, the orchestrator is given these patterns as hints for future planning.

Configuration ​

In Settings > Cognition > Procedures:

SettingDefaultDescription
EnabledOffToggle procedural memory
Suggest proceduresOffFeed learned patterns to the orchestrator
Min executions to learn3How many times a pattern must succeed before it's learned

Thought Type Actions ​

Configure which auto-actions run when agent captures create items of each thought type. This lets you customize the pipeline per type — for example, always run Deep Think on architecture decisions, but only summarize notes.

Configuration ​

In Settings > Cognition > Type Actions:

Each of the 8 thought types (decision, discovery, architecture, debug, pattern, question, todo, note) has 4 toggle chips:

  • Summarize — auto-generate a summary
  • Deep Think — run the full thesis pipeline
  • Research — trigger web + vault research
  • Brief — generate an audio briefing

Defaults ​

TypeSummarizeDeep ThinkResearchBrief
decisionYesNoNoNo
discoveryYesNoNoNo
architectureYesNoNoNo
debugYesNoNoNo
patternYesNoNoNo
questionNoNoYesNo
todoNoNoNoNo
noteNoNoNoNo

Memory Governance (Search Boosting) ​

The cognition stack feeds back into search ranking. When confidence scoring is enabled, FTS search results are boosted by confidence:

boosted_score = raw_bm25_score × (0.7 + 0.3 × confidence_score)

This means high-confidence items (recently validated, well-researched theses) rank higher than stale or low-confidence items for the same query. The effect is subtle but compounds — your best knowledge surfaces first.

The Full Picture ​

All 7 layers form an interconnected system:

  Capture → Embed → Store
       ↓
  Reflection → finds themes, contradictions, patterns
       ↓
  Confidence → decays stale items, boosts well-researched
       ↓
  Cross-Synthesis → merges peer perspectives
       ↓
  Observability → tracks what works
       ↓
  Procedural Memory → learns successful workflows
       ↓
  Social Memory → tracks peer expertise
       ↓
  Memory Governance → search ranking reflects all signals
       ↓
  Agents get the best context automatically

Over time, your vault develops a meta-layer of self-awareness: it knows what themes dominate your thinking, where your knowledge conflicts, what's getting stale, how your perspectives compare to your peers, and which analysis approaches work best for different types of problems.

Built with Rust, Tauri, and a lot of captured thoughts.