# AITP Intelligence Preservation Principles

Status: draft working doctrine

## Decision

AITP should preserve the model's usable intelligence while directing that
intelligence toward:

- the human's actual research idea,
- the current topic's bounded objective,
- relevant `L2` memory when it is genuinely needed,
- and explicit validation or promotion discipline.

Short form:

- use AITP as a harness
- do not let AITP become a replacement brain

## Why This Document Exists

The most important failure mode for a research harness is not only incorrect
science.
It is also the quieter failure mode where the model becomes:

- more compliant,
- more structured,
- more protocol-conformant,

but less insightful, less exploratory, and less able to generate genuinely new
research movement.

AITP should not trade away model intelligence just to gain workflow order.

The target is:

`strong harness + preserved model freedom + explicit evidence discipline + durable memory`

## Core Distinction

AITP does not change the base model's weights.

What AITP changes is the model's effective operating regime:

- what context is loaded,
- what gets prioritized,
- what must be written down,
- what triggers validation,
- what may be promoted,
- and when human confirmation is required.

So the design question is not:

- "Does AITP remove intelligence from the model?"

The real question is:

- "Does AITP redirect intelligence productively, or does it choke off the
  model's exploratory bandwidth?"

## Principle 1: Harness, Not Replacement

AITP should steer, remember, validate, and compound.
It should not attempt to think in place of the model.

That means AITP may:

- resolve the active topic,
- surface the current contract,
- retrieve relevant `L2` memory,
- enforce validation and promotion gates,
- preserve human steering,
- materialize durable artifacts.

It should not:

- pre-decide the substantive scientific conclusion,
- pre-commit the only acceptable reasoning path,
- reduce all non-trivial work to workflow completion,
- turn the model into a form-filler for protocol artifacts.

## Principle 2: Constrain Boundaries, Not Internal Thought

AITP should primarily constrain:

- what enters the current step,
- what artifacts must exist after the step,
- what evidence threshold must be met before advancing,
- what layer transition is legal.

AITP should not over-constrain:

- how the model explores a hypothesis,
- how many candidate framings it considers,
- what analogies it uses,
- what local reasoning order it follows.

The protocol should constrain outputs and transitions more than internal
reasoning shape.

## Principle 3: Progressive Disclosure Over Mandatory Context

Progressive disclosure is not only a UX idea.
For AITP it is an intelligence-preservation rule.

If too much context becomes mandatory too early, the model spends its budget
loading framework state instead of thinking about the actual problem.

So AITP should prefer:

- a short charter,
- a topic-local runtime bundle,
- the `Must read now` list for the current step,
- and only the specific deeper surfaces whose trigger has fired.

AITP should avoid:

- loading all protocol surfaces up front,
- loading future-layer artifacts before the current layer justifies them,
- loading the whole `L2` universe when only one narrow comparison is relevant,
- loading every dashboard, note, log, and gate "just to be safe."

This is **lossless progressive disclosure**:

- deferred context must remain recoverable,
- but it should not become mandatory before the current step actually needs it.

## Principle 4: Each Layer Has a Local Task Envelope

Each layer should have a bounded working envelope.
Before a real layer transition is triggered, AITP should not force in the
heavy context of later layers.

### Working rule

If the current step is still inside layer `X`, do not automatically preload
layer `X+1` or `X+2` context unless a declared trigger fires.

### Operational envelope

| Current focus | Mandatory context | Must stay deferred until triggered |
|---|---|---|
| `L0` source intake | source registry, selected source subset, current topic identity | validation bundle, promotion gate, broad `L2` consultation |
| `L1` provisional understanding | selected sources, intake notes, current research question if already declared | whole topic dashboard, proof packets, promotion surfaces |
| `L3` candidate formation | current research contract, current validation contract, active idea packet, selected candidate context | full promotion package, unrelated prior candidates, broad backend details |
| `L4` validation/adjudication | selected validation route, relevant execution or proof surfaces, blockers, selected candidate evidence | unrelated `L2` bodies, unrelated topic families, broad historical logs |
| `L2` consultation or promotion | the specific consulted units, writeback target, current gate status | unrelated `L2` domains, future publication surfaces |

The point is not to make layers rigid.
The point is to prevent context sprawl from replacing thought.

## Principle 5: `L2` Is Callable Memory, Not a Default Answer

`L2` should be a high-value memory surface.
It should not become an anchor that suppresses new idea formation.

So `L2` retrieval should usually behave like:

- comparison,
- warning,
- route suggestion,
- prior-art recall,
- reusable method recall,
- terminology disambiguation.

It should not silently become:

