livingcircuit

Composable AI conditioning primitives for stability, coherence, and signal smoothing.

Free · No API keys · No bloat · Drop them in, layer them together.

Install

pip install livingcircuit

For PyTorch support (AdaptiveAmplitudeStabilizer nn.Module):

pip install livingcircuit[torch]

Why it matters

Most AI systems today rely on brute force. These small primitives give you precise control over how information flows through your models — making them more stable, coherent, and reliable under real-world conditions. Use one to fix a specific problem, or stack several to stabilize the whole pipeline.

Modules

Quick start

import numpy as np
from livingcircuit import harmonic_vector_stabilizer

t      = np.linspace(0, 4 * np.pi, 256)
result = harmonic_vector_stabilizer(t)

print(result["quality_score"])   # coherence ratio
print(result["energy"])          # mean signal energy

Composable stack

These modules are designed to layer together across different parts of the same pipeline:

raw input
  → SimpleVoiceToneAnalyzer        # tone + intensity
  → harmonic_vector_stabilizer     # latent coherence
  → AdaptiveAmplitudeStabilizer    # activation control
  → model block (attention + FFN)
  → adaptive_amplitude_stabilizer  # scalar output smoothing
  → stabilize_solar_output         # signal continuity
  → stable output

Transformer block stabilization

import torch
from livingcircuit import AdaptiveAmplitudeStabilizer

stab1 = AdaptiveAmplitudeStabilizer(dim=768, layer_idx=0)
stab2 = AdaptiveAmplitudeStabilizer(dim=768, layer_idx=1)

# In your forward pass
attn_out = self.attn(self.norm1(x))
x = x + stab1(attn_out)

ffn_out = self.ffn(self.norm2(x))
x = x + stab2(ffn_out)

Voice-aware response shaping

import numpy as np
from livingcircuit import SimpleVoiceToneAnalyzer, harmonic_vector_stabilizer

analyzer = SimpleVoiceToneAnalyzer()
audio    = np.random.randn(16000).astype(np.float32) * 0.1

tone_result = analyzer.analyze(audio)
print(tone_result["tone"], tone_result["intensity"])

# Feed intensity into harmonic conditioner
t      = np.linspace(0, 4 * np.pi, 256) * tone_result["intensity"]
latent = harmonic_vector_stabilizer(t)
print(latent["quality_score"])

Scalar signal continuity

from livingcircuit import adaptive_amplitude_stabilizer, stabilize_solar_output

readings = [1.0, 1.4, 0.9, 1.1, 1.3, 0.8, 1.2]
set_pt   = readings[0]
memory   = 0.0

for i in range(1, len(readings)):
    bounded, set_pt = adaptive_amplitude_stabilizer(
        readings[i], set_pt, variance_limit=0.3, impedance=0.5
    )
    smoothed, memory = stabilize_solar_output(
        bounded, readings[i - 1], dt=1.0, memory=memory
    )
    print(f"raw: {readings[i]:.2f}  →  smoothed: {smoothed:.4f}")

License

MIT — free for any use. No restrictions on the public layer.

The Living Circuit LLC · thelivingcircuit.ai · ghost@thelivingcircuit.ai