p4vc-core · cognitive cross-section · v3

How the Core thinks.

Foundation Core is the part of the system that remembers everything. The Decision Engine is the part that decides what gets written down. Together they make sure the platform never forgets, never lies, and never lets one tool quietly overwrite another.

← home← organismbrain · you are here

cross-section · 01

Three layers, stacked.

The brain isn't one big machine — it's three layers doing different jobs. At the bottom: one source of truth, one gate, one loop that compounds. In the middle: seven organ systems that handle memory, reasoning, and filtering. At the top: the tools and services that ask the brain to do work. Each layer answers to the one below it.

STRATUM I · NARROWservices · external toolsSTRATUM II · BROADorgan systems · 7 capacitiesGfGcGsmGlrGvGsGtSTRATUM III · gfoundation core+ decision enginewrites ↓

authority flows down · capability flows up

Stratum I · Narrow Abilities

Service arcs + external tools. Submit structural claims to the Decision Engine. Zero authority over the baseline founder record.

CompassFounder intelligenceBreakthroughProcedural learningAstraSignal filtrationPartner EngineRelationship graph
HubSpotStripeGitHubLovablen8nSupabaseResend

Stratum II · Broad Abilities

Multi-modal cognitive capacities, mapped to organ systems.

  • Fluid ReasoningGf

    Cerebrum · Compass · Prefrontal Cortex (human)

    Tree-of-Thoughts / MCTS deep evaluation. Prefrontal cortex reserved for Steve, Jason, Chris. AI assists, humans decide.

  • Crystallized KnowledgeGc

    Core Cognitive State

    Pre-trained network weights, structured knowledge graphs, fine-tuned validation models with domain-specific benchmarks.

  • Short-Term MemoryGsm

    Heart & Blood · Mirror Loop

    Live operational context window. Heart pumps active founder state (SESAC, TAJ, Bowditch, momentum) through all sub-modules.

  • Long-Term StorageGlr

    Intestine · Memory & Evidence Ledger

    Retrieval-augmented generation, vector pools, semantic historical index. Slow-absorption, high-fidelity archival.

  • Sensory FiltrationGv / Ga

    Liver · Astra Polaris

    Multi-modal ingestion pipeline. Strips noise, hallucinations, corrupted tokens before they reach core reasoning.

  • Data HygieneGs

    Kidneys · Waste Filtration

    Background subprocesses for data cleansing. Purges test variables, pulse-exclusions, abandoned logs.

  • Procedural HabituationGt / Gs

    Cerebellum · Breakthrough Program

    Automated execution loops, low-latency workflows. Stabilizes cohort operations; recurring logic becomes low-cost routine.

Stratum III · g

The general factor. Foundation Core + Decision Engine + Compounding Engine. The append-only, single source of truth — and the loop that turns each write into the next decision's evidence. Every write of every stratum lands here, with provenance.

Foundation Core

Brainstem. Identity, state, evidence, memory, provenance, decisions. Append-only. Cryptographic history.

Decision Engine

Inner gate. ±15 calibration, two-operator agreement, HITL authority. Structural rules made teeth.

Compounding Engine

Closed loop. Signal → Evidence → Assessment → Memory → Δ → Intervention → Outcome. Every intervention carries Expected Δ; every outcome records the residual. Calibration is constitutional.

why this exists

Three parts you can't take out.

Most software gets messy because everyone writes to the database however they want, nobody can tell later who changed what, and the system never learns from what it just did. The Core, the Decision Engine, and the Compounding Engine exist to make all three of those impossible.

the memory

Foundation Core

why we need it
Without it: every tool keeps its own copy of the founder, and the copies drift apart. One says the founder is in Series A. Another still says pre-seed. Nobody is wrong, but nobody is right either.
what it actually does
With it: there is one place every tool agrees to read from and write to. Writes never erase — they stack on top of each other, with the time, the author, and the reason attached. You can rewind to any moment and see exactly what the system believed.
why it works
A founder's story is the product. If we lose track of who they are, what they've done, and how they've grown, we have nothing to coach on and nothing to show an investor. The Core is the part that refuses to forget.

