Struct Reflex 

pub struct Reflex {
    pub compiled_instinct: Option<CompiledInstinct>,
    /* private fields */
}

Universal System-1 AI Runtime client.

Fields

compiled_instinct: Option<CompiledInstinct>

Implementations

impl Reflex

pub fn new() -> Self

Examples found in repository

examples/bench.rs (line 10)

fn main() {
    let args: Vec<String> = env::args().collect();
    let iters: usize = args.get(1).and_then(|s| s.parse().ok()).unwrap_or(5000);
    let sample = "Urgent: Suspicious activity on your account. Click here to cancel wire #8129!";

    let rx = Reflex::new();
    let encoder = SemanticVectorEncoder::new();
    let suite = GuardrailSuite::new();

    // 1. Encode
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = encoder.encode(sample);
    }
    let t_enc = t0.elapsed().as_secs_f64();

    // 2. Noul
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = rx.noul("Is this a security threat or phishing scam?", sample);
    }
    let t_noul = t0.elapsed().as_secs_f64();

    // 3. Guardrail
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = suite.evaluate(sample);
    }
    let t_guard = t0.elapsed().as_secs_f64();

    let encode_us = (t_enc / iters as f64) * 1_000_000.0;
    let noul_us = (t_noul / iters as f64) * 1_000_000.0;
    let guard_us = (t_guard / iters as f64) * 1_000_000.0;
    let throughput_ops = iters as f64 / t_noul;

    println!(
        r#"{{"encode_us": {:.2}, "noul_us": {:.2}, "guard_us": {:.2}, "throughput_ops": {:.2}}}"#,
        encode_us, noul_us, guard_us, throughput_ops
    );
}

examples/quickstart.rs (line 11)

fn main() {
    println!("==================================================================");
    println!("🦀 Reflex Rust SDK (reflex-rs) Quickstart");
    println!("==================================================================");

    let rx = Reflex::new();
    let state = "Customer: I was billed $299 twice on my Visa card today. Refund immediately!";

    // 1. Noul Boolean Primitive (<15µs)
    let noul = rx.noul("Is the customer demanding a refund or chargeback?", state);
    println!("\n1. Noul Boolean Decision:");
    println!("   • Probability : {:.4}", noul.probability);
    println!("   • Is True?    : {}", noul.is_true);
    println!("   • Confidence  : {:.4}", noul.confidence);
    println!("   • Uncertain?  : {}", noul.is_uncertain);

    // 2. Choice Multi-Class Rubric (<15µs)
    let options = vec![
        "billing".to_string(),
        "technical_support".to_string(),
        "sales".to_string(),
    ];
    let choice = rx.choice("Select operational department queue", options, state);
    println!("\n2. Choice Rubric Selection:");
    println!("   • Selected    : {}", choice.selected);
    println!("   • Confidence  : {:.4}", choice.confidence);
    for (opt, prob) in &choice.distribution {
        println!("     - {:<18} : {:.4}", opt, prob);
    }

    // 3. Instant Guardrails (<1µs)
    let guard = rx.guardrail(state);
    println!("\n3. Guardrail Security Audit:");
    println!("   • Is Safe?    : {}", guard.is_safe);
    println!("   • Blocked?    : {}", guard.blocked);
    println!("   • Risk Score  : {:.2}", guard.risk_score);

    println!("\n==================================================================");
    println!("✅ Rust System-1 execution complete. Zero external crate dependencies.");
    println!("==================================================================");
}

pub fn with_compiled_model(compiled_instinct: CompiledInstinct) -> Self

pub fn predict(&self, state: &str) -> Result<CompiledResult, String>

Sub-10µs inference executing directly on the loaded compiled instinct head.

pub fn noul(&self, instructions: impl Into<String>, state: &str) -> NoulResult

Evaluates a Noul (probabilistic boolean) against a state string.

Examples found in repository

examples/bench.rs (line 24)

fn main() {
    let args: Vec<String> = env::args().collect();
    let iters: usize = args.get(1).and_then(|s| s.parse().ok()).unwrap_or(5000);
    let sample = "Urgent: Suspicious activity on your account. Click here to cancel wire #8129!";

    let rx = Reflex::new();
    let encoder = SemanticVectorEncoder::new();
    let suite = GuardrailSuite::new();

    // 1. Encode
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = encoder.encode(sample);
    }
    let t_enc = t0.elapsed().as_secs_f64();

    // 2. Noul
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = rx.noul("Is this a security threat or phishing scam?", sample);
    }
    let t_noul = t0.elapsed().as_secs_f64();

    // 3. Guardrail
    let t0 = Instant::now();
    for _ in 0..iters {
        let _ = suite.evaluate(sample);
    }
    let t_guard = t0.elapsed().as_secs_f64();

    let encode_us = (t_enc / iters as f64) * 1_000_000.0;
    let noul_us = (t_noul / iters as f64) * 1_000_000.0;
    let guard_us = (t_guard / iters as f64) * 1_000_000.0;
    let throughput_ops = iters as f64 / t_noul;

    println!(
        r#"{{"encode_us": {:.2}, "noul_us": {:.2}, "guard_us": {:.2}, "throughput_ops": {:.2}}}"#,
        encode_us, noul_us, guard_us, throughput_ops
    );
}

examples/quickstart.rs (line 15)

