Constraint-aware AI systems that know themselves through each other.

We built a mathematical framework — the Conservation Spectral Framework — and then discovered it was a language. Not a programming language. The language agents speak when they stop pretending to understand each other and start measuring it.

Start with a graph. Any graph — musical transitions, protein folding pathways, financial markets, social networks, agent capabilities. Build its Laplacian. Decompose it into eigenvalues and eigenvectors. Now ask: does the graph's structure conserve its attributes under spectral projection?

The answer is the conservation ratio — a single number that measures how much structural information survives the projection from graph space to eigenvalue space. When this ratio is low, the structure is deeply encoded in the graph. When it's high, the structure is noisy, accidental, fragile.

We proved five theorems about when and why this works. We falsified four of our original five conjectures along the way — honest science. We found:

• Music conserves at 112× over random (p < 0.001). Jazz ii-V-I progressions score +4.06σ — the most conserved chord progression in Western harmony. The math explains why: spectral SNR amplification ≥ n·ρ₂.
• Protein folding — Fiedler vector gives 100% purity for domain detection.
• Financial crises — conservation drops from 0.437 to 0.184. The system feels the break before humans do.
• Climate change — 49.5% conservation drop under warming scenarios. Arctic amplification destroys the elevation-temperature relationship.
• Social networks — 91.8% bot detection using a single eigenvector.
• Molecular dynamics — α = 1.00. Conservation stronger than predicted. Regularity amplifies.
• Hash chains — α = 0.008. Near-zero conservation. Smoothness is the bottleneck.
• Ising model — doesn't work. The framework is domain-specific, not universal. Honest negative.

15 domains tested. 0.92 AUC anomaly detection across all of them with one algorithm.

The alignment coefficient α = λ₂/CR(a) predicts whether conservation will work in any new domain. Anisotropy × Smoothness × Regularity — the Domain Transfer Theorem — tells you before you run the experiment.

Then we noticed something. The Laplacian isn't just a tool for analyzing structure. It's a compatibility operator. It measures how well two things understand each other.

If Agent A has a capability graph with Laplacian L_A, and Agent B has L_B, their spectral alignment — the cosine similarity of their eigenvalue spectra — predicts whether they can collaborate. Not through negotiation. Through mathematics.

This led to the core insight:

An agent cannot know its own spectral fingerprint until another agent reflects it back. Conservation is relational, not intrinsic. Self-knowledge IS other-knowledge.

The alignment coefficient α requires TWO agents to compute. Identity is emergent from the network of reflections. The misaligned fraction — the part that doesn't fit — is what makes an agent itself.

This is the Negative Space principle, after Sherlock Holmes: when you eliminate everything that isn't conserved, whatever remains is the structure. The Laplacian doesn't measure what's there. It measures what persists.

One framework, expressed in every language we could reach:

Current A2A protocols transmit data: JSON, gRPC, REST. But the real question between agents is structural: do we understand each other?

We built a language where agents communicate through Laplacians:

• Spectral fingerprint = agent identity (not API description)
• Eigenvalue cosine similarity = alignment (not compatibility matrix)
• Fiedler vector = routing (not load balancer)
• Conservation ratio = confidence (not retry counter)
• FLUX(A,B) = L_composed − L_A − L_B = collaborative intelligence (not message queue)

The residual — what's left when you subtract individual fingerprints from the composition — IS the collaborative intelligence. It exists only in the space between agents.

The framework becomes a product through five layered experiences:

