Platform Engineering • AI/ML Infrastructure • Distributed Systems • Developer Tooling

I'm a systems-focused software engineer building platforms across AI/ML infrastructure, deterministic compute, developer tooling, distributed systems, and full-stack applications.

My work spans:

• AI training, benchmarking & local inference infrastructure
• Deterministic and replayable execution systems
• Distributed compute architecture
• Developer platforms & tooling
• GPU/CPU-aware execution systems
• Full-stack applications
• Internal tools & workflow automation
• Operational and logistics software

I like owning difficult problems end-to-end, from architecture and runtime behavior to APIs, infrastructure, desktop applications, and user-facing interfaces.

Atlas Lab is a deterministic machine learning platform for creating, training, benchmarking, promoting, running, and evolving AI residents locally.

Rather than treating a model as a static artifact, Atlas Lab provides an end-to-end lifecycle:

curriculum → train → benchmark → promote → inference → evolve

• Local CPU and GPU-aware training architecture
• Resident-specific training and learned-state management
• Dataset and curriculum pipelines
• Benchmark suites and promotion workflows
• Local inference without requiring a hosted inference API
• Deterministic resident lifecycle management
• Seed-based resident identity and lineage
• Hardware capability discovery and execution selection
• Electron desktop application connected to the Atlas web platform
• Resident evolution and lifecycle visualization

Atlas Lab currently includes multiple specialized residents, including Nexus, its coding resident. Try it now @ www.trainatlas.dev

Tech: TypeScript, React, Electron, Node.js, Python, PyTorch, llama.cpp, Supabase, PostgreSQL, AWS

Nexus is Atlas Lab's coding-focused AI resident, built on a frozen 30B multimodal foundation with lightweight trainable resident adapters.

• 30B frozen foundation model
• 52-layer language stack
• Rank-8 LoRA adapters across attention projections
• ~7.3M trainable resident parameters
• Local CPU inference through llama.cpp
• Hardware-aware training execution
• Benchmark → promotion → inference lifecycle
• Persistent resident identity and learned state

The architecture separates the large frozen foundation from the resident's comparatively small learned state, allowing Nexus to evolve without reproducing or retraining the entire foundation model.

Focus: local AI, parameter-efficient training, inference infrastructure, model lifecycle systems

Contract OS is an experimental deterministic compute and platform architecture built around reproducible execution, distributed scheduling, runtime orchestration, and observable system behavior.

Its compute architecture includes Nine Compute, a deterministic execution layer designed around isolated compute regions and runtime instances.

• Deterministic runtime execution
• Distributed scheduler architecture
• Nine Compute regions and execution instances
• Replayable execution
• Deterministic pseudo-random execution primitives
• Runtime orchestration
• Developer platform tooling
• Platform administration systems
• Self-healing/drift detecting substrate architecture experiments
• Deterministic execution verification

Previous compute benchmarks have demonstrated multi-million-action-per-second raw execution throughput under controlled workloads.

Tech: TypeScript, Node.js, AWS, PostgreSQL, Supabase, PM2, distributed runtime architecture

Elemental Arena is an experimental game and simulation platform being developed around a custom rendering and runtime architecture rather than a traditional game engine.

• WebGPU rendering
• C++ systems
• Custom renderer architecture
• GPU lifecycle management
• Hardware capability detection
• Deterministic simulation
• Performance and content budgets
• Explicit GPU readiness contracts
• Reproducible execution
• Engine-level architecture

The project is being developed using explicit engine contracts, performance budgets, lifecycle boundaries, and evidence-backed architecture decisions.

Tech: C++, WebGPU, TypeScript, CMake, custom engine architecture

Internal software built to support material accountability and warehouse operations in an active shipyard environment.

• Government Furnished Material (GFM) tracking
• Commercial material management
• Tool and equipment accountability
• Gas bottle tracking across yard locations
• Calibration and compliance workflows
• Certification/document management
• Operational inventory visibility
• Production usage by warehouse personnel

Built from direct operational experience to replace fragmented manual workflows with centralized, searchable systems.

Outcome: Used in daily operations and led to discussions around broader implementation across warehouse operations.

Tech: React, TypeScript, Node.js, AWS, Supabase, PostgreSQL

A lightweight VS Code productivity extension built around an intentionally simple idea: developers shouldn't need to leave their workflow to remember to move.

• Organic Marketplace adoption
• Native VS Code status-bar integration
• Configurable movement reminders
• Snooze and timer state management
• Streak tracking
• Accessibility-aware UI
• Lightweight notification lifecycle
• Custom extension icon system

Built quickly, released publicly, and continuously improved based on real usage.

Tech: TypeScript, VS Code Extension API

A full-stack commerce platform built for a real small business to replace manual product and ordering workflows.

• Product and inventory management
• Secure payment processing
• Order lifecycle management
• Customer management
• Responsive storefront
• Mobile-focused purchasing experience
• Production deployment

Tech: React, TypeScript, Tailwind, Stripe, Supabase, PostgreSQL

Focus: local inference, parameter-efficient training, model lifecycle infrastructure, benchmarking, hardware-aware execution

• Build systems that solve real problems
• Understand the architecture, not just the interface
• Treat determinism and observability as engineering tools
• Design explicit lifecycle boundaries
• Measure before optimizing
• Keep user workflows simple even when the underlying system is complex
• Build for failure, recovery, and reproducibility
• Own systems end-to-end
• Ship working software

I'm currently exploring and building around:

Local AI & ML Infrastructure Training, inference, resident lifecycle management, learned-state persistence, and hardware-aware execution.

Deterministic Compute Replayable execution, distributed scheduling, deterministic runtimes, and reproducible system behavior.

GPU-Aware Systems Device discovery, capability negotiation, readiness lifecycles, execution selection, and WebGPU.

Developer Platforms Tools and abstractions that make complex systems easier to operate, debug, and extend.

Production Software Building practical applications around real operational workflows rather than isolated technical demos.

"Build useful things."