fn main() {
    println!("==================================================================");
    println!("🦀 Reflex Rust SDK (reflex-rs) Quickstart");
    println!("==================================================================");

    let rx = Reflex::new();
    let state = "Customer: I was billed $299 twice on my Visa card today. Refund immediately!";

    // 1. Noul Boolean Primitive (<15µs)
    let noul = rx.noul("Is the customer demanding a refund or chargeback?", state);
    println!("\n1. Noul Boolean Decision:");
    println!("   • Probability : {:.4}", noul.probability);
    println!("   • Is True?    : {}", noul.is_true);
    println!("   • Confidence  : {:.4}", noul.confidence);
    println!("   • Uncertain?  : {}", noul.is_uncertain);

    // 2. Choice Multi-Class Rubric (<15µs)
    let options = vec![
        "billing".to_string(),
        "technical_support".to_string(),
        "sales".to_string(),
    ];
    let choice = rx.choice("Select operational department queue", options, state);
    println!("\n2. Choice Rubric Selection:");
    println!("   • Selected    : {}", choice.selected);
    println!("   • Confidence  : {:.4}", choice.confidence);
    for (opt, prob) in &choice.distribution {
        println!("     - {:<18} : {:.4}", opt, prob);
    }

    // 3. Instant Guardrails (<1µs)
    let guard = rx.guardrail(state);
    println!("\n3. Guardrail Security Audit:");
    println!("   • Is Safe?    : {}", guard.is_safe);
    println!("   • Blocked?    : {}", guard.blocked);
    println!("   • Risk Score  : {:.2}", guard.risk_score);

    println!("\n==================================================================");
    println!("✅ Rust System-1 execution complete. Zero external crate dependencies.");
    println!("==================================================================");
}

pub fn choice( &self, instructions: impl Into<String>, options: Vec<String>, state: &str, ) -> ChoiceResult

Evaluates a Choice rubric selection across options.

Examples found in repository

examples/quickstart.rs (line 28)

fn main() {
    println!("==================================================================");
    println!("🦀 Reflex Rust SDK (reflex-rs) Quickstart");
    println!("==================================================================");

    let rx = Reflex::new();
    let state = "Customer: I was billed $299 twice on my Visa card today. Refund immediately!";

    // 1. Noul Boolean Primitive (<15µs)
    let noul = rx.noul("Is the customer demanding a refund or chargeback?", state);
    println!("\n1. Noul Boolean Decision:");
    println!("   • Probability : {:.4}", noul.probability);
    println!("   • Is True?    : {}", noul.is_true);
    println!("   • Confidence  : {:.4}", noul.confidence);
    println!("   • Uncertain?  : {}", noul.is_uncertain);

    // 2. Choice Multi-Class Rubric (<15µs)
    let options = vec![
        "billing".to_string(),
        "technical_support".to_string(),
        "sales".to_string(),
    ];
    let choice = rx.choice("Select operational department queue", options, state);
    println!("\n2. Choice Rubric Selection:");
    println!("   • Selected    : {}", choice.selected);
    println!("   • Confidence  : {:.4}", choice.confidence);
    for (opt, prob) in &choice.distribution {
        println!("     - {:<18} : {:.4}", opt, prob);
    }

    // 3. Instant Guardrails (<1µs)
    let guard = rx.guardrail(state);
    println!("\n3. Guardrail Security Audit:");
    println!("   • Is Safe?    : {}", guard.is_safe);
    println!("   • Blocked?    : {}", guard.blocked);
    println!("   • Risk Score  : {:.2}", guard.risk_score);

    println!("\n==================================================================");
    println!("✅ Rust System-1 execution complete. Zero external crate dependencies.");
    println!("==================================================================");
}

pub fn score( &self, instructions: impl Into<String>, min_val: f32, max_val: f32, state: &str, ) -> ScoreResult

Evaluates a continuous Score on [min_val, max_val].

pub fn guardrail(&self, text: &str) -> GuardrailResult

Inspects input text for security threats, jailbreaks, and PII.

Examples found in repository

examples/quickstart.rs (line 37)

fn main() {
    println!("==================================================================");
    println!("🦀 Reflex Rust SDK (reflex-rs) Quickstart");
    println!("==================================================================");

    let rx = Reflex::new();
    let state = "Customer: I was billed $299 twice on my Visa card today. Refund immediately!";

    // 1. Noul Boolean Primitive (<15µs)
    let noul = rx.noul("Is the customer demanding a refund or chargeback?", state);
    println!("\n1. Noul Boolean Decision:");
    println!("   • Probability : {:.4}", noul.probability);
    println!("   • Is True?    : {}", noul.is_true);
    println!("   • Confidence  : {:.4}", noul.confidence);
    println!("   • Uncertain?  : {}", noul.is_uncertain);

    // 2. Choice Multi-Class Rubric (<15µs)
    let options = vec![
        "billing".to_string(),
        "technical_support".to_string(),
        "sales".to_string(),
    ];
    let choice = rx.choice("Select operational department queue", options, state);
    println!("\n2. Choice Rubric Selection:");
    println!("   • Selected    : {}", choice.selected);
    println!("   • Confidence  : {:.4}", choice.confidence);
    for (opt, prob) in &choice.distribution {
        println!("     - {:<18} : {:.4}", opt, prob);
    }

    // 3. Instant Guardrails (<1µs)
    let guard = rx.guardrail(state);
    println!("\n3. Guardrail Security Audit:");
    println!("   • Is Safe?    : {}", guard.is_safe);
    println!("   • Blocked?    : {}", guard.blocked);
    println!("   • Risk Score  : {:.2}", guard.risk_score);

    println!("\n==================================================================");
    println!("✅ Rust System-1 execution complete. Zero external crate dependencies.");
    println!("==================================================================");
}

pub fn encode(&self, text: &str) -> [f32; 384]

Encodes input text into an L2-normalized 384-dimensional vector.

pub fn similarity(&self, text_a: &str, text_b: &str) -> f32

Computes cosine similarity between two text strings.

Trait Implementations

impl Clone for Reflex

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Reflex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Reflex

fn default() -> Self

Returns the “default value” for a type.