brCausalGraphRAG¶
Methodology → decision-grade memory
brCausalGraphRAG: active memory with identity, enforced by constraints.
CausalGraphRAG is the idea: retrieve mechanistic paths instead of text chunks. brCausalGraphRAG is the discipline: provenance-first primitives, enforceable constraint gates, trace objects, typed identity, and versioned memory writes — with deterministic abstention.
What we add on top of CausalGraphRAG¶
Provenance-first primitives
Claims are objects with source, version, scope, and extraction method. Evidence is never “just text”.
Constraint validation
Policy and safety rules are enforced in a gate the model cannot negotiate.
Trace objects
Reasoning produces machine-verifiable artifacts you can replay, diff, and audit.
Abstention & escalation
When there is no valid path or a rule fails, the system refuses and explains why.
Typed identity & permissions
Identity is explicit: roles, scopes, and allowed actions are modeled and checked. The same question can yield different valid behavior per identity.
Versioned memory writes
Updates become first-class events: what changed, why it changed, and which evidence justified the update — so the memory can evolve safely.
Why we call this a mental model for “AI consciousness” (without metaphysics)¶
Operational framing: “consciousness” here means persistent identity + active memory + governed action selection.
Not feelings. Not personhood. A system-level model that makes behavior legible and controllable.
Identity
A stable handle: what goals, roles, permissions, and safety posture apply to this agent instance.
Active memory
Memory is not a chat log; it’s a graph of validated claims and causal relations, versioned over time.
Self-monitoring via traces
The system can inspect what it did, why it did it, and which rules were applied.
Boundaries
Constraints define “what cannot happen”, making abstention a first-class outcome.
Continuity over time
Identity + versioned memory create continuity: the system can explain what it believed before, what changed, and what it believes now.
Action selection is governed
“Agency” is not improvisation. Actions are selected through constraints, permissions, and traceable justification — or blocked deterministically.
Advantages of a brModel-based system¶
Stable primitives
Reality is stored as durable objects (subjects, objects, processes, relations, sources), not as prompt-shaped text. That survives model churn.
Provenance-first evidence
Claims are tied to sources, versions, scope, and extraction. “Grounding” becomes inspectable evidence, not a rhetorical style.
Enforceable constraints
Safety and policy live outside the model. Invalid assertions and forbidden actions are rejected by gates — not politely discouraged by prompts.
Trace as a product artifact
Every decision yields a machine-verifiable trace: path, evidence, rules applied, and outcome. That’s what you can audit and replay.
Deterministic abstention
When the graph has no valid path, “unknown” is the correct output. The system refuses with reasons and a falsification plan.
Reduced complexity
Complex domains compress into a finite set of causal relation types over a small set of primitives, making governance and evaluation tractable.
Safer evolution
Updates are versioned events with provenance. You can diff memory, roll back, and test changes before they affect decisions.
Identity-aware behavior
The same system can act differently by role and scope — because identity is modeled and enforced, not assumed in a hidden system prompt.
Future-proof architecture
As LLMs improve, the gates and memory remain. The stack scales with capability without losing controllability, audit, or safety posture.
Diagram: decision-grade traversal¶
flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;
I_Q(["❓ Question / task"]):::i
P_S("🎯 Select start nodes"):::p
P_Search("🧭 Constrained path search"):::p
P_Val("🔒 Validate shapes + constraints"):::p
D_OK{"✅ Allowed and supported?"}:::s
R_T(["🧾 Trace object (evidence + provenance + rules)"]):::r
O_A(["✅ Answer with evidence (or execute)"]):::o
S_X(["🛑 Abstain / escalate (violation or missing path)"]):::i
I_Q --> P_S --> P_Search --> P_Val --> D_OK
D_OK -->|"Yes"| R_T --> O_A
D_OK -->|"No"| S_X
%% Clickable nodes
click P_Val "/methodology/constraints/" "Constraints & SHACL"
click R_T "/reasoners/governance/" "Governance"What happens here: the system turns a ❓ question into a 🧭 constrained path search, runs a 🔒 validation gate, then either emits a 🧾 trace object and a ✅ decision-grade answer or 🛑 abstains/escalates with a reason.
Diagram: identity + active memory loop¶
flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;
I_ID(["🪪 Identity (role + permissions + goals)"]):::i
I_Q(["❓ Question / task"]):::i
P_TRV("🕸️ Traverse causal memory"):::p
P_G("🔒 Constraint gate"):::p
D_Allow{"✅ Allowed?"}:::s
O_ACT(["✅ Act / answer"]):::o
S_ABS(["🛑 Abstain + explain"]):::i
R_W(["🧾 Write trace + versioned memory update"]):::r
I_ID --> I_Q --> P_TRV --> P_G --> D_Allow
D_Allow -->|"Yes"| O_ACT --> R_W
D_Allow -->|"No"| S_ABS --> R_W
R_W --> I_ID
R_W --> P_TRV
%% Clickable nodes
click P_G "/methodology/constraints/" "Constraints & SHACL"
click R_W "/methodology/core-primitives/" "Core primitives"
click P_TRV "/methodology/causalgraphrag/" "CausalGraphRAG"Mechanism: 🪪 identity shapes what is allowed, 🕸️ traversal proposes an action, the 🔒 gate decides, and the system always writes a 🧾 trace + memory update so behavior stays explainable over time.
Diagram: trace object (what gets stored)¶
flowchart TB
%% Styles (brModel Standard)
classDef i fill:#D3D3D3,stroke-width:0px,color:#000;
classDef p fill:#B3D9FF,stroke-width:0px,color:#000;
classDef r fill:#FFFFB3,stroke-width:0px,color:#000;
classDef o fill:#C1F0C1,stroke-width:0px,color:#000;
classDef s fill:#FFB3B3,stroke-width:0px,color:#000;
I_Trigger(["❓ Trigger: question or proposed action"]):::i
R_Meta(["🧾 Trace header: identity, timestamp, scope"]):::r
P_Path("🧭 Select path"):::p
R_Path(["Path artifact: nodes, edges, direction"]):::r
P_Ev("📎 Collect evidence"):::p
R_Ev(["Evidence set: citations, versions, extraction"]):::r
P_Rules("🔒 Evaluate rules"):::p
R_Rules(["Rules applied: constraints, permissions, thresholds"]):::r
D_Out{"✅ Allowed and supported?"}:::s
O_Ans(["✅ Output or execute"]):::o
S_Abs(["🛑 Abstain or escalate"]):::i
P_Write("✍️ Propose memory writes"):::p
R_Writes(["Write-set: claims, edges, deltas, justification"]):::r
D_Store{"✅ Store and replay?"}:::s
O_Audit(["✅ Audit-ready trace package (replayable)"]):::o
S_Skip(["🛑 Do not store (policy or privacy)"]):::i
I_Trigger --> R_Meta --> P_Path --> R_Path --> P_Ev --> R_Ev --> P_Rules --> R_Rules --> D_Out
D_Out -->|"Yes"| O_Ans --> P_Write --> R_Writes --> D_Store
D_Out -->|"No"| S_Abs --> P_Write
D_Store -->|"Yes"| O_Audit
D_Store -->|"No"| S_Skip
%% Clickable nodes
click P_Rules "/methodology/constraints/" "Constraints & SHACL"
click P_Path "/methodology/causalgraphrag/" "CausalGraphRAG"
click R_Ev "/methodology/core-primitives/" "Core primitives"Stored artifact: a 🧾 trace package that ties together 🧭 the path, 📎 evidence versions, 🔒 rules evaluated, the ✅ allowed vs 🛑 abstain decision, and the ✍️ exact memory writes (so you can replay, diff, and audit).
Why this is different from “better prompts”¶
- Prompting is a social contract: editable, bypassable, and difficult to prove.
- Constraints are an enforcement mechanism: deterministic, testable, and auditable.
- Traces make debugging and governance concrete: you can inspect the artifact, not the vibe.