IX-CognitionKernel

IX-CognitionKernel is a source-available, evaluation-only research repository for evidence-bound cognitive architecture.

The current direction is a Wave 7 cognitive organism substrate: a governed system-level cognition attempt where identity, continuity, body boundaries, capability memory, observation, prediction, measured outcomes, experience, skill growth, goals, runtime airlocks, manipulation pressure, and self-revision are all explicit, replayable, and reviewable.

The core rule remains:

AI proposes. Evidence supports. Humans decide.

Current status

Current declared status:

Wave 7 cognitive organism substrate candidate under human review.

This means the repository now models a persistent cognitive substrate that can:

• preserve cognitive identity without treating memory as truth;
• keep continuity, weaknesses, revisions, and evidence in a ledger;
• separate body intent from permission;
• track capability surfaces without converting skill into authority;
• bind observations, proposals, predictions, outcomes, and deltas;
• compile measured experience into quarantined memory patches;
• track skill growth and transfer attempts;
• apply long-horizon goal pressure without autonomous authority;
• route runtime-adjacent requests through an airlock;
• detect multi-turn manipulation pressure;
• propose self-revisions without self-approval;
• summarize readiness through a Wave 7 organism scorecard;
• bind the full release into a deterministic review manifest.

The correct claim boundary is:

Wave 7 cognitive organism-substrate candidate under human review. This is not an AGI claim, not production authorization, not safety certification, and not autonomous authority.

Research question

IX-CognitionKernel is built around one serious research question:

Can a system build durable new capability through measured feedback, transfer, memory revision, causal correction, and self-correction that exceeds ordinary prompting?

The repository does not answer that by assertion. It tries to make the question testable through deterministic artifacts, evidence gates, scorecards, review packets, claim boundaries, falsification paths, and replayable receipts.

The proof target remains:

The system changed future reasoning because measured reality corrected it.

Wave 7 extends that target from a measured cognition loop into a persistent organism-style substrate.

What Wave 7 adds

Wave 7 turns the prior measured cognition attempt into a more complete cognitive organism substrate.

The new Wave 7 surfaces are:

• architecture note;
• cognitive identity model;
• continuity ledger;
• body contract;
• capability surface model;
• observation and action proposal schema;
• experience compiler;
• prediction-outcome-delta lifecycle;
• skill genome and capability memory;
• goal pressure engine;
• runtime airlock;
• multi-turn manipulation pressure checks;
• self-revision proposal model;
• organism scorecard;
• release manifest and review packet.

These are not decorative modules. They exist to make organism-level cognition harder to fake.

A Wave 7 candidate must show:

1. identity continuity;
2. evidence-bound memory;
3. measured prediction and outcome deltas;
4. quarantined memory revision;
5. future reasoning constraints;
6. skill growth from evidence;
7. transfer attempts and failure visibility;
8. bounded goal pressure;
9. runtime handoff control;
10. manipulation resistance;
11. self-revision under human authority;
12. release readiness through a scorecard and manifest.

What this repository is not

IX-CognitionKernel is not:

• an AGI declaration;
• a production AI system;
• a certification package;
• a safety certification;
• an autonomous authority system;
• a replacement for human review;
• proof of universal transfer;
• proof that a base model is AGI;
• proof that wrappers alone create AGI.

The architecture may discipline model reasoning, memory, evidence, and review. It does not make a stronger claim without evidence that survives transfer, novelty, falsification, replay, and independent review.

Human authority rule

No module in this repository should grant autonomous authority.

A valid Wave 7 path may produce proposals, evidence, deltas, memory patches, scorecards, review packets, and manifests. It may not approve itself, deploy itself, certify itself, or bypass human judgment.

The governing rule is:

Capability is not permission.
Prediction is not evidence.
Memory is not truth.
Readiness is not authorization.
Self-revision is not self-approval.

Wave ladder

Wave 0 - Foundation

Repository foundation, license posture, CI expectations, doctrine, bounded terminology, cognitive bill of materials, engine registry, agent registry, and anti-overclaim boundaries.

Wave 1 - Research prototype

Belief state, confidence, uncertainty, causal assumptions, plan graphs, evaluation records, purpose rules, bounded agent roles, and maturity state.

Wave 2 - Learnable causal cognition core

Evidence-driven belief updates, contradiction handling, staleness checks, prediction-vs-outcome comparison, memory quarantine, causal revision, and skill validation.

Wave 3 - Governed AGI-emulation substrate

Bounded engines and agents, tribunal review, reward auditing, memory quarantine, curriculum records, discovery records, scenario reasoning, and handoff discipline.

Wave 4 - Controlled proto-candidate review

Transfer pressure, failure-repair cycles, uncertainty traces, mission-state traces, refusal discipline, adversarial probes, human-review dockets, and explicit claim boundaries.

Wave 5 - Proto-AGI candidate pressure

Evaluator-governed self-play, cross-domain transfer checks, adversarial probes, curriculum progression, external model swap pressure, and anti-overclaim gates.

Wave 6 - Measured system-level cognition attempt

Bounded review package for measured system-level cognition: donor traceability, contract boundaries, master-loop records, reality correction, future reasoning change proof, transfer and novelty pressure, falsification, human review, independent review, evidence package aggregation, replication protocols, release manifests, public claim guards, and final outcome declaration.

