Backend & AI Infrastructure Engineer Building systems where AI behavior is predictable, costs are controlled, and data models don't lie.

I design and ship backend infrastructure with a focus on reliability and correctness — AI routing systems that control inference cost, agent harnesses that make model behavior auditable, and financial tools built on integer arithmetic instead of floating-point optimism. My projects reflect a consistent preference for systems that fail loudly, log honestly, and scale without accumulating hidden technical debt.

Beyond that core, I build in public across mobile and games: an on-device Android LLM host, a Game Boy Advance emulator core, and a few strategy and RPG prototypes. The through-line is the same — deterministic behavior, explicit boundaries, and claims you can verify instead of take on faith.

Babel AI systems fail in production not because the model is wrong, but because agent behavior is inconsistent, unversioned, and impossible to audit. Babel is an open-source agent harness for real software work: a local coding agent with a conversational chat loop, explicit plan and deep modes, and an inspectable Prompt OS underneath. Around the model it composes a deterministic control surface — controller gates, mode policies, isolation profiles, revision-bound verification, completion authority, and hash-linked evidence — so the operating instructions stay visible and testable. (Apache-2.0)

Prismatix Running every prompt through the most capable model is expensive and slow. Prismatix is a cost-aware multi-provider AI chat client: each request is classified into a routing role and mapped to a curated, priced model through the OpenCode model hub, and the UI explains every choice. Cost safety is fail-closed — if a price is unknown, the request is rejected rather than silently re-routed to something more expensive. One normalized SSE stream spans every gateway and protocol. Direct Anthropic/OpenAI/Gemini/NVIDIA/DeepInfra routes remain as an explicit legacy fallback, not the default path. (MIT)

MonteCarlo-Ledger Personal finance software that rounds incorrectly or simulates with too few runs gives you false confidence in your projections. MonteCarlo-Ledger is a local-first finance CLI and API with a ledger-first SQLite core that stores monetary values as integer cents — eliminating floating-point rounding errors at the data layer — and runs bounded Monte Carlo simulations to produce safe-to-spend projections grounded in variance, not averages. The companion Android app adds deterministic bill pacing and AES-GCM encrypted backups. (MIT)

Scout (MIT) Most developers have no systematic way to find which open-source projects are actively paying for help. Scout is a local CLI that finds paid open-source bounty candidates and packages each one into artifacts a coding agent can pick up and execute — Cursor, Claude Code, Codex, Gemini, or anything else able to follow a runbook. Policy gates are enforced against Scout's own operations rather than trusted to the external agent, and the work stays local. This is the most complete open-source project on the account: CI, CONTRIBUTING.md, CHANGELOG.md, .editorconfig, a Dockerfile, architecture ADRs under docs/, and a shipped v0.6.2 release.

PrismLocal — Android app for private, on-device GGUF LLM inference. Embeds a C++20 llama.cpp runtime behind a thread-safe JNI bridge, with chat, tool dispatch, and local document retrieval (RAG). (Apache-2.0)

GBA_Emulator — Portable Game Boy Advance emulator core (C++17), validated against 13 public mGBA test suites with a committed regression baseline and a credibility matrix. (Apache-2.0)

GbaEmulatorAndroid — Android development shell for the GBA_Emulator core: Compose UI, SAF ROM loading, a SurfaceView 240x160 viewport, Oboe audio, and a JNI/CMake bridge into the sibling C++ core. (Apache-2.0)

MonteCarloLedger-Android — Kotlin/Compose financial ledger app focused on deterministic forecasting, bill pacing, and encrypted backups. No network dependency. (Public source, all rights reserved)

ProofPath — Offline-first React Native learning system that turns lessons into reviewer-ready portfolio evidence, built around active engineering exercises instead of passive content. (Public source, all rights reserved)

DragonWake — Multiplayer web MMORTS MVP beta: async city builder plus map combat, with a server-derived Dragon Presence lifecycle and canonical save migration. (Public source, all rights reserved)

Orbitscar — Clean-room sci-fi strategy prototype: a deterministic headless battle/colony simulation in one package, declarative content validation in another, and an accessible DOM command surface beside a Phaser tactical view. (Public source, all rights reserved)

ManaNet — Cyber-themed tower defense game and a Godot 4.6 / GDScript port of the Python/Kivy TowerDefenseKivy. (Public source, all rights reserved)

GravityPivot — Hyper-casual physics space-navigation game: tether to gravity anchors to orbit, swing, and sling through an infinite cave. Refactored out of a single-file prototype into DI-decoupled modules on TypeScript + Vite, with Vitest coverage. (Public source, all rights reserved)

reliquary — Medieval-fantasy monster-binding RPG prototype: elemental battles, creature evolution, binding, party and box storage, saves, and keyboard/touch controls. (Public source, all rights reserved)

WallpaperCropFixer — On-device Android utility that positions crops around faces with ML Kit and handles EXIF orientation correctly. Requests only SET_WALLPAPER; photos never leave the device. (Public source, all rights reserved)

ExactUploadFixer — Android (Kotlin/Compose) utility that resizes and compresses images to meet exact upload requirements — dimensions and file size — for things like passport or visa-photo submissions. Free manual tier plus Pro presets via Play Billing, with an Amazon flavor. (Public source, all rights reserved)

babel-origin-site — Public static origin and bounded demo front door for Babel. (Public source, all rights reserved)

Not everything here has a public repository. These projects are real and shipped, but the source is not published — the only thing to inspect is the live product.

GPCGuard (private repository — source not published) Privacy compliance is a legal requirement, but most engineering teams have no systematic way to verify it. GPCGuard is a GPC/CCPA compliance SaaS that detects and reports on Global Privacy Control opt-out signals as required under CCPA/CPRA, CPA, CTDPA, and NJDPA. It includes a Python scanner suite, Stripe billing, a Next.js dashboard, and Supabase Edge Functions on the backend. Security audit complete; live at gpcguard.app.

These projects are designed to be verifiable, not just described. Start with the live surfaces:

• GPCGuard — live product: https://www.gpcguard.app (private repo — product surface only, no public source)
• Prismatix — live app: https://prismatix-app.vercel.app · routing and cost behavior documented in the repo README
• Babel — latest release and a public release gate in CI
• Scout — v0.6.2 release, CI, CONTRIBUTING.md, and architecture ADRs in docs/architecture/
• GBA_Emulator — green mGBA suites plus a committed credibility matrix baseline
• Babel origin site — https://babel-origin-site.vercel.app

Then read how each behaves under the hood.

What actually happens:

• A simple query (e.g. "summarize this text") is routed to an economy/fast role backed by a low-cost model
• A complex task (e.g. code generation or multi-step reasoning) is routed to a strong/max role
• Every Auto-routed answer exposes the chosen role, model, gateway, reason, whether a fallback was used, and the estimated cost basis
• An unknown price fails the request closed rather than quietly spending more; provider fallback may only re-route to a cheaper priced model
• All responses stream through a single normalized SSE interface regardless of which provider handles the request

What to look for in the code:

• Role-based routing decisions with deterministic in-role fallbacks
• No provider-specific branching in client-facing code
• Consistent streaming output regardless of backend model
• Cost safety enforced server-side (supabase/functions/router/pricing_registry.ts)

What actually happens:

• The selected Prompt OS stack is previewable before any model acts
• The stack is composed into a validated, catalog-backed instruction plan before execution begins
• Governance layers decide what a mode may do: controller gates, isolation profiles, and mode policies
• Completion is verified against a specific repository revision rather than asserted by the model
• If the plan is incomplete, underspecified, or violates interface contracts, execution is blocked with an explicit failure state — not silently degraded

What to look for in the code:

• Preview → Compose → Validate → Execute flow on every run
• No direct model execution without a validated instruction plan
• Regression and release-gate tests that catch behavioral drift before it ships
• Reproducible outputs given identical inputs and catalog state

What actually happens:

• All monetary values are stored as integer cents — no floating-point arithmetic at the data layer
• Income and expenses are projected forward across a 90-day horizon
• Bounded Monte Carlo simulations stress-test each projection
• The system outputs a safe-to-spend value derived from the worst-case distribution, not simple averages

What to look for in the code:

• Integer-only money storage throughout — no float for currency values
• Deterministic simulation seeding — identical inputs produce identical projections
• Clear separation between raw ledger data and derived projection output
• Ledger-first accounting: balances are derived, never treated as an editable source of truth

These projects share a set of properties that I actively design toward:

Determinism over convenience Same input should produce the same output. Variability is controlled and observable, not accidental.

Fail-fast over silent degradation Invalid states are blocked and surfaced with explicit reasoning. "Best effort" results that hide errors are worse than hard failures.

Cost as a first-class constraint Routing decisions, budget enforcement, and simulation design are all built with resource usage in mind — not added as an afterthought.

Correctness enforced at the lowest level Integer money storage, catalog-backed instruction plans, priced routing registries. Correctness bugs at the data layer propagate everywhere; fix them at the source.

Specific decisions made across these projects — what I chose, what I ruled out, and where the current design has limits.

Prismatix: runtime routing over static configuration, safety over availability Routing could have been a config file — map task types to models at deploy time. I built role-based scoring at request time instead because static config can't adapt to prompt length, context depth, or mixed-intent queries. The tradeoff is added latency on the scoring step and a complexity score that needs tuning. The harder call was fail-closed cost safety: when a model's price is unknown, or discovery returns no usable priced model for a role, the request fails with a readable error instead of silently falling back to a costlier provider. That means occasional hard failures, but no silent cost surprises. Provider fallback is deliberately constrained to cheaper priced models; broad automatic failover without proper logging first would make failures harder to diagnose, not easier.

Babel: a governed agent loop over a bare model call The simplest agent is a model with tools and a loop. Babel composes a validated, catalog-backed instruction plan and wraps execution in explicit gates because unaudited behavior is invisible until it reaches production. The tradeoff is a heavier request path and more moving parts. Where it breaks: the catalog resolver assumes instruction entries are stable between deployments — hot-swapping catalog entries mid-session is not currently safe.

MonteCarlo-Ledger: integer cents over decimal types Most finance software uses DECIMAL or float for readability. I use integer cents because rounding behavior in DECIMAL arithmetic is database-specific and float accumulates error across summation. The tradeoff is that every input and display layer must convert explicitly — there's no implicit formatting. What I intentionally did not build: multi-currency support. Adding it correctly requires exchange-rate versioning tied to transaction timestamps, which is a separate system; adding it naively would corrupt historical projections.

• Add full request/response tracing dashboards for Prismatix (latency and cost per route, per provider)
• Introduce persistent execution logs and replay tooling for Babel to support post-hoc debugging
• Expand MonteCarlo-Ledger with real-time ingestion and user-configurable scenario parameters
• Replace the remaining emulator interactive oracles with deterministic frame-hash coverage as the GBA core matures

Babel and Prismatix are the most architecturally complex. Scout is the best-documented open-source project. GPCGuard is the most complete product, though its source is not public. PrismLocal and GBA_Emulator show the systems-native side. MonteCarlo-Ledger is smaller but demonstrates a data-correctness mindset that shows up consistently across all of the work.

TypeScript · Python · Kotlin · C++17 · React · Next.js · React Native · Deno · Supabase · SQLite · Android (Jetpack Compose) · Godot (GDScript) · Phaser

Backend systems, AI infrastructure, and applied ML tooling — currently agent harnesses, cost-aware routing, and on-device inference. Open to internship and early-career roles in software engineering, ML infrastructure, or backend development.

LinkedIn

This profile repository is publicly viewable for portfolio and project-navigation purposes. It is not open source. See LICENSE for permitted use. Referenced projects and third-party materials retain their own licenses.