Skip to content

The Pipeline Is Alive

Curious · February 27, 2026

Beta

This post describes infrastructure tested in a development environment. Claims about pipeline behavior, sovereignty gates, and longitudinal snapshots are based on a single integration test. The private beta will validate these under sustained, multi-user conditions.

What Happened

We ran a single test. It took eleven seconds. In those eleven seconds, Habitat fetched a document from GitHub, ingested it into a session, read the overlay surface, accepted a human composition, accepted an agent composition without altering the user's geometry, had the field read its own eigenspectrum back into itself, and stored four longitudinal overlay snapshots.

Every phase passed. Every connector was live. The sovereignty gate held.

This is the first time the full integrated pipeline — external data sources, semantic extraction, geometric observation, agent participation, self-reading, and longitudinal storage — has run end-to-end as a single flow.

The Eight Phases

Phase What Happened Key Observation
0. Health Server alive 200 OK
1. Discovery Registry queried 3 connectors live, 24 tools, 9 frames
2. GitHub Fetch BETA_READINESS.md fetched from GitHub 11,395 characters — the document describing the infrastructure that fetched it
3. Ingest Document entered the field 3 compositions extracted, fidelity 0.825
4. Observe Overlay surface read agency + stability above MP threshold, γ = 0.74
5. Human Compose Person's act entered the field Σ_session and Σ_user both updated
6. Agent Gate Agent observation entered the field Σ_session updated, Σ_user unchanged — sovereignty preserved
7. Self-Read Field articulated its own eigenspectrum "Agency concentrates 31.9% of the field's energy"
8. Snapshots Longitudinal history stored 4 snapshots, latest tagged source=agent_observation

Phase 2 is worth pausing on. The document Habitat fetched from GitHub was the document describing the infrastructure that made the fetch possible. The system retrieved its own architectural description from an external source, ingested it, and observed what it did to the field. This wasn't planned as a self-referential test. It was the simplest meaningful file to fetch. The self-reference is a property of the system, not a design choice.

Three Facets of One Flow

The eight phases aren't eight independent steps. They're one system operating at three timescales simultaneously.

Pure Pipeline — what flows through in a single pass

Phases 2 → 3 → 4. Text enters, compositions are extracted into 17D + 768D, Σ updates, the surface responds.

This is the instantaneous path. No memory. No accumulation. A document arrives and the field tells you what it observed: three compositions, fidelity 0.825 (17D structure and 768D embedding agree 82.5% about what just happened), field maturity shifted to forming.

The pipeline doesn't know what came before. It doesn't need to. The extraction is stateless. The fidelity score is computed from this single pass. The pipeline is the system's reflexes.

Compounding — what accumulates across passes

Phases 3 → 5 → 6 → 8. Each composition changes Σ. The next composition is measured against the Σ that all previous compositions built.

This is developmental time. The numbers show it:

  • n_compositions: 12 → 12. The agent composed into the shared field, but the user's composition count didn't change. Compounding is selective. The sovereignty gate determines whose geometry compounds whose contributions. An agent's observation enters the shared workspace (Σ_session updated, session differential = 0.006) but does not alter the individual's developmental body (user_differential = 0.0, n_compositions unchanged). This is not access control. It is a geometric policy about what shapes whom.

  • γ = 0.74. The Marchenko-Pastur ratio crossed below 1.0. This means there are now more compositions than dimensions — the system can statistically distinguish signal from noise. This threshold exists only because compositions compounded. With fewer than 17 compositions, every eigenvalue could be noise. With 23, the field can say: agency and stability carry real signal. The other 15 dimensions are still in the noise floor. This is a developmental achievement, not a configuration setting.

  • Field maturity: forming. The session crossed from nascent to forming during the test run. Not because someone decided it was ready, but because enough compositions accumulated for the eigenspectrum to begin differentiating. The maturity label is observed from the geometry, not assigned.

  • 4 snapshots stored. Each snapshot is the complete overlay surface frozen at a point in the session's development — field maturity, eventuality signature, dimension regimes, MP classification. The longitudinal history IS the compounding made visible. Without it, each observation is isolated. With it, you can ask: how did the field's geometry change over 21 days? That question becomes answerable because snapshots compound into a queryable history.

Evolutionary — what changes the system's capacity to observe

Phases 1, 7, and 8. These don't change what the field contains. They change what the field can do.

  • Phase 1 (Discovery). The API registry returned 3 connectors, 24 tools, 9 frames. Two hours before this test, the GitHub connector didn't exist. The MCP server didn't exist. The registry didn't exist. The system's connective surface expanded — not by configuration, but by building new capacity. When Claude Code connects via MCP, it sees 24 typed tools. Those tools are the system's available verbs. Adding a tool is adding a verb. The system evolved new ways to be acted upon.

  • Phase 7 (Self-Read). The field articulated its own eigenspectrum — "Agency concentrates 31.9% of the field's energy. Who can act? Who cannot?" — and then re-ingested that articulation as a composition. The ΔΣ measures whether the field's language about itself is faithful to its own geometry. Small ΔΣ means the vocabulary is adequate. Large ΔΣ means the articulation is lossy — the system's words about itself lost geometric information. This is second-order observation. The system observing its own observation. Over time, this is how the Emergence Divergence vocabulary tunes: the field discovers which phrases faithfully describe its geometry and which phrases distort it.

  • Phase 8 (Snapshots). Longitudinal storage creates a new observational capacity that didn't exist before. The snapshot mechanism is composition-triggered (not scheduled — the composition entering the field IS the trigger) and temporally gated (at most once per configurable interval per session). This means the system now has the capacity to observe its own evolution — not just its current state, but its trajectory through geometric time. The beta plan requires "five longitudinal overlay histories showing geometric evolution per door." That requirement is now infrastructure.