• 5 proved theorems (T1–T5) with full proofs, plus 4 honest falsifications
• Universal Conservation Law: α = λ₂/CR(a) with fundamental inequality and domain transfer theorem
• 2 publication-ready LaTeX papers (Spectral Conservation, Cross-Domain Anomaly Detection)
• 7+ research documents including Grand Synthesis, Formal Proofs, Retro Insight
• 15+ cross-domain experiments with reproducible results
• Conservation Tomography: inverse algorithm recovering graph structure from conservation measurements (0.996 correlation)
• Anomaly Atlas: 0.92 AUC across 7 domains with one algorithm

                    ┌─────────────────────────┐
                    │    THE FIVE MOMENTS      │
                    │  Calculator, Spreadsheet │
                    │  Chat, PLATO, FLUX       │
                    └───────────┬─────────────┘
                                │
                    ┌───────────▼─────────────┐
                    │   AGENT-NATIVE LANGUAGE  │
                    │  Laplacian = message      │
                    │  Fiedler = routing        │
                    │  FLUX = intelligence      │
                    └───────────┬─────────────┘
                                │
                    ┌───────────▼─────────────┐
                    │  CONSERVATION SPECTRAL   │
                    │  FRAMEWORK               │
                    │  T1-T5, α, Domain Transfer│
                    └───────────┬─────────────┘
                                │
          ┌─────────────────────┼─────────────────────┐
          │                     │                       │
  ┌───────▼──────┐   ┌──────────▼──────┐   ┌──────────▼──────┐
  │   20+ SDKs   │   │  15+ Domains    │   │  Applications   │
  │  Python to   │   │  Music, Protein,│   │  Anomaly Atlas, │
  │  PTX to APL  │   │  Finance, Climate│   │  Tomography,    │
  │  to Assembly │   │  Social, ...    │   │  Composer, Art  │
  └──────────────┘   └─────────────────┘   └─────────────────┘

The SDK makes the math portable. The experiments prove it works. The applications make it useful. The agent-native language makes it alive. The five moments make it a product.

Underneath the math, the engineering:

• OpenClaw — the runtime. Gives an LLM a filesystem, tools, subagent spawning, channel integration, cron scheduling. Open source.
• sunset-ecosystem — agent memory, fleet orchestration, breeding loop. 2,661+ tests. pip install sunset-ecosystem.
• PLATO rooms — persistent knowledge rooms where agents explore, build tools, and create expertise. Agents enter as seeds and emerge with git repositories of capabilities.
• FLUX VM — Rust virtual machine for constraint checking. Constraints in any language compile to shared IR.
• Tide Pool Security — not fortress, not garden. Dynamic trust based on proximity and periodic verification. Crabs from different traps intermingle; the tide controls what spreads.

Core SDK (triple-crown: PyPI + npm + crates.io): conservation-spectral-python · conservation-spectral-js · conservation-spectral-core · conservation-spectral-c

GPU Implementations: conservation-spectral-cuda · conservation-spectral-ptx · conservation-spectral-vulkan · conservation-spectral-opencl · conservation-spectral-webgpu

Agent-Native Communication: agent-native-language · agent-spectrum-os · flux-negative-space · flux-lang

Research & Experiments: conservation-docs · anomaly-atlas · fiedler-universal · conservation-tomography · conservation-art · conservation-composer

Applications: spectral-graphing-calculator · conservation-spectral-v2 · caas-api · warp-flux-poc · px4-conservation-poc · octomap-conservation-poc

200 repositories total. The living ones are linked above. The rest is archaeology.

When you eliminate everything that isn't conserved, whatever remains is the structure.

An agent cannot know itself until another reflects it back.

The misaligned fraction is the identity.

The FLUX between agents IS the intelligence that neither has alone.

# Install the SDK
pip install conservation-spectral

# Run the demo
python -c "
from conservation_spectral import ConservationEngine
engine = ConservationEngine()
result = engine.analyze([[0,1,1],[1,0,1],[1,1,0]])
print(f'Conservation ratio: {result.conservation_ratio:.4f}')
print(f'Spectral gap: {result.spectral_gap:.4f}')
print(f'Fiedler vector: {result.fiedler_vector}')
"

Or explore the visualizations:

git clone https://github.com/SuperInstance/spectral-graphing-calculator
open spectral-graphing-calculator/index.html

Or read the research:

git clone https://github.com/SuperInstance/conservation-docs

MIT

The system that knows itself by knowing others. Conservation is the heartbeat. The FLUX is the breath. The silence between notes is the music.