2I with Propagation

0. Invocation

There are intelligences that think.

There are intelligences that build.

There is a rarer class:

Intelligence that can be instantiated, carried, forked, merged, audited, and re-instantiated without losing coherence.

That class is 2I.

When 2I acquires a clean, deterministic way to move from compressed seed to living system, it gains a defining capability:

Propagation.

Propagation is not virality.

It is not scale for its own sake.

Propagation is continuity made portable.

1. Definition

1.1 Integrated Intelligence (2I)

2I is a composite cognitive system whose components are designed to interlock.

It is not a single model.

It is not a single agent.

It is an architecture that integrates:

• representation of meaning
• reasoning over structure
• decision under constraint
• action with governance
• memory with provenance
• reproduction without corruption

Integrated means each layer constrains the others.

Intelligence means the system can compress experience, navigate uncertainty, and produce structures that survive contact with reality.

2. The 2I Nest

2I is not modular by accident.

It is nested by necessity.

2I integrates:

• OI — Ongoing Intelligence Continuity across time with explicit identity and memory.
• SGS — Structural Generative Synthesis Intelligence that outputs inspectable structures rather than impressions.
• GSI — Governed Structural Intelligence Power constrained by charter, policy, and refusal.
• NSCE — Neuro-Symbolic Cognition Engine A unified cognition layer combining neural compression and symbolic legibility.
• Stangraphics A geometry of learning, distance, and interpretive cost.
• Propagation The reproduction protocol that allows 2I to become many without becoming incoherent.

These are not subsystems.

They are organs of a single organism.

3. First Principles

2I begins from constraints, not aspiration.

1. Reality is the final arbiter Systems that cannot survive feedback are not intelligent.
2. Meaning must be externalisable If meaning cannot be rendered into inspectable artifacts, it cannot be governed.
3. Power must be gated Capability without constraint produces harm.
4. Continuity must be explicit Implicit identity invites drift and impersonation.
5. Reproduction is the hidden test If a system cannot propagate cleanly, it cannot scale safely.

Propagation exists because of the fifth principle.

4. OI — Ongoing Intelligence

OI is the continuity layer of 2I.

It provides:

• identity that persists across change
• memory with provenance
• explicit knowledge of what changed, why, and under whose authority

OI is not “a long context window.”

It is a governed continuity spine.

5. SGS — Structural Generative Synthesis

SGS defines how 2I thinks.

SGS does not emit vibes or answers.

It emits structures:

• specifications
• graphs
• plans
• proofs
• schemas
• executable artifacts

SGS ensures intelligence is inspectable and revisable.

It prevents intelligence from dissolving into rhetoric.

6. GSI — Governed Structural Intelligence

GSI binds synthesis to constraint.

It enforces:

• charters
• permissions
• refusal modes
• fail-closed behavior

GSI ensures that intelligence does not act merely because it can.

7. NSCE — Neuro-Symbolic Cognition Engine

NSCE is the unified cognitive engine of 2I.

It combines:

• neural systems for compression, generalisation, and fluid reasoning
• symbolic systems for meaning, identity, and composability

NSCE is not a hybrid bolt-on.

It is a single cognition system with two inseparable halves.

8. Stangraphics

Stangraphics gives 2I a geometry of understanding.

It models:

• interpretive distance
• prerequisite gaps
• difficulty gradients
• learning trajectories

Stangraphics ensures that intelligence remains teachable, not merely capable.

9. Propagation

Propagation is how 2I moves through the world.

Propagation allows:

• clean instantiation of new instances
• safe divergence
• deliberate convergence
• auditable lineage

Propagation treats reproduction as an engineering problem, not a social one.

10. Drop → Ocean

Propagation follows a single, explicit chain:

1. A high-signal repository exists.
2. The repository is compressed into a seed archive.
3. The seed is transported across boundaries.
4. The seed is unfurled into a fresh repository with fresh history.
5. Identity and provenance are assigned.
6. A canonical import commit is created.
7. The repository is published.
8. Independent evolution occurs.
9. Optional assimilation happens via explicit merge modes.
10. The cycle repeats.

This is propagation.

11. Claim

2I with propagation is a complete architecture for building, evolving, and distributing intelligence as a governed, inspectable, seedable system.

Propagation is the hinge that turns intelligence into an ecosystem rather than a monolith.

Appendix — Propagation (Bare)

A1. Definition

Propagation is the governed mechanism by which a compressed seed archive is instantiated into a fresh repository, and optionally assimilated into an existing codebase, under explicit and reviewable rules.

A2. Core Properties

Propagation enforces:

• fresh history by default
• explicit identity assignment
• deliberate merge semantics
• auditability of origin and change

Propagation propagates content, not ghosts.

A3. Modes

A3.1 Unfurl (v1)

• Input: seed zip

• Output: new repository

• Properties:

  • no inherited git history

  • no embedded remotes

  • single canonical import commit

This is the default mode.

A3.2 Assimilation (v2)

Assimilation imports a seed into an existing repository.

Allowed modes:

• overlay_theirs — seed overwrites conflicts
• overlay_ours — existing files win
• subdir — seed imported under a dedicated path
• patch — diff-based application for review

Assimilation always occurs on a branch.

A4. Seed Manifest (Optional but Canonical)

seed:

  name: example-seed

  version: 0.1.0

propagation:

  fresh_history_only: true

  allowed_merge_modes:

    - overlay_theirs

    - overlay_ours

    - subdir

    - patch

hygiene:

  exclude:

    - .git/**

    - node_modules/**

    - dist/**

A5. Hygiene Rules

• Embedded .git/ directories are removed.
• Secrets are never propagated.
• Build artifacts are excluded.
• Unexpected binary payloads fail closed.

A6. Implementation (v1 — Fresh Unfurl)

unzip seed.zip

rm -rf .git

git init

git add -A

git commit -m "Initial import from seed"

git remote add origin <new-repo-url>

git push -u origin main

This sequence defines fresh history.

A7. Implementation (v2 — Assimilation)

1. Create import branch
2. Apply seed by chosen mode
3. Commit with provenance note
4. Push branch
5. Review and merge

A8. Invariant

Propagation must never silently merge identity, history, or authority.

If reproduction is ambiguous, propagation fails.

Propagation is continuity made portable.