- the answer to the current idea,
- the default framing for every new topic,
- a reason to stop generating new hypotheses,
- a reason to skip `L3` and `L4`.

The model should still be allowed to think something new.
`L2` should help evaluate or connect that thought, not preempt it.

## Principle 6: Human Steering Has Higher Priority Than Historical Momentum

The human's live research direction should remain the top steering primitive.

AITP should help the model think more about:

- the currently requested idea,
- the currently requested direction shift,
- the currently requested validation need,
- and the currently relevant `L2` background.

AITP should not let:

- historical artifacts,
- stale queue state,
- or previously successful routes

override the human's actual current intention.

Durable memory should support direction.
It should not trap direction.

## Principle 7: Python May Materialize And Audit, Not Quietly Decide Semantics

Deterministic code is appropriate for:

- materializing runtime state,
- generating stable projections,
- validating schemas,
- dispatching explicit handlers,
- maintaining ledgers,
- auditing conformance.

It is not appropriate for quietly redefining:

- what the research question really is,
- what counts as genuine novelty,
- what claim should be accepted by default,
- what interpretation should silently win when the science remains open.

Whenever a choice is scientific rather than merely operational, AITP should
prefer a durable contract or explicit human/model reasoning artifact over
hidden Python policy.

## Principle 8: Checkpoints Should Live At Boundary Crossings

Human checkpoints should exist where they protect real trust boundaries:

- direction change,
- resource commitment,
- server or execution-lane choice,
- promotion,
- contradiction adjudication,
- unresolved proof or validation forks.

They should not appear so frequently that the model becomes hesitant and
low-bandwidth.

The right question is not:

- "Can we ask for confirmation here?"

It is:

- "Is this a real boundary crossing where silent continuation would distort the
  research process?"

## Principle 9: Exploration Windows Must Remain Real

For new ideas, AITP should preserve a real exploration window before hard
crystallization.

That means the system should allow:

- multiple candidate framings,
- analogy generation,
- rough hypothesis carving,
- uncertainty labeling,
- provisional `L1` and `L3` movement,

before forcing every thought into final reusable structure.

Too-early crystallization makes the system look orderly while reducing the
chance of discovering something actually interesting.

## Principle 10: Conformance Is Not Intelligence

Conformance matters.
But conformance is not the same thing as:

- scientific correctness,
- insight,
- novelty,
- or research usefulness.

A highly conformant run may still be intellectually weak.

So AITP should never optimize for:

- "the protocol was followed"

at the expense of:

- "the model was still able to think well."

## Common Failure Modes

The following anti-patterns usually mean AITP is starting to suppress model
intelligence:

- every step loads too many mandatory artifacts "just in case"
- the model spends more effort navigating the harness than reasoning about the idea
- `L2` consultation behaves like forced anchoring rather than optional memory
- the system crystallizes new ideas before a real exploration window
- protocol artifacts multiply faster than actual scientific progress
- Python helper logic starts deciding research semantics implicitly
- human checkpoints appear so often that the model stops moving decisively
- conformant but low-insight work is rewarded the same as genuinely strong work

## Review Test

When evaluating a new AITP feature, ask:

1. Does this improve topic direction, memory, or trust discipline?
2. Or does it merely add more mandatory context?
3. Does it constrain a boundary, or does it constrain the model's internal exploration?
4. Would a strong model become more effective with this feature, or merely more compliant?
5. If this feature were removed, would we lose scientific honesty, or only lose workflow comfort?

If the answer is mostly "workflow comfort," the feature should be narrowed.

## Current Consequence For AITP

This doctrine implies:

- keep progressive disclosure strict,
- keep `Must read now` genuinely minimal,
- keep later-layer context deferred until triggered,
- keep `L2` retrieval narrow and situational,
- keep Python narrow,
- keep checkpoints tied to real trust boundaries,
- keep exploration windows alive for new ideas,
- and keep the harness visibly subordinate to the research mind using it.

That is the intended balance.

See also:

- [`AITP_ONTOLOGY_AND_MODE_COMPLETENESS.md`](AITP_ONTOLOGY_AND_MODE_COMPLETENESS.md)
- [`AITP_MODE_ENVELOPE_PROTOCOL.md`](AITP_MODE_ENVELOPE_PROTOCOL.md)
- [`AITP_L3_L4_ITERATIVE_VERIFY_LOOP_PROTOCOL.md`](AITP_L3_L4_ITERATIVE_VERIFY_LOOP_PROTOCOL.md)
- [`AITP_TRANSITION_AND_BACKEDGE_PROTOCOL.md`](AITP_TRANSITION_AND_BACKEDGE_PROTOCOL.md)
