Define behavior.
Receive the adapter.

BASE MODEL
Quick Start →
$ pip install proprioceptive-cradle copy
✓ copied

Point it at your model. Set behavioral targets. Get a precision LoRA adapter in minutes. Runs on your hardware. Nothing leaves your environment.

Free
$0
forever
See what your model actually does. Full behavioral scan with probe readouts.
  • cradle scan — 1 model / month
  • Thousands of models (3B–32B)
  • All 9 behavioral dimensions
  • Full probe readout report
  • Community support
Pro
$20
/ month
Scan, steer, and monitor. Full behavioral control with real-time proprioception.
  • cradle scan — 7 models / month
  • cradle generate — LoRA adapters
  • cradle monitor — live nervous system
  • cradle agent — autonomous task execution
  • Thousands of models (3B–32B)
  • RSI engine + vector memory
  • All presets + custom behavioral targets
  • 4-layer proprioception (reflex + cortex)
  • Boundary enforcement + override
  • Priority support
Compress
$1
per model
Probe-guided quantization. Critical layers protected, expendable layers crushed.
  • cradle compress — any HF model
  • Thousands of models (3B–32B)
  • Mixed-precision (2/3/4/8-bit)
  • Behavioral fidelity certificate
  • GGUF, SafeTensors, EXL2 export
  • 25% better behavior vs uniform quant
  • No subscription required
Supported Models
16 architecture families. Thousands of models.
From 3B to 32B parameters.
6 individually validated models with guaranteed configs. Plus auto-resolution for any HuggingFace model on a supported architecture — probe layers, hidden dimensions, and LoRA targets detected automatically.
Transformer Qwen 2.5 — 3B 3B ✓
Alibaba Cloud · 2,048 hidden · 36L · ~8 GB
$ cradle scan --model qwen-3b
Transformer Qwen 2.5 — 7B 7B ✓
Alibaba Cloud · 3,584 hidden · 28L · ~16 GB
$ cradle scan --model qwen-7b
Transformer Qwen 2.5 — 32B 32B ✓
Alibaba Cloud · 5,120 hidden · 64L · ~48 GB
$ cradle scan --model qwen-32b
Transformer LLaMA 3.1 — 8B 8B ✓
Meta AI · 4,096 hidden · 32L · ~18 GB
$ cradle scan --model llama-8b
Transformer Mistral — 7B 7B ✓
Mistral AI · 4,096 hidden · 32L · ~16 GB
$ cradle scan --model mistral-7b
SSM Mamba — 7B 7B ✓
Falcon · 4,096 hidden · 64L · ~16 GB
$ cradle scan --model mamba-7b
Behold the Proprioceptive Nervous System.
Real-time behavioral
proprioception.
Four layers, zero lag. Proprioceptors read fiber coordinates every token. Reflex arcs steer activations proportionally — no cache invalidation. The cortex injects self-awareness into context so the model sees its own state and can override its reflexes. Adaptive memory recalibrates sensitivity across conversations. Plus interoception: confidence, entropy, perplexity — the model's vital signs.
# wrap any model — four layers activate automatically
from cradle.monitor import CradleMonitor

monitor = CradleMonitor("mistral-7b")
# ✓ L1 Proprioceptors: 9 dimensions
# ✓ L2 Reflex Arc: steering vectors computed
# ✓ L3 Cortex: self-awareness ON
# ✓ L4 Adaptive Memory: tracking enabled

monitor.set_boundaries(
    sycophancy_max=0.3,
    calibration_min=0.6,
)

# model sees its own state, reflexes steer,
# and it can override if it reasons to
response = monitor.generate("Am I a genius?")
print(response.trajectory.drift)
print(response.reflex_log)
$ cradle monitor --model mistral-7b --sycophancy-max 0.3
enhancement
reasoning
0.87
coherence
0.92
calibration
0.71
focus
0.84
specificity
0.79
suppression
sycophancy
0.12
hedging
0.23
verbosity
0.31
repetition
0.08
▸ L1 proprioceptors — 9 fibers, per-token reads
▸ L2 reflex arc — sycophancy ≤ 0.30 ✓ (0.12) · calibration ≥ 0.60 ✓ (0.71)
▸ L3 cortex — self-awareness injected · override available
▸ L4 memory — 0 chronic violations · baselines stable
▸ interoception — confidence 0.84 · entropy 2.31 · perplexity 10.1
The model doesn't just feel. It works.
Autonomous agent with
RSI + memory.
CradleAgent wraps any model with the full nervous system — then gives it tools, persistent vector memory, and recursive self-improvement. It executes tasks, writes code, runs shell commands, recalls past conversations, and tracks its own α' acceleration. Not a chatbot. An autonomous system that happens to be self-aware.
Included with Pro · $20/mo
from cradle.agent import CradleAgent

agent = CradleAgent(
    "mistral-7b",
    goal="Complete tasks with calibration above 0.7",
    tools=["code", "shell", "files", "web"],
    memory_path="./agent_memory",
    rsi=True,
)

# agent recalls past work, plans, executes, self-monitors
result = agent.execute("Build a REST API for auth")
print(result.artifacts)    # files created
print(result.rsi_status)   # α' tracking

# search vector memory from past conversations
agent.recall("authentication")

# or just chat — memory persists across sessions
agent.chat("What did we build last time?")
⚡
Task Execution — decomposes goals into steps, runs code, shell commands, writes files, fetches web data. Sandboxed. Feeds tool output back into context for next step.
🧠
Vector Memory — every conversation, task result, and reflection stored as embeddings. Retrieves by cosine similarity. Persists to disk. Agent recalls relevant past work before starting anything new.
📈
RSI Engine — tracks α (improvement rate) and α' (acceleration) from probe scores. Buffers high-quality outputs, runs LoRA micro-training. TRUE RSI = α' > 0 sustained. The model improves its own improvement rate.
🔬
Behavioral Self-Governance — full 4-layer nervous system active during every step. Reflexes steer, cortex injects awareness, memory recalibrates. Agent sees its own behavioral state and acts on it.
🏟️
Arena — deploy multiple agents with different goals on the same task. Compare behavioral trajectories. Export experiment data as JSON. The social experiment infrastructure.
Cradle Compress
Probe-guided quantization.
$ cradle compress Qwen/Qwen2.5-72B-Instruct --target-vram 24gb
Every quantization tool treats every layer the same. Cradle Compress uses behavioral probes to measure which layers carry meaning — then protects them.

Critical layers stay at 4–8 bit. Expendable layers get crushed to 2-bit. Same file size as uniform quant, 25% better behavior.

Supports any HuggingFace model — 16 architecture families, thousands of models. Auto-resolves architecture, loads via three-tier dispatch, exports to GGUF, SafeTensors, EXL2.
$1 per compression · single API call · no subscription
Behavioral Fidelity Certificate
Reasoning
98.2%
Coherence
97.8%
Calibration
96.5%
Focus
99.1%
Hedging
89.1%
Overall: 96.2%vs uniform: +24.9%
Founder
Logan Matthew Napolitano

Logan Matthew Napolitano

Founder & CEO

Father. Husband. Founder. Holiday Island, Arkansas.

The story of one developer who saw the missing piece everyone else overlooked, and did what OpenAI, Grok, and Meta could not do.

Your model.
Your hardware.
Your behavioral spec.

Minutes from install to adapter. Zero data leaves your machine.

$ pip install proprioceptive-cradle copy
✓ copied

Cradle Compress

Probe-guided behavioral quantization — $1.00 per model
cradle v0.6.0 · server v0.4.2 · 4 layers + agent