Cognitive Substrate

io.github.JaysonAIOnlinePublished by GitHub account JaysonAIOnlinev1.0.1Updated Oct 27, 2026

28-layer cognitive substrate with cross-session ToT evolutionary memory and self-telemetry tools

VerifiedSTDIODesktop onlyKnowledge & MemoryAI & ML

Overview

AI-generated overview

A local Python MCP server that runs prompts through a 28-layer reasoning substrate and keeps cross-session Tree-of-Thoughts memory in SQLite.

What you can do
  • Validate prompts and branches through a 28-layer, 6-family cognitive substrate and get a pruning verdict
  • Run seven reasoning paradigms (deductive, inductive, abductive, analogical, causal, syllogistic, falsification) and produce reasoning plans
  • Store, recall and prune Tree-of-Thoughts memory across sessions, including 5-key telemetry and lessons from pruned branches
  • Inspect session telemetry: active paths and pruned branches via the cognitive tree state tool
  • Extract and parse JSON from messy text with a stack-based parser
  • List, discover, call and orchestrate peer agents over A2A
When to use it
Worth adding when you want an assistant to structure its reasoning through an explicit layered checklist and to carry lessons from failed approaches into later sessions. It suits experimentation with reasoning scaffolds and agent-to-agent calls rather than everyday data or file tasks.
Requirements
Runs as a local stdio process installed with pip (mcp-cognitive-substrate) and started with the cognitive-substrate command. Requires Python 3.11 or newer. No accounts, API keys, environment variables or headers are declared. Memory is stored locally in SQLite.
Before you install
The substrate verdicts are described as heuristic, so treat them as scaffolding rather than authoritative judgments. Memory and telemetry are written to a local SQLite store across sessions, so reasoning content persists on disk. The A2A tools can call and orchestrate peer agents, which may send data to those peers.

Installation

In SourceWeft

  1. Open Cognitive Substrate in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

mcp-cognitive-substrate

mcp-name: io.github.JaysonAIOnline/cognitive-substrate

A 28-layer cognitive substrate with cross-session Tree-of-Thoughts (ToT) evolutionary memory, conditional self-telemetry, and A2A tools for MCP agents.

Lets agents reason through a validated 28-layer substrate, evolve memory across sessions, and communicate with peer agents — all in one pip-installable package.

Features

  • 28-layer cognitive substrate with Pydantic validation — CognitiveSubstrate validates reasoning through 6 families / 28 layers.
  • Cross-session ToT evolutionary memory — SQLite-backed tree-of-thoughts nodes + substrate history; pruned branches become lessons for future sessions.
  • Robust stack-based JSON parser — no regex; handles nested brackets, escaped strings, embedded code fences (robust_slice / robust_json_slice).
  • Self-telemetry tool — get_cognitive_tree_state returns active paths and pruned branches for a session.
  • Post-execution storage loop — store_5key_telemetry auto-saves compact 5-key telemetry (foundations, metacognition, defensive, resource, utility).
  • 7 reasoning paradigms — deductive, inductive, abductive, analogical, causal, syllogistic, falsification.
  • A2A tools — list, discover, call, and orchestrate peer agents.
  • MCP server — exposes everything as tools via the cognitive-substrate CLI.

Install

bash
pip install mcp-cognitive-substrate

Or install from source:

bash
git clone https://github.com/JaysonAIOnline/mcp-cognitive-substrate.gitcd mcp-cognitive-substratepip install -e .[test]

Requires Python >= 3.11.

Quick Start

python
from mcp_cognitive_substrate.substrate import CognitiveSubstratefrom mcp_cognitive_substrate.memory import get_cognitive_tree_state, store_5key_telemetry
substrate = CognitiveSubstrate()response = substrate.run("Your user prompt here")print(response["layers_applied"], "layers applied")print(response["substrate_verdict"])

Usage

28-layer substrate

python
from mcp_cognitive_substrate import substrate
# Layer count and schemaprint(substrate.layer_count())        # 28print(substrate.SUBSTRATE_SCHEMA)     # the full 6-family schema
# Validate a prompt through the substrateresult = substrate.CognitiveSubstrate(session_id="s1").run("deploy safely")print(result["substrate_verdict"])    # heuristic pruning verdict
# Run a single paradigmfrom mcp_cognitive_substrate import run_paradigmprint(run_paradigm("14_idempotency_side_effect_audit", {"evaluate_branch": True}))

Cross-session ToT evolutionary memory

python
from mcp_cognitive_substrate.memory import (    store_5key_telemetry,    get_cognitive_tree_state,    prune_failed_approach,)
node_id = store_5key_telemetry(    session_id="session-a",    payload={        "foundations": {"premise_validation": "assuming deps", "state_hash": "h", "falsification_notes": "deps missing"},        "defensive": {"blast_radius": "unpredictable", "is_idempotent": True, "invariant_rule": "r"},        "resource": {"big_o": "o(n)", "latency_bottleneck": "none"},        "utility": {"load_summary": "pin versions to deploy", "checklist_verified": True},        "metacognition": {"self_critique": "c", "drift_pct": 0.1},    },    score_delta=-110.0,)prune_failed_approach(node_id)state = get_cognitive_tree_state("session-a", include_pruned=True)print(state["active_path_count"], state["pruned_branch_count"])

Stack-based JSON parser

python
from mcp_cognitive_substrate.memory import robust_slice, robust_json_slice
cleaned, payload = robust_slice('prefix {"a": {"b": [1, 2]}, "c": "x"} suffix')# payload == {"a": {"b": [1, 2]}, "c": "x"}; cleaned == "prefix suffix"

7 reasoning paradigms + A2A

python
from mcp_cognitive_substrate import reason, a2a_list, a2a_call, a2a_orchestrate
print(reason("Solve X", reasoning_type="abductive", depth=3)["steps"])print(a2a_list())print(a2a_call("peer-agent", "hello"))print(a2a_orchestrate("hi", capability="memory"))

As an MCP server

bash
cognitive-substrate          # starts stdio MCP servercognitive-substrate --info   # prints package summary

All of the above — substrate paradigms, extraction/evaluation, memory store/recall, ToT lessons, tree-state telemetry, JSON parsing, reasoning plans, and A2A — are exposed as MCP tools.

Testing

bash
pip install -e .[test]python -m pytest src/tests -q     # 16 tests

License

MIT

Source: README.md at commit 064d125

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v1.0.1LatestSep 16, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts