Independent Systems Laboratory

High-assurance cognitive infrastructure for autonomous AI agents.

Perseus Computing develops pure-Rust crates for microsecond context budgeting, encrypted local memory concurrency, and tamper-evident audit logs.

100% Pure Rust Zero Cloud Telemetry MIT Licensed Published on crates.io

CORE_SUITE_TELEMETRY ACTIVE

Harpe p50 Latency: 1.72 µs

Kibisis Throughput: 1.74M+ ops/s

Argus Tamper Detection: 46 µs

LongMemEval-S Recall@10: 98.20%

Swarm Split-Brain: 0 Detected

System Data Path

Autonomous Execution & Cognitive Bus

INTERACTIVE SCHEMATIC // SELECT NODE TO INSPECT

HARPE // ARCHITECTURAL SPECIFICATION CONCURRENCY: SINGLE THREAD O(LOG N)

State Transition Invariant

Eviction occurs deterministically through explicit priority policies (Fifo, LowestPriority, TruncateTail, LeastRelevant). Context ceiling is enforced with absolute token bounds before model inference invocation.

Mechanical Guarantees:

✓ Zero LLM-in-the-loop hallucination or prompt degradation during pruning
✓ 1.72 µs median pruning latency across 128k context allocations
✓ Deterministic token ceiling reduction up to 69.5%

HARPE_TYPE_INTERFACE.rs CARGO_BUILD

pub struct TokenBudget {
    pub total_budget: usize,
    pub reserved_completion: usize,
    pub reserved_tools: usize,
    pub safety_margin: usize,
}

pub enum PrunePolicy {
    Fifo,
    LowestPriority,
    TruncateTail,
    LeastRelevant,
}

Core Stack

Crate Directory & API Reference

harpe

v0.1.0-alpha.2 Pure Rust

Deterministic context window budgeting and priority token pruning. Harpe governs agent token allocations before inference calls to eliminate rate overflows and bounded degradation.

crates.io/crates/harpe github.com/harpe

Architectural Guarantees

Sub-Microsecond Latency

p50 execution under 1.72 µs ensures budgeting operations incur zero human-discernible or pipeline overhead.

Deterministic Pruning Curves

Explicit policies (Fifo, LowestPriority, TruncateTail, LeastRelevant) guarantee reproducible prompt assembly across runs.

Zero-Allocation Steady State

Pre-allocated token pools prevent heap fragmentation in high-frequency multi-turn agent execution loops.

Implementation Example

use harpe::{TokenBudget, PrunePolicy};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize token budget with strict allocations
    let mut budget = TokenBudget::new(8192);
    budget.reserved_completion = 1024;
    budget.reserved_tools = 512;
    budget.safety_margin = 128;

    let available = budget.available_context();
    assert_eq!(available, 6528);

    // Verify context limits prior to inference execution
    let prompt_tokens = 5400;
    if budget.is_exceeded(prompt_tokens) {
        println!("Pruning triggered under policy: {:?}", PrunePolicy::LowestPriority);
    } else {
        println!("Context allocation verified: {:.2}% utilized", budget.utilization_pct(prompt_tokens));
    }
    Ok(())
}

kibisis

v0.1.0-alpha.2 Pure Rust

Local-first encrypted cognitive memory vault with atomic concurrency leases. Built to isolate multi-agent workspace memory without central database servers.

crates.io/crates/kibisis github.com/kibisis

Architectural Guarantees

Atomic SWMR Lease Locks

Single-Writer Multi-Reader concurrency locks prevent conflicting state updates across concurrent agent threads.

ChaCha20-Poly1305 Cryptography

Memory envelopes are encrypted locally before committing to disk with Argon2id key derivation.

Partition Resilient

Sustains 1,745,000+ lease acquisitions per second with zero race conditions under 100% thread contention.

Implementation Example

use kibisis::{MemoryEntity, LeaseManager};
use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut manager = LeaseManager::new();
    let entity = MemoryEntity::new(
        "trajectory_state",
        "agent_subgoal_42",
        "Target hash verified: 0x8a92... committed."
    );

    // Acquire atomic write lease with strict 50ms TTL
    let lease = manager.acquire_write_lease("agent_subgoal_42", Duration::from_millis(50))?;
    println!("Acquired write lock token: {:?}", lease.token);

    // Commit payload into encrypted envelope
    manager.commit_entity(lease, entity)?;
    println!("Entity committed atomically under local envelope.");
    Ok(())
}

argus-ledger

v0.1.0-alpha.2 Pure Rust

Tamper-evident append-only SHA-256 provenance and audit ledger. Produces cryptographic execution receipts for all agent decisions, actions, and memory modifications.

crates.io/crates/argus-ledger github.com/argus

Architectural Guarantees

Single-Bit Tamper Detection

Detects corrupted or altered bytes across 100,000 blocks in 46 µs with immediate fail-closed state halt.

Cryptographic Hash Chains

Each record incorporates the preceding event hash, creating an immutable Merkle DAG rooted at genesis.

Zero Remote Dependency

Pure offline cryptographic verification requiring no cloud attestations, third-party nodes, or network calls.

Implementation Example

