Define behavior.
Receive the adapter.

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

Select a supported model and define behavioral targets. Generate a candidate LoRA adapter under a documented configuration. Processing is designed to run locally; verify compatibility and data flows for your deployment.

Free
$0
current tier
Run an experimental behavioral scan and review selected probe outputs.
  • cradle scan — 1 model / month
  • Supported configurations (3B–32B)
  • Up to 9 documented behavioral dimensions
  • Probe readout report
  • Community support
Compress
$1
per model
Probe-guided quantization. Critical layers protected, expendable layers crushed.
  • cradle compress — supported HF models
  • Documented configurations (3B–32B)
  • Mixed-precision (2/3/4/8-bit)
  • Behavioral fidelity report
  • GGUF, SafeTensors, EXL2 export
  • Internal benchmark: up to 25% vs uniform quant under reported conditions
  • No subscription currently required
Compatibility framework spanning 16 architecture families.
Support varies by model and configuration.
Internal testing covers the six named configurations below. Automatic resolution is available for selected models on supported architectures; probe layers, hidden dimensions, and LoRA targets should be verified before use. Results may vary by model, task, hardware, software, and evaluation conditions.
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
Experimental internal-state monitoring.
Token-level behavioral
telemetry.
In supported configurations, four experimental layers can read selected hidden-state features during token generation and apply bounded steering. Latency, cache behavior, steering effectiveness, and stability depend on the model, hardware, software, and configuration. The cortex component supplies a contextual state summary; it does not create consciousness or human-like self-awareness. Optional memory can retain selected measurements across sessions, while telemetry may include confidence, entropy, and perplexity.
Illustrative interface example — displayed scores and events are simulated UI values, not live measurements or benchmark results.
# example supported model — configure and validate layers
from cradle.monitor import CradleMonitor

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

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

# model receives a state summary; configured
# policy may apply, bypass, or review steering
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
demo
coherence
demo
calibration
demo
focus
demo
specificity
demo
suppression
sycophancy
demo
hedging
demo
verbosity
demo
repetition
demo
▸ L1 telemetry — selected dimensions, token-level reads
▸ L2 steering — illustrative thresholds and example events
▸ L3 context — state-summary injection · policy review available
▸ L4 memory — optional event history and baseline estimates
▸ diagnostics — example confidence, entropy, and perplexity fields
Equip supported models with tools and monitored workflows.
Tool-enabled agent with memory
and improvement tracking.
CradleAgent is designed to wrap supported models with experimental monitoring, configured tools, and optional persistent vector memory. Depending on permissions and deployment controls, it can assist with tasks such as writing code, running sandboxed commands, and retrieving prior work. Its α and α' fields are internal improvement-tracking metrics; they do not establish recursive self-improvement, general capability gains, consciousness, or self-awareness.
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,  # experimental tracking
)

# configured workflow example; review permissions and outputs
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?")
Tool-Enabled Workflows — can decompose goals and use configured code, shell, file, or web tools within deployment permissions. Sandbox boundaries and outputs require independent review.
🧠
Vector Memory — when enabled, configured task data can be stored as embeddings, retrieved by similarity, and persisted to disk. Retention, privacy, and relevance depend on deployment settings.
📈
Improvement Tracking — tracks internally defined α and α' metrics from selected probe scores and can support controlled LoRA experiments. These diagnostics do not by themselves demonstrate true recursive self-improvement or sustained capability growth.
🔬
Monitoring and Policy Hooks — supported workflows can expose selected behavioral signals, apply configured steering, add state summaries, and retain event history. No consciousness or human-like self-awareness is implied.
🏟️
Arena — supports controlled comparisons of configured agents on the same task, with trajectory review and JSON export for experimental analysis.
Probe-guided quantization.
$ cradle compress Qwen/Qwen2.5-72B-Instruct --target-vram 24gb
Uniform quantization applies a common precision policy across layers. Cradle Compress uses selected behavioral probe measurements to estimate which layers may warrant higher precision.

Under supported configurations, selected layers can remain at 4–8 bit while other eligible layers may use 2-bit precision. An internal benchmark reported up to 25% improvement over uniform quantization under the reported model, metric, and test conditions; results may vary and are not guaranteed.

Supports documented Hugging Face configurations across selected architecture families. Automatic architecture resolution and export availability depend on model structure, software versions, hardware, and target format.
$1 current listed price per supported compression · subject to availability and terms
Illustrative Behavioral Fidelity Report
Reasoning
demo
Coherence
demo
Calibration
demo
Focus
demo
Hedging
demo
Illustrative UI onlynot measured results
Logan Matthew Napolitano

Logan Matthew Napolitano

Founder & CEO

Father. Husband. Founder. San Bernardino, California.

An independent developer building and testing an architecture-portable approach to internal-state monitoring, bounded intervention, and evidence-based evaluation.

Your model.
Your hardware.
Your behavioral spec.

Installation and adapter-generation time vary by model, hardware, software, and configuration. Local execution is supported in documented deployments; verify all data flows before use.

$ 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