the gate

Decision Engine

why we need it
Without it: any tool — Compass, Astra, an integration, a script someone wrote on a Friday — can write whatever it wants into the Core. Bad data lands next to good data. You can't tell them apart later.
what it actually does
With it: every write has to stop at one gate and answer three questions. Where did this come from? Why are you writing it? Does it agree with what we already know? If it can't answer, it doesn't get in.
why it works
This is what makes the platform trustworthy. An AI can be wrong. A human can be tired. An integration can break. The gate doesn't stop mistakes from happening — it stops them from quietly becoming the new truth.

the loop

Compounding Engine

why we need it
Without it: the system remembers everything and decides cleanly — but never learns. Each intervention is a one-off. Expected outcomes never get compared to real ones. The same mistakes get made again, just with better paperwork.
what it actually does
With it: every intervention is logged with an expected change. The outcome is measured against it. The gap — the residual — becomes a calibration score that weights the next decision. Signal → Evidence → Assessment → Memory → Δ → Intervention → Outcome, and around again.
why it works
A founder progresses by becoming more calibrated, not just more active. The loop is what turns motion into progression. Without it, the Core is an archive and the Engine is a bouncer. With it, the system actually gets sharper every turn.

The Core without the Engine is a database anyone can corrupt. The Engine without the Core is a guard standing in front of nothing. The Loop without either is motion without memory. None of the three works alone — that's the point.

cross-section · 02

The gate, in action.

Here's what happens when five different tools try to write to the Core at the same time. Watch the gate: writes that carry their source through. Writes without a source get bounced. The cycle repeats every four seconds.

INCOMING WRITEScompass.appendastra.signalhubspot.event✕ no provenancebreakthrough.†partner.linkDECISION ENGINEFOUNDATION COREappend-only · cited

±15 calibration

Numeric writes must agree with prior state inside the bound.

Two-operator agreement

Structural changes require two independent signatures.

HITL authority

Humans hold the final judgment layer — always.

cross-section · 03

Five rules the system lives by.

These aren't goals or values posted on a wall. They're rules wired into how the Core actually runs. Break one and the system stops — that's the point.

  • principle · 01

    The rules are visible

    Every limit the system enforces — score ranges, who can read what, what counts as proof — is written down where anyone can check it. If you can't see the rule, you can't trust the answer.

  • principle · 02

    Humans make the final call

    The AI does the heavy math: pulling signals together, scoring, summarizing. But when it's time to actually decide something about a founder, a person signs off. The AI never decides alone.

  • principle · 03

    One gate for every write

    No tool gets a shortcut into the Core. Every write — from Compass, from Astra, from a script, from anywhere — goes through the same gate, with the same checks. No exceptions.

  • principle · 04

    Ethics run on every turn

    Honesty, safety, and respect aren't a policy document — they're code that runs on every action. If the check fails, the action stops. The values can't be skipped because they're built in.

  • principle · 05

    Nothing gets erased

    The Core never overwrites. New facts stack on top of old ones, each with a timestamp and an author. You can always see what we used to believe and when that changed.

cross-section · 04

What's next.

Four capabilities that aren't built yet but are already shaped into the design. They sit here as dormant organs — wired in, waiting to wake up.

  • dormant · v3

    Adaptive Immune Memory

    A defense system that learns from attacks. When someone tries to trick the system or break in, every other part hears about it and gets stronger.

  • dormant · v3

    Sleep & Consolidation

    A quiet, off-hours cycle. The system cleans up old data, throws out what's no longer useful, and turns specific memories into general lessons — the same way sleep works for us.

  • dormant · v3

    Self-Awareness

    An internal sense of how the system itself is doing. How fast it's running, what it's close to forgetting, where it's near a limit. The brain knowing its own body.

  • dormant · v3

    Growth Stages

    Explicit phases the system grows through: infant (early testing), adolescent (mostly working), mature (full production). Each stage unlocks more autonomy carefully.

constitutional covenant · project astra

AI assists. Humans decide.
The skeleton is visible.

← return to the organism mapkernel console