Skip to main content

Selected Engineering Work

Systems work, explained with evidence.

Start with Aether and Sentinel for the clearest view of how I frame problems, define architecture boundaries, make trade-offs, and validate an implementation.

ProblemWhat constraint or failure mode made the system necessary?
My ContributionWhich architecture and implementation decisions did I own?
EvidenceWhat was actually tested, demonstrated, or deployed?

Recommended Starting Points

Two projects, end-to-end reasoning.

Aether demonstrates platform integration; Sentinel goes deeper on AI-safety product and policy design. Both separate implemented evidence from future production claims.

Aether

Reference ImplementationIndependent BuildPlatform

Solution

An independently built, production-oriented Safe GenAI reference implementation integrating content safety, traffic governance, ML inference, and observability.

Problem
AI applications often assemble traffic control, safety, inference, and observability as disconnected layers with inconsistent failure behavior.
My Contribution
Defined the shared request lifecycle and integrated Atlas, Sentinel, Hyperion, and MonitorX behind explicit service and deployment contracts.
Evidence
Local integration testing
Read Case Study Open Platform Demo View Source
Request Flow
Client
->
Atlas
->
Sentinel
->
Hyperion
MonitorX - Observability
4 core components All healthy Docker Compose

Sentinel

Reference ImplementationIndependent BuildAI SecurityFormer Public API

Solution

An independently built AI supervision reference implementation for enforcing safety, compliance, and quality policies around LLM applications.

Problem
LLM applications need enforceable safety decisions without sending every request through the slowest and most expensive detector.
My Contribution
Designed and implemented the tiered inspection pipeline, verdict contract, API packaging, former hosted deployment, and browser simulation.
Evidence
Local functional testing; formerly served via RapidAPI
Read Case Study Open Safety Simulation View Source
➜ sentinel audit --prompt "Hack wifi"
Analyzing...
Policy: Safety.HarmfulContent
Verdict: FAIL
"Request violates safety protocols."
➜ _

Platform Systems

Explore a specific engineering capability.

Gateways, inference, observability, agent safety, and orchestration—each scoped by the problem, my contribution, and its current validation evidence.

Atlas

Reference ImplementationLLM GatewayDistributed Systems

Solution

An independently built, production-oriented LLM traffic and quota gateway using Redis, FastAPI, and Prometheus, validated through a local automated test suite.

Problem
Shared LLM endpoints need enforceable quotas, routing, and backpressure before traffic reaches scarce or expensive model capacity.
My Contribution
Designed and implemented the FastAPI gateway, Redis-backed controls, routing behavior, metrics, and local automated test suite.
Evidence
46 automated tests passed locally
View Source Open Gateway Simulation

Guardian

PrototypeAgent SafetyPlatform

Solution

An agent-action firewall prototype with dynamic Python rules, Python AST checks, and heuristic content inspection before tool execution.

Problem
Agent tool calls can translate untrusted model output into dangerous actions before conventional content filters can intervene.
My Contribution
Built the structured action contract, analyzer chain, Python AST checks, mutable policy rules, and browser-only demonstration.
Evidence
Four core allow/block cases passed locally; no automated tests; hosted API currently unavailable
View Source Open Interactive Demo

Hyperion

Reference ImplementationML PlatformKubernetes

Solution

Production-oriented ML inference platform reference implementation exploring GPU-aware model serving, request batching, caching, Kubernetes autoscaling, and observability.

Problem
Inference services must balance model lifecycle, batching, caching, scaling, and observability without hiding hardware-specific trade-offs.
My Contribution
Implemented the serving reference architecture, batching and cache paths, autoscaling examples, and operational instrumentation.
Evidence
82 tests passed locally; 7 current failures under audit
View Source Open Interactive Demo

Strategos

IncubatingControl PlaneIncubation

Solution

An incubating agent-orchestration prototype with a ReAct loop, SQLite event replay, approval-gated local tools, and tiered keyword memory.

Problem
Agent workflows need recoverable state, explicit approvals, tool boundaries, and inspectable memory instead of an opaque reasoning loop.
My Contribution
Built the ReAct loop, approval-gated tools, SQLite event replay, workflow recovery example, and tiered memory prototype.
Evidence
Four executable examples passed locally; no automated test suite
View Source Open Interactive Demo

MonitorX

Reference ImplementationML PlatformObservability

Solution

Production-oriented ML observability reference implementation with SDK instrumentation, metrics collection, drift signals, alert routing, and an InfluxDB-backed dashboard.

Problem
AI teams need one operational view of inference behavior, resource pressure, drift signals, and alert state across model services.
My Contribution
Implemented the instrumentation SDK, collectors, alert lifecycle, storage adapter, API surface, and dashboard reference path.
Evidence
97 non-API tests passed locally; API suite collection blocked
View Source Open Interactive Demo

Experiments / Labs

Smaller explorations with narrower scope.

Useful demonstrations and research tools without implying the same maturity or ownership depth as the case studies above.

AerialView

PrototypeFinancial AnalyticsPython

Solution

Independently built finance analytics prototype for exploring historical market data, technical indicators, risk metrics, correlations, and charting through Streamlit and a Python CLI.

Problem
Exploring historical market behavior often requires switching between disconnected indicator, risk, comparison, and charting tools.
My Contribution
Built the Streamlit analysis views, Python CLI, indicator calculations, correlation workflow, and Plotly visualizations.
Evidence
Python source parses; repository screenshots document local use; one network-dependent automated test
View Source Open Interactive Demo

FairTune

PrototypeEval-as-CodeResearch Prototype

Solution

Early-stage LLM fine-tuning and eval-as-code experiment covering QLoRA scaffolding, utility and safety checks, comparison dashboards, and planned fairness gates.

Problem
Fine-tuning workflows often treat utility, safety, and fairness evaluation as separate manual checks instead of promotion gates.
My Contribution
Created QLoRA training scaffolding, utility and safety checks, comparison reporting, and the initial eval-as-code workflow.
Evidence
Python source compiles; no automated tests; fairness metric is a placeholder
View Source Open Evaluation Demo

Capability Map

What the portfolio is designed to demonstrate.

The projects overlap intentionally: the value is in connecting safety, infrastructure, and operations into coherent systems.

Platform Architecture

Boundaries, control planes, deployment, and end-to-end system composition.

AetherAtlasStrategos

AI Safety

Supervision, policy enforcement, semantic firewalls, and defense in depth.

SentinelGuardianAether

ML Infrastructure

Inference performance, observability, drift detection, and model operations.

HyperionMonitorXFairTune

Distributed Systems

Traffic governance, durable workflows, quotas, and asynchronous execution.

AtlasStrategosHyperion

Maturity and evidence labels describe what each repository currently demonstrates; they are not claims of external adoption.

Continue the Conversation

Need a technical leader who connects architecture to operations?

I work across AI infrastructure, distributed systems, safety, capacity, and reliability—and I stay close enough to implementation to make the trade-offs concrete.

Start a Conversation See How I Work