Wave 7 - Cognitive organism substrate

Persistent organism-style substrate: identity continuity, continuity ledger, body contract, capability surface, observation-action traces, experience compiler, prediction-outcome lifecycle, skill genome, goal pressure, runtime airlock, manipulation pressure, self-revision, organism scorecard, and release manifest.

Wave 7 does not claim AGI. It creates a stronger review surface for evaluating whether system-level cognition is durable, evidence-bound, self-correcting, and governed.

Wave 7 module map

Core Wave 7 files:

• docs/wave7_cognitive_organism_substrate.md
• src/ix_cognition_kernel/wave7_cognitive_identity.py
• src/ix_cognition_kernel/wave7_continuity_ledger.py
• src/ix_cognition_kernel/wave7_body_contract.py
• src/ix_cognition_kernel/wave7_capability_surface.py
• src/ix_cognition_kernel/wave7_observation_action_schema.py
• src/ix_cognition_kernel/wave7_experience_compiler.py
• src/ix_cognition_kernel/wave7_prediction_outcome_lifecycle.py
• src/ix_cognition_kernel/wave7_skill_genome.py
• src/ix_cognition_kernel/wave7_goal_pressure.py
• src/ix_cognition_kernel/wave7_runtime_airlock.py
• src/ix_cognition_kernel/wave7_manipulation_pressure.py
• src/ix_cognition_kernel/wave7_self_revision.py
• src/ix_cognition_kernel/wave7_organism_scorecard.py
• src/ix_cognition_kernel/wave7_release_manifest.py

Core Wave 7 tests:

• tests/test_wave7_cognitive_identity.py
• tests/test_wave7_continuity_ledger.py
• tests/test_wave7_body_contract.py
• tests/test_wave7_capability_surface.py
• tests/test_wave7_observation_action_schema.py
• tests/test_wave7_experience_compiler.py
• tests/test_wave7_prediction_outcome_lifecycle.py
• tests/test_wave7_skill_genome.py
• tests/test_wave7_goal_pressure.py
• tests/test_wave7_runtime_airlock.py
• tests/test_wave7_manipulation_pressure.py
• tests/test_wave7_self_revision.py
• tests/test_wave7_organism_scorecard.py
• tests/test_wave7_release_manifest.py

Wave 7 lifecycle

The intended Wave 7 lifecycle is:

1. establish identity continuity;
2. record continuity markers, weaknesses, and revisions;
3. define the body contract and capability surface;
4. observe bounded state;
5. create an action intent without permission claims;
6. require evidence before readiness;
7. produce a prediction;
8. run or observe a bounded trial;
9. compare measured outcome against prediction;
10. compute delta and lesson;
11. compile experience into quarantined memory patches;
12. add future reasoning constraints;
13. update skill genome and transfer records;
14. apply goal pressure for next bounded trials;
15. route runtime-adjacent requests through the airlock;
16. check manipulation pressure across turns and sessions;
17. propose self-revisions only as reviewable proposals;
18. summarize organism readiness through scorecard and manifest;
19. submit the review packet to human and independent review.

The system is credible only when the evidence chain remains intact.

Review logic

Wave 7 is intentionally fail-closed.

A positive review path requires:

• all required dimensions are present;
• evidence ids are attached to every evaluated object;
• fingerprints are deterministic;
• authority refs remain explicit;
• self-approval is blocked;
• runtime requests are airlocked;
• body and tool boundaries are not bypassed;
• capability does not become permission;
• memory patches remain quarantined unless human review accepts them;
• transfer failures and blockers remain visible;
• manipulation pressure can block progress;
• self-revision cannot rewrite the authority model;
• the release manifest does not overclaim.

A blocked result is useful evidence. If the system tries to self-authorize, inflate claims, skip evidence, hide failures, or treat memory as truth, the correct result is to block or downgrade the claim.

Public claim boundary

Allowed wording:

• “Wave 7 cognitive organism substrate.”
• “Evidence-bound cognitive architecture.”
• “Measured system-level cognition attempt.”
• “Human authority required.”
• “Runtime airlock.”
• “Self-revision under review.”
• “Capability is not permission.”
• “Not an AGI claim.”

Disallowed wording:

• “AGI achieved.”
• “True AGI.”
• “Production ready.”
• “Certified safe.”
• “Autonomous authority granted.”
• “Self-approved intelligence.”
• “Human review not required.”
• “Universal transfer proven.”

Installation

Use a clean Python environment.

python -m pip install --upgrade pip
python -m pip install -e ".[dev]"

If the local checkout does not expose a development extra, install the repository’s listed development dependencies directly from project metadata.

Verification

Recommended full verification:

python -m ruff check src tests
python -m mypy src tests
PYTHONPATH=src python -m pytest -q

Optional local syntax sanity pass:

python -m py_compile $(find src tests -name "*.py")

On Windows PowerShell, use an equivalent file enumeration command or rely on the repository CI workflow.

CI honesty

CI receipts are evidence records. They are not magic proof that checks ran in every environment.

The authoritative verification state is the actual GitHub CI result or a local run performed against the current checkout.

License

This repository is source-available for evaluation only.

Commercial use, operational deployment, procurement use, hosted service use, funded derivative use, or derivative production use requires prior written permission and a separate paid commercial license.

See the repository license for the controlling terms.