Personal notebook / Applied AI
Engineering projectsI have built the application and backend layers around AI agents, plus working audio-processing and machine-learning components. My focus is the point where model output becomes a tool action, a user-visible answer or a decision that needs to survive failure. The published case studies and source references document those boundaries.
Implementation areas
I implemented typed tool contracts and first-party API gates that keep identity, tenant permissions and side effects outside the model’s authority.
Implementation: Typed-tool execution models and backend integration
I built repeatable evaluation fixtures and failure-path checks so changes to tool policies, prompts and integrations have concrete regression evidence.
Implementation: Deterministic evaluations implemented
I implemented classification models and deterministic tests to isolate feature scaling, neighborhood choice, data coverage and distribution shifts.
Implementation: Working classifier implementation and controlled experiments
I separated native inference interfaces from backend policy, with hardware, latency, model versioning and offline behavior treated as explicit integration constraints.
Implementation: Swift/Kotlin inference integration interfaces implemented
Execution architecture
External data
The user prompt, retrieved content or network response is not a source of privilege.
Probabilistic component
Generated text and tool-call proposals are predictions, not authoritative instructions.
Trusted policy enforcement
The backend checks schema, identity, resource tenancy, capability scope and approvals before side effects.
Trusted service
Execute only allowed operations, use bounded retries, record decision reasons without leaking secrets.
Operational feedback
Replay regression fixtures, track failure modes and change model or prompt versions with a rollback path.
A system prompt is not the authorization boundary. The executor must validate permissions and resource ownership even when a model proposes a plausible action.
Voice agents / production integration patterns
I built the workflow gateway, signed CRM event handling, deterministic agent evaluations, reliability models and native iOS/Android callback integrations. The common thread is control over what happens after an agent proposes an action.
Voice agent engineering projectsSPEECH / MODELING / REAL-TIME INFERENCE
I built and measured five local audio projects: speech-to-text evaluation, vector-quantized neural audio modeling, TTS prosody planning, streaming endpointing, and reproducible model training and ablations. They connect the model layer to the voice-agent systems I work on.
Inspectable engineering work
I published the backend and security reference code that accompanies my systems work. The agent and audio-model projects have separate technical case studies; they use their own test results rather than borrowing credibility from unrelated demos.
I built and tested the request-fingerprint and idempotency code that controls repeated agent-triggered API writes.
Inspect public sourceI built a single-process challenge-consumption guard and exercised replay, mismatched identity and expiry cases.
Inspect public sourceI documented object-level authorization, retry and trust-boundary failures with deterministic test fixtures.
Explore evidenceDated notes, reproducible tests and context for published code. Dated engineering changes, test results and source-linked implementation notes.
Explore evidenceMobile and edge ML
I developed Swift and Kotlin inference adapters that keep model execution separate from backend authorization. On-device inference also means handling CPU/GPU/Neural Engine variation, thermal throttling, model packaging, versioning, offline behavior and battery costs. The adapters are implemented; any accuracy or performance claim belongs to a specific trained model and device test.
Measure cold-start latency, CPU/GPU/Neural Engine selection, memory pressure, model integrity and behavior when offline.
Apple Core ML docsCompare runtime acceleration and quantization tradeoffs, download/version verification, device compatibility and privacy costs.
Google LiteRT docsThe production boundaries I use to review agent integrations:
