I design and build deterministic software architectures optimized for local-first execution environments. My engineering focus centers on zero-cloud, air-gapped systems orchestration, localized retrieval models, and developer toolchains designed to run safely on native hardware.

As a Computer Science student at Southern New Hampshire University, my core development philosophy is rooted in low-level resource control and strict compile-time safety. While I have historical grounding building native applications in C++, I program primarily in Rust. I leverage its type system and memory ownership model to eliminate runtime invalid states and prevent memory regressions before a single byte hits the disk.

A high-precision local AI agent harness, data science runtime, and terminal intelligence platform running 100% on native silicon.

• Lead Computational Researcher Mandate: Engineered a verifiable computation layer that rejects language model hallucinations for mathematical and physics vectors. Integrates high-precision symbolic solvers, unit-aware dimensional analysis, and an empirical Big-O complexity auditor that runs performance regressions against varying input sizes to mathematically verify algorithmic throughput.
• Analytical SQL & Dataset Ingestion: Built a native streaming SQL data engine for local files (CSV, JSON, SQLite) supporting automatic schema inference and transactional batching. Pairs with a secure Python sandbox execution environment to run statistical discovery, trend calculations, and generate inline data visualizations directly from production datasets.
• High-Performance Data & Search Indexing: Developed a hybrid codebase index pairing an SQLite FTS5 BM25 search engine with a local vector embedding layer. Implements automated background data backfills, path-segment room taxonomy routing, and an active-room memory bias engine to optimize retrieval scores based on hot-subsystem editing velocity.
• Algorithmic Repository Mapping: Utilizes tree-sitter AST parsing to extract definitions and references across entire workspaces, running a localized PageRank algorithm via petgraph to weight and map core execution modules directly into prompt contexts with zero runtime network dependency.
• Proactive Security & Privacy Filtering: Enforces an aggressive, two-tier identity-stripping privacy gateway before any diagnostic data interfaces with external layers. Combines a fast compiled regular expression pass (--edge-redact) with a dedicated local summarizer model (--semantic-redact) to programmatically sanitize usernames, hostnames, MAC addresses, and credentials.
• Full-Stack Telemetry Matrix: Monitors a monolithic 128+ read-only headless topic catalog mapping low-level Windows kernel metrics, process I/O read/write thrashing counters, network socket allocations, memory pressure, and real-time hardware trends directly to an interactive, mouse-enabled TUI.

An industrial Python automation framework and actor orchestration engine running inside the sandboxed Unreal Editor for Fortnite process.

• Slate-Tick Dispatch Architecture: Resolved Unreal Engine's primary thread-lock constraint by engineering a two-layer asynchronous bridge. External Model Context Protocol (MCP) HTTP commands are safely ingested via a background FastMCP server, queued, and deterministically dispatched on UEFN's main execution thread using native Slate pre-tick callbacks (register_slate_pre_tick_callback) to eliminate engine deadlocks.
• Algorithmic Asset Mapping: Orchestrated the first programmatic traversal and taxonomy mapping of the sandboxed Fortnite Creative device palette, systematically cataloging 4,698 device Blueprints across 35 structural categories from 24,000+ total assets.
• Four-Stage Security Plugin Gate: Implements a strict, zero-trust security perimeter for community plugin ingestion. Before runtime execution, unverified .py files are pushed through four blocking constraints: a 50 KB payload cap, an abstract syntax tree (AST) token scanner that blocks rogue socket, subprocess, and ctypes injections, API version mapping, and SHA-256 integrity hashing logged to an unalterable audit trail.
• Asynchronous Event-Loop UI UI: Drives a 26-tab dark-themed desktop dashboard driven by PySide6. The UI hooks cleanly into native Slate tick signals to facilitate synchronous interface state modifications and cross-tab search filtering over all 358 modules without micro-stuttering the main viewport's render thread.
• Dual-Layer World Schema Generator: Exposes a static 1.6 MB baseline schema mapping all core core engine/Fortnite classes alongside a dynamically generated project-level schema. This gives external tools a reliable object-property dictionary wrapper, completely dropping loose log-parsing overhead.
• Rigorous Test Automation: Backed by an automated, invasive 163-test regression suite running natively in-editor. It programmatically spawns actors, tests cross-module configurations, asserts state updates, and flushes environment state clean inside isolated undo windows using scoped editor transactions (unreal.ScopedEditorTransaction).

• Languages: Rust, C++, Python, TypeScript, Node.js, Verse Lang
• Databases & Caching: SQLite FTS5, PostgreSQL, MySQL, MongoDB, Redis, CosmosDB, Relational Schema Design, High-Velocity Index Tuning
• Systems Subsystems: PySide6 / Qt Framework, Win32 Core APIs, Slate Event Loops, WMI Telemetry Probes
• Local Protocols & Search: Model Context Protocol (MCP), FastMCP JSON-RPC, ONNX Runtime, Ollama, Hybrid Search Architectures
• Safety & Code Integrity: AST Syntax Trees, Scoped Editor Transactions, Automated SHA-256 Verification, Static Code Obfuscation Scanning

• Platform Hub: oceanbennett.com
• LinkedIn: linkedin.com/in/oceanbennett
• X / Twitter: x.com/oceanbennett