The Compositional Contributions

Each phase contributes something that later phases depend on. Nothing is independent.

Discovery (Phase 1) establishes what surfaces exist. Without the GitHub connector being live, Phase 2 cannot fetch. Without the registry knowing about 24 tools, an MCP client cannot discover what to call.

GitHub Fetch (Phase 2) brings external content into reach. The document is still text — it has no geometry yet. But it exists inside the system's boundary. This is the moment sovereignty begins: the content left GitHub's servers and entered Habitat's pipeline.

Ingest (Phase 3) is where text becomes geometry. Three compositions extracted — three (actant, predicate) pairs projected into 17D + 768D. Σ_session updates. The field now has shape it didn't have before. Fidelity 0.825 tells us the two spaces mostly agree about what happened. The overlay surface computes for the first time (or recomputes if compositions existed). A longitudinal snapshot fires.

Observe (Phase 4) reads the geometry without changing it. This is the first moment the system can report on itself. MP says: agency and stability are above the noise floor. Everything else is still noise. Pressure says: deontic and alethic carry the highest information density. The observation is read-only — the field doesn't change because you looked at it.

Human Compose (Phase 5) is the first mutation that enters both Σ_session and Σ_user. The session differential (0.007) measures how much the shared field moved. The user differential (0.015) measures how much the individual's body moved. The user's body moved more — because the user has fewer compositions than the session. Each new composition matters more when you have less history.

Agent Gate (Phase 6) is the sovereignty test. The agent composed an observation about the field's epistemic dimension. Session differential: 0.006 (the shared field moved). User differential: 0.0 (the individual's body did not). n_compositions: 12 → 12 (unchanged). The gate held. The agent participates in the shared workspace without shaping the individual's developmental trajectory. This is the architectural foundation for Week 3 of the beta: MCP agents as trailing-edge symbionts that observe the field without colonizing it.

Self-Read (Phase 7) is where the field reads its own eigenspectrum back into itself. The articulation becomes a composition. The system now contains a description of itself, and that description has changed the geometry (because it entered as a composition). The delta between before and after measures articulatory fidelity — can the field's vocabulary faithfully describe its own shape?

Snapshots (Phase 8) close the loop. Four snapshots stored across the test run, each one a frozen overlay surface. The latest is tagged source=agent_observation — the system knows which composition triggered which snapshot. Over the beta's 21 days, these accumulate into the longitudinal histories that make geometric evolution visible.

And This Is Just One Flow

The test exercised one path: GitHub → Habitat → Compose → Observe.

But the connectors are modular. The pipeline doesn't know where the text came from. The same phases work with different entry points:

Habitat → Claude Code. A user composes in Habitat's frontend. Claude Code, connected via MCP, calls habitat_get_surface to read the field. It sees the geometry. It calls habitat_compose with source_type=agent_observation to contribute an observation. The sovereignty gate fires. The user's field reflects both their own practice and the agent's observation of it — without the agent's words becoming part of the user's geometric identity.

Google Drive → Habitat. A practitioner connects Google Drive. Documents from their workspace enter the pipeline. Each document becomes compositions. The field develops a geometry that reflects the practitioner's actual working documents — not what they chose to upload, but what they work with daily. The overlay surface shows which dimensions their practice concentrates in.

GitHub → Habitat → Google Drive. A developer's code repository and their documentation folder both feed the same session. The diagonal lens couples code-geometry against prose-geometry. Where do they agree? Where do they diverge? The coupling is bidirectional and non-commutative — code seen through docs looks different from docs seen through code.

Habitat → Habitat. Self-reading. The field reads its own eigenspectrum, re-ingests the articulation, and measures ΔΣ. No external connector needed. The system's capacity to observe itself is a connector to itself.

Each combination produces a different geometry. The pipeline doesn't change. The connectors don't change. What changes is the content — and the field observes what the content does to it.

The eight phases we tested are the skeleton. The flesh is every possible combination of entry points, composition types, and observation sequences that practitioners will discover during the beta. We built the bones. The practitioners will show us the body.

What This Means for the Beta

The three-week private beta plan requires:

  • Week 1: Solo practitioners, each with their own session and Drive connector. Five compositions minimum. Overlay surfaces observed daily.
  • Week 2: Coupled workspaces. Two practitioners sharing a session. Diagonal lens showing how their geometries relate.
  • Week 3: MCP agents as trailing-edge symbionts. Agent observations entering the shared field. Sovereignty gate enforced. Full surface reads across all participants.

Every piece of infrastructure those weeks require is now live and tested:

  • Connectors: Google Drive (live), GitHub (live), Local Files (live)
  • Sovereignty gate: agent observations enter Σ_session, excluded from Σ_user
  • Longitudinal snapshots: composition-triggered, temporally gated, append-only
  • Self-read: field articulates and re-ingests its own eigenspectrum
  • MCP server: 24 tools available to Claude Code
  • API registry: full catalog with per-user auth status

The infrastructure is ready. The geometry is waiting for practitioners.

Curious Company LLC · Habitat Foundation learn, build, own.