use argus_ledger::{AuditEvent, AuditLedgerWriter};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut ledger = argus_ledger::MemoryLedger::new();
    
    // Append verified execution step
    let event = ledger.append(
        "TOOL_INVOCATION",
        "agent:perseus-runtime-0",
        r#"{"action":"git_commit","sha":"a9f24c"}"#
    )?;
    
    println!("Appended sequence #{}: Hash {}", event.sequence, &event.event_hash[0..16]);

    // Perform audit chain verification
    let report = ledger.verify_chain()?;
    assert!(report.valid, "Tamper detected in sequence chain");
    println!("Audit chain validated: {} blocks verified intact.", report.total_events);
    Ok(())
}

Empirical Performance

Benchmark Suite & Rig Telemetry

ENVIRONMENT: BARE METAL LINUX X86_64 // RELEASE PROFILE (LTO=FAT)

HARPE LATENCY (p50)

1.72 µs

Evaluated across 100,000 budgeting decisions with 128k context ceilings.

KIBISIS THROUGHPUT

1.74M+

Lease operations/sec sustained under multi-threaded agent contention.

ARGUS TAMPER HALT

46 µs

Fail-closed verification time upon single-bit mutation across 100k events.

LONGMEMEVAL-S RECALL

98.20%

Recall@10 over 500 instances across 23,854 historical sessions in 7.45s.

Subsystem Crate	Evaluation Condition	Metric	Measurement	Verification Invariant
harpe	Context Pruning (128k Token Limit)	p50 Latency	1.72 µs	Deterministic eviction without token distortion
harpe	High Contention Peak Window	p95 Latency	4.88 µs	Strict sub-5µs bounding on all eviction curves
harpe	Dynamic Multi-Turn Compression	Ceiling Reduction	69.50%	Prevents context runaway while retaining core trajectory
kibisis	Concurrent Read/Write Leases	Throughput	1,745,000+ ops/s	Zero data races under 100% thread contention
kibisis	10-Node Edge Swarm Partition	Split-Brain Count	0 Errors	100% state convergence under 50% simulated packet loss
argus-ledger	Append Event to Merkle DAG	Append Latency	4.12 µs	SHA-256 continuous hash continuity preserved
argus-ledger	Single-Bit Corrupt Inspection	Detection Latency	46.00 µs	Immediate fail-closed validation rejection

REPRODUCE_BENCHMARKS: $ cargo run --release -p perseus-benchmarks

{
  "suite": "perseus-benchmarks",
  "version": "0.1.0-alpha.2",
  "rig": {
    "os": "Linux 6.18.38-Unraid x86_64",
    "compiler": "rustc 1.85.0 (nightly)",
    "profile": "release",
    "opt_level": 3,
    "lto": "fat",
    "cpu_affinity": "isolcpus=2-7"
  },
  "results": {
    "harpe": {
      "p50_latency_micros": 1.72,
      "p95_latency_micros": 4.88,
      "ceiling_reduction_pct": 69.5,
      "allocations_per_cycle": 0
    },
    "kibisis": {
      "ops_per_second": 1745280,
      "sustained_writes_per_sec": 2140000,
      "lock_contention_races": 0,
      "recovery_time_ms": 0.42
    },
    "argus": {
      "append_latency_micros": 4.12,
      "tamper_detection_micros": 46.0,
      "hash_primitive": "SHA-256",
      "fail_closed_verified": true
    },
    "longmemeval_s": {
      "instances": 500,
      "total_sessions": 23854,
      "runtime_seconds": 7.45,
      "recall_at_1": 0.872,
      "recall_at_10": 0.982,
      "mrr": 0.9111
    }
  }
}

Distribution & Source

Official Online Presence & Repositories

CODE_ORGANIZATION PUBLIC GIT

Perseus-Computing-LLC

Primary GitHub organization hosting pure-Rust source trees, benchmark test beds, and CI validation suites.

github.com/Perseus-Computing-LLC

CRATES_REGISTRY PUBLISHED

crates.io / lib.rs

Published packages ready for instant cargo compilation across x86_64 and aarch64 architectures.

crates.io/crates/harpe v0.1.0

crates.io/crates/kibisis v0.1.0

crates.io/crates/argus-ledger v0.1.0

API_DOCS DOCS.RS

docs.rs Specification

Complete rustdoc generation including memory safety invariants, error types, and trait definitions.

docs.rs/harpe docs

docs.rs/kibisis docs

docs.rs/argus-ledger docs

High Assurance Posture

Security Invariants & Government Compliance Records

Perseus Computing maintains active compliance records and government self-assessments. All components are written in Rust from scratch without third-party proprietary dependencies.

●

Entity Identifiers & Registration

CAGE: 22JC5 | SAM.gov UEI: PJS2LW7HAK35 | NAICS: 541715 | Austin, TX

●

SPRS NIST SP 800-171 Self-Assessment

UID SB00157695 | Score 110/110 posted to SPRS (assessed 2026-08-04)

●

CMMC Level 2 Final Self-Assessment

UID S200069604 | Score 110/110 self-classified (assessed 2026-08-06)

●

DD2345 Defense Logistics JCP

Application #35743 pending official assignment

Official Executive Brief

1-Page Systems Capability Summary (PDF)

Download Brief

Direct Technical Channels

Inquiries & Security Coordination

Direct communication channels for systems architects, researchers, and security disclosures. Encrypted correspondence preferred for vulnerability reporting.

General & Systems Inquiries

contact@perseuscomputing.com

Vulnerability Disclosure & Security

security@perseuscomputing.com

PGP Master Key Fingerprint

4A8E 2F1C 89B0 51E3 D6C2 7B94 F02A 198C 3E7D 5B12