I build production AI, speech, and backend systems end to end.

From-Scratch Speech Model & Training-Data Engine

Built the lower-level ML and training infrastructure behind the speech system: a 730M-parameter AR + NAR neural-codec speech model trained from scratch on consumer GPUs, covering 13 languages, 17 speakers, and 6 emotional states with metadata conditioning. To make a 108,000-sample corpus trainable on limited hardware, I designed a custom memory-mapped binary dataset format for zero-copy loading and a Rust metadata pipeline for fast, validated data preparation — backed by an automated verification suite with ablation probes to catch silent training failures before they reach production.

• 730M-parameter AR + NAR neural-codec model trained from scratch on consumer GPUs
• 108,000-sample multilingual corpus — 13 languages, 17 speakers, 6 emotional states
• Published engineering report with a citable DOI (Zenodo)

Grounded RAG Portfolio Agent — a Chatbot That Validates Itself

The chat button on this page is a live, grounded assistant that answers questions about my papers and projects from an indexed, provenance-tracked corpus only — every answer cites its sources, and a Retrieval X-ray exposes the raw retrieved chunks with their real relevance scores. It ships behind a 48-case adversarial eval gate (answerability, refusal, prompt injection, credential traps), and a self-maintaining pipeline re-validates and redeploys it only when it still passes.

• 48/48 on the adversarial eval suite; retrieval hit@6 27/27 (hybrid retrieval: static embeddings + BM25)
• Self-maintaining — an eval-gated pipeline detects drift, re-tests, and redeploys only on a green suite; a red eval blocks the deploy
• The eval suite caught a real prompt-injection breach and a factual error in a published paper — both fixed pre-launch (paper republished as Zenodo v2)

GEO Observatory — Live AI-Crawler Observability Platform

A deployed observability platform that records how AI crawlers and search engines discover my sites. A daily collector pulls crawler events from Cloudflare’s GraphQL Analytics API into an append-only SQLite event ledger (raw payloads preserved, deterministic dedup hashing, hourly buckets), and a public dashboard exposes live per-crawler timelines — ClaudeBot, GPTBot, PerplexityBot, Googlebot — under a strict honesty policy: sampled aggregates labeled as such, temporal association only, no fabricated causation or confidence scores.

• Live in production — public dashboard with real data, collected automatically every day (systemd timer, hardened non-root service)
• Probe-gated integration — the Cloudflare GraphQL provider was built only after a verification probe confirmed the exact datasets and fields available on the plan
• Day-one catch — logged a spoofed “Googlebot” (a Google-Cloud scanner hunting for leaked .env files) within hours of the subdomain’s TLS certificate appearing in transparency logs

BedVibe TTS Platform

Built and deployed the user-facing BedVibe TTS product layer: authenticated accounts, token accounting, Stripe checkout and subscriptions, proprietary multi-voice speech generation endpoints, voice/language/emotion selection, custom voice support, token-aware generation, and production backend services for real user traffic. The product exposes creative speech controls such as Flow/Chaos generation parameters, voice warmth, equalizer and reverb, HD enhancement/denoise, an inline library of ~60 per-speaker expressive vocal effects (laughs — sarcastic, sinister, hysterical, escalating — gasps, breaths, coughs, throat-clears, wheezes, hiccups and shivers, and more) inserted by right-click, background ambience mixing, optional viseme timing output, and long-form audiobook/project workflows. Voices are proprietary models trained on curated datasets, and on a target-language change the product offers automatic text translation (for example English → Japanese) or keeps the original text to be spoken in the chosen language's accent. This card represents the deployed application and business system around the speech models — not the from-scratch model-training work itself.

• 13 languages with per-language accent synthesis and optional automatic translation
• ~60 inline expressive vocal effects per speaker, inserted directly into text
• In production: Stripe checkout + subscriptions with token-aware generation

The interface exposes direct generation and audio controls rather than a single opaque “generate” button. Flow controls speaking pace, allowing users to move delivery faster or slower. Chaos controls sampling temperature, allowing more stable or more varied output. Brightness is an EQ-driven tone control: lowering it emphasizes lower-frequency body, while increasing it reduces low-frequency weight and increases high-frequency presence; this can also help tame sharp sibilance. Space controls reverberation amount for a drier or more spacious voice presentation.

HD mode combines spectral and psychoacoustic enhancement with DeepFilterNet cleanup to improve perceived clarity and reduce unwanted noise. A separate diffusion enhancement path exists for further output-quality improvement, but it is disabled in the current interactive path because its latency is not suitable for live generation.

Each available voice can be auditioned through sample playback by selecting the performer portrait. The product supports 13 languages and, when a user changes the target language, asks whether to translate the text into that language or keep the original text and synthesize it with the selected language accent. Translation uses a local Argos Translate path, with a Google-based translation option available for paid subscription workflows where higher-quality translation is requested. Custom voice cloning is not enabled as open self-service; it is handled only for rights-cleared, permissioned requests.

Production Backend Infrastructure — Auth, Billing & Device Licensing

Architected and operate the full backend behind BedVibe's products: a fleet of independent services handling user authentication and registration, Stripe billing and webhook processing, device-bound (MAC-ID) software licensing, subscription and entitlement management, a TTS inference job queue, and security telemetry integrations. Runs on a self-managed Linux server behind nginx, with each service isolated as its own systemd unit and PostgreSQL as the shared data layer — provisioned and maintained at the operating-system level.

• 10 independent services, each isolated as its own systemd unit behind nginx
• Self-managed Linux server: PostgreSQL data layer, TLS, OS-level provisioning
• Replay-safe Stripe webhooks and MAC-ID device licensing running in production

BookProof — AI Book Summary Auditor

Built a reproducible workflow for auditing AI-generated book summaries and answers against long manuscripts. BookProof checks evidence grounding, missing details, unsupported claims, answer-term coverage, and evidence-term coverage. The underlying LongBook Verifier research package is published on Zenodo and includes retrieval baselines, model-output scoring, plots, reports, and a 240,767-word long-form stress-test benchmark, while excluding private manuscript text from the public release. A follow-up ablation study (Experiment C) diagnoses why hierarchical book RAG underperformed chapter-summary retrieval on this corpus — isolating first-stage chapter selection and neighbor-expansion dilution as the two failure modes — and is published as a separate Zenodo record.

• 240,767-word long-form stress-test benchmark
• Two published Zenodo records — research package + Experiment C retrieval ablation
• Evidence-grounding and retrieval-baseline scoring, fully reproducible

Built the workflow as a complete RAG/evaluation pipeline: ingestion, structure-aware chunking, retrieval baselines, citation-grounded generation checks, gold-question scoring, and controlled ablations across retrieval strategies.

Automated Failure-Mode QA Framework for Neural TTS — Published Technical Report

A backend-only, fully automated quality-assurance framework for a reference-based neural text-to-speech system. For each edge-case input it normalizes the text, runs ASR-independent structural audio checks (empty / short / long audio, long silence, clipping, loop/repeat, end-of-clip artifact), scores pronunciation with equivalence-aware WER/CER, and — where ASR is itself unreliable — isolates the case for review instead of guessing. Evaluated on 130 edge cases across 3 neutral voices (390 samples): zero structural audio-integrity defects. A one-time blinded human validation of the 42 ASR-uncertain cases (with 15 ASR-passed controls; controls 15/15) showed the quarantined zone is a genuine 45/55 mix — 19 real TTS mispronunciations and 23 ASR false-negatives — confirming quarantine-for-review is the correct design, and localizing the synthesizer's weak spot to short letters/acronyms. Published as a citable technical report with an explicit claims-and-limitations statement.

• 390 samples (130 edge cases × 3 voices) — zero structural audio-integrity defects
• Blinded human validation — 15/15 controls correct; quarantine design confirmed
• Published as a citable technical report (Zenodo DOI, CC-BY-4.0)

ttsproof — Open-Source TTS QA & Benchmark Library (PyPI)

Published the QA-framework method above as an installable open-source library: pip install ttsproof. It stress-tests any TTS engine through a one-command benchmark — structural audio checks that need no model (loops, silences, clipping, duration explosions), equivalence-aware WER/CER on canonical spoken form, and an ASR-uncertainty quarantine — then renders a self-contained HTML report with per-category score bars, waveforms, and audio players for every failure. Engines plug in via a command template or a Python callable; a regress command gates CI on category-level quality drops.

• Live on PyPI — pip install ttsproof (MIT, sole author)
• Benchmark Corpus 1.0 — 817 curated edge cases across 39 categories, versioned independently of the tool so published scores stay comparable
• Closed-source engines supported — documented SpeechSDK integration benchmarks commercial models (OpenAI, ElevenLabs, 17+ providers); shipped within a day of the request from the SpeechSDK team at Jellypod
• CI regression gate + self-contained HTML failure reports; method backed by a published technical report (DOI)

trainproof — Deterministic Reliability Layer for ML Training (PyPI)

pip install trainproof. A linter for ML training runs that catches broken fine-tunes across the whole lifecycle — before training (dataset + tokenizer pre-flight), during (a live HuggingFace callback with step-time telemetry that can abort a doomed run), after (divergence / dead-run / overfitting / NaN / gradient-spike detection from log files), and against a baseline (N-way ratio rules that catch failures a single loss curve can't see). The flagship trainproof doctor . auto-discovers every training log in a directory and prints a triage-sorted autopsy. Every rule is a deterministic threshold with a stable ID (TP-DIVERGE, …) and cited evidence — no inferred causes, no invented confidence scores. Sibling of ttsproof (which it reuses for speech-dataset checks).

• Live on PyPI — pip install trainproof (MIT, sole author); fifteen published releases behind a 228-test suite, exposing 84 stable rule IDs, with its rules validated against real training runs from three frameworks (HuggingFace, Coqui XTTS, PyTorch Lightning) rather than synthetic fixtures alone. It judges a run before it starts as well as after: an environment preflight imports the training stack in a subprocess and inspects checkpoints as ZIP archives without ever unpickling them, because torch.load executes arbitrary code by design. CONTRACTS.md pins exit codes, JSON schema policy, rule-ID stability and a verdict-stability guarantee, so downstream CI can depend on this tool without reading its source.
• A PASS that states what it did not check (v0.12) — an audit found a run whose loss was exactly zero on every step passed silently, because every loss-shape check was guarded against dividing by zero and skipped, while the report went on to name those same three checks as having run. A PASS now lists each check that executed and each that did not, with its reason, exposed as structured data. A skipped check is not a passed check.
• SARIF 2.1.0 output — --sarif on every judging command turns findings into GitHub PR annotations, so a doomed fine-tune is flagged inline on the diff that caused it. Exit 2 now means “trainproof could not judge” and is never conflated with 1, a real FAIL verdict about your run — CI can tell a broken run from an unreadable log.
• Live-abort proof — the guardian stopped a real diverging QLoRA fine-tune at step 20 of 300, so 93% of the scheduled GPU steps never ran
• Overfitting detection (TP-OVERFIT) — flags a run whose eval-loss climbs past 1.2× its minimum while train-loss keeps falling, naming the run whose best checkpoint has already gone by
• Regression-locked by construction — every gallery verdict and its complete rule-ID set is frozen in tests/golden/; a rule that stops firing and one that starts firing spuriously both fail the build. All 38 snapshots are byte-identical across v0.11 and v0.12, so “no existing verdict changed” is a checkable claim rather than a promise.
• Fault-injection study shipped as evidence — six controlled QLoRA configurations (Qwen2.5-3B, RTX 5080) at three seeds each: all 18 real logs are committed, not just a representative one, and every verdict is locked in tests/golden/. A nineteenth log ships alongside them — a 9.8-hour Coqui XTTS fine-tune that diverged on its own, the first shipped failure nobody injected
• Documented honest limitation — proved loss curves can't detect corrupted data (a shuffled-labels run cut its loss 62%); the compare command exists to close exactly that gap

AI Content Automation Pipeline — n8n · LangChain · LangGraph

Built an end-to-end content-automation system on the same open-source AI stack used in production teams. A self-hosted n8n workflow fires on a daily schedule and calls a decoupled FastAPI service over HTTP (via host.docker.internal, bridging Docker to the host). That service runs a LangGraph state machine: pick an unused image → caption it with a multimodal LLM (Gemini, structured output enforced by a Pydantic schema) → a validate → retry loop that regenerates any caption failing length, keyword, or tag rules. Per-folder context files keep names and lore accurate (no hallucination), and per-folder link overrides deep-link each item to the right page. Output: validated, SEO-optimised, ready-to-publish content packages — fully decoupled and orchestrated.

• Runs unattended on a daily schedule, fully decoupled over HTTP (Docker-to-host bridge)
• Schema-enforced structured output (Pydantic) with a validate → retry loop
• Public repository on GitHub

Bed Vibe AI Companion — Hybrid Local AI Desktop Runtime

Built and shipped a hybrid AI-companion app in Unity HDRP: a downloadable, installable desktop product run locally on the user's machine behind paid subscription access. Unity launches and supervises a fleet of local subprocesses — a Rust voice-activity gateway, a Whisper ASR server, a Rust local server, and a llama.cpp wrapper serving a custom GGUF model — with hardware-aware LLaMA build selection, CPU/GPU Whisper selection, TCP port health checks, and clean shutdown handling. At startup, the runtime profiles CPU capability, GPU availability, RAM, VRAM, model size, quantization, and context-window fit so it can select a reliable local Whisper and LLaMA/GGUF configuration for the machine. Authentication, MAC-address device licensing, and Stripe-webhook subscriptions run on backend services I operate. Speech-provider credentials remain server-side: the Unity client sends only the bounded synthesis request, while the backend performs the authenticated provider call and returns generated audio plus lip-sync timing data. The real-time conversation loop is microphone → Rust VAD → Whisper → local LLaMA/GGUF → AWS Polly TTS → FFmpeg conversion → OVRLipSync lip-synced avatar playback, bridged over local HTTP/TCP IPC with mute/unmute coordination so the character does not transcribe its own generated voice. Each LLM request is assembled from the character backstory, personality rules, selected model settings, the user profile, relevant prior conversation history, and the newly transcribed utterance. The character is autonomous and conversation-aware through a hand-built locomotion/idle state machine, spoken-cue behavior, talking-gated eye contact, Animation-Rigging head look-at, and a cinematic physical-camera rig. Users configure the AI's name, backstory, personality, temperature, and token limit per profile, inside a production shell with SHA-256/HTTPS login, file-integrity anti-tamper checks, server-synced gold economy, in-app store, and chat-history export.

Beyond the speech pipeline, I built the companion as a persistent interactive character inside a real-time environment. A behavior state machine controls first-contact greeting, engagement, idle activity, movement, sitting, sleeping, spoken-cue reactions, and talking-gated attention. On first greeting or when the user calls her, the character turns toward the user, establishes eye contact, performs a wave animation, and presents a positive engagement response before entering the normal conversation loop. When the user is inactive, the character can transition through autonomous behaviors rather than remaining frozen: after idle time she may move through the room, sit on the couch, and later sleep according to the environment state.

The environment includes time-based presentation such as changing daylight outside the room, while the avatar uses camera-aware eye contact, animation-rigging head tracking, locomotion, idle animations, and cinematic camera behavior to create a continuous social presence. The product layer also includes a server-synced in-app gold economy, shop and unlock flow, room and furniture customization, character/personality configuration, selectable voice and language options, and user-facing personalization such as placing a user photo inside the virtual space. The goal was not only to make an LLM answer, but to combine AI conversation, avatar behavior, environment state, customization, and product systems into one interactive desktop experience.

BedVibe Security Telemetry Lab

Built a defensive security telemetry lab around BedVibe’s production infrastructure: an isolated HTTP honeypot on a self-managed Linux VPS, event capture into JSONL and SQLite, hourly/daily human-readable reports, honeytoken tracking, scanner fingerprinting, and safe pull-only local report mirroring so the home machine remains unexposed.

BookProof — Production API & MCP Server

Shipped the deterministic LongBook retrieval-evaluation engine for real use, two ways. (1) A deployed HTTP API on a self-managed Linux server — Cloudflare → nginx → FastAPI/uvicorn, Let's Encrypt TLS, systemd service — exposing a token-gated developer API (/api/bookproof/v1/verify) and a free public demo (/api/bookproof/public/verify) with per-IP daily rate limiting keyed on the real Cloudflare visitor IP, strict text/claim caps, a one-run concurrency lock, and ephemeral processing (uploaded text and results deleted immediately after each run). Deterministic local retrieval only — no external model calls. (2) An MCP server (Model Context Protocol) over stdio that exposes the same engine as allowlisted tools with sandboxed read/write paths, including a diagnosed transport bug where the child process inherited the MCP stdio channel, fixed with stdin isolation.

Audio Drama Studio — Browser Multitrack Production Editor

Built a full multitrack production editor that runs entirely in the browser: a script parser auto-casts dialogue lines onto 8 voice channels plus SFX and music lanes; clips drag between channels to recast; per-clip volume, pan, and reverb run through a Web Audio API node graph with canvas-rendered waveforms; final mixdown renders offline via OfflineAudioContext through a hand-written PCM WAV encoder with peak normalization; projects save and reload as JSON with full audio rehydration. A working demo project loads automatically — no account needed.

All voices are contracted, rights-cleared voice performers, generated through BedVibe's proprietary TTS pipeline — no scraped or third-party audio.

BedVibe Story Parser — Tagged Text → Audiobook & Audio Drama Projects

Built a deterministic browser-based text-to-project parser that converts pasted novels, scripts, dialogue, or TXT files into structured production JSON. It detects named speakers, narrator passages, optional emotion tags, and tag-only speaker declarations; untagged text is assigned to NARRATOR. The parser supports formats such as [Name] text, [Name|angry] text, (Name|happy) text, Name: text, Name|angry: text, S1: text, and Speaker 1: text.

The output is a structured JSON project containing a title, speaker list, and ordered blocks with block ID, speaker, emotion, and text. Users can download the project JSON or hand it directly to either Audiobook Studio Editor or Audio Drama Studio through an in-browser project-transfer flow. This creates one shared ingestion layer for converting raw writing into long-form narration or multitrack dramatized production.

Audiobook Studio Editor

Built a multi-block editor for long-form speech generation with voice selection, emotion controls, project save and load, UI logic, cost estimation, and API-connected generation workflows for spoken content production.

The editor turns a parsed or manually written audiobook into an editable sequence of generation blocks. Each block can receive its own voice, language, emotion, text, and production settings. Users can include or exclude individual blocks before generation, generate only the selected material, regenerate a specific block after editing, and review estimated token cost before committing a larger project run.

The production workflow supports project save and load, imported Story Parser projects, speaker-to-voice mapping, inline expressive effects embedded in text, and post-generation controls for warmth and space. Global production settings and per-block choices allow the same project to move from clean narration to more stylized audiobook delivery without rebuilding the structure from scratch.

The Mirelands — Fantasy Card Game / Interactive Web Game

Built a custom browser game engine in JavaScript from scratch — no framework, no external game library — with deterministic turn logic, combat resolution, AI opponent behavior, persistent state, deck validation, tower/projectile systems, and backend sync. Includes row-level security on the PostgreSQL backend, cloud-save sync, and replay-safe Stripe purchase handling through an idempotent webhook flow.

Fantasy Talking Avatars

Built a fantasy multi-character avatar stage where transparent PNG characters can speak alone or together using BedVibe TTS with aligned lip sync. Supports one to four visible avatars on the same screen, dialogue sequencing, debate-style scenes, and creator-focused workflows for comics, animated storytelling, fantasy scenes, and game-style character presentation.

Book-Publishing Automation Factories

Built two content-generation factories that turn structured data into print-ready books: a published puzzle-book series (crosswords, word-hunts, matching) on Amazon KDP, and a Norwegian exam-prep exercise engine (trinn 1–3: verb conjugation, noun declension, adjective agreement, possessives and word order). Each generates exercises from CSV data pools, rendered through HTML/CSS into 6×9 KDP-print PDFs — with correctness machine-verified by construction (every crossword reconstructs, every hidden word is findable, every answer key is right) and automated KDP preflight for page count, bleed and margins.

Speech Datasets & Curation

Designed and curated multilingual speech datasets with structured metadata, controlled emotion labels, speaker coverage, studio-grade recordings, and training-oriented organization for TTS and speech model workflows.

Speech Dataset Recorder & Audio Toolkit

Built a Unity-based speech dataset recorder for profile-driven collection workflows, with language and emotion session setup, guided text recording, countdown flow, and organized output for large-scale dataset creation. In parallel, built an 11-tool batch-processing and QA toolkit to complement RX11 for mass curation workflows, including trimming, duration scanning, RMS and peak checks, onset / pre-post checks, clipping detection, noise screening, and dataset-wide analysis.

The Mirelands Audiobooks & Lore Pipeline

Built a connected dark fantasy audiobook line that introduces the core world, characters, creatures, and lore behind The Mirelands. The audiobooks function as both standalone content and a worldbuilding pipeline tied directly to the game’s cards, factions, character identity, voice continuity, and long-form story systems.

BedVibe Author Intake & Rights Authorization Workflow

Built a serverless production-intake workflow for managed audiobook and digital voice projects. The system collects author metadata, book details, narration requirements, voice preferences, manuscript/material links, rights declarations, content-policy attestations, privacy consent, and electronic signature before production begins. It validates required fields server-side, rejects incomplete submissions before email processing, stores the submission record, generates a signed authorization PDF, and routes one internal BedVibe notification with the PDF attached and the submitted author email set as Reply-To. The workflow also includes SEO metadata, sitemap integration, and a noindex confirmation page.

Real-Time Voice-Activity Detection — custom-built

Built a custom Rust voice-activity gateway for a real-time Unity avatar pipeline. The tool selects a named microphone device, captures live audio through cpal, detects speech using dB thresholding, finalizes an utterance after 1.2 seconds of silence, writes the captured segment as a temporary WAV, sends it as multipart audio to a local Whisper transcription server, forwards the transcription back to Unity over localhost TCP, and deletes the temporary file after processing. Unity can also control the gateway with local start/mute commands.

Reception AI / Lead Intake System

Built a hosted reception and lead-capture flow with live deployment, form handling, email routing, persistence, and business-facing web intake connected to backend services.

Business Talking Avatars

Built a business-facing talking avatar system for reception, presentations, ads, e-learning, and instruction flows. Users can generate speech with BedVibe TTS or upload their own audio, then drive branded character lip sync with natural breathing, blinking, positioning, mirroring, and on-character company logo placement.

Norwegian Grammar Books — Multi-language Editions

Developed Norwegian grammar material from 14 years of teaching experience and published full-length editions for English, Polish, and Ukrainian readers. The books span the complete CEFR range — A1 beginner through C2 proficiency — from basic structures all the way to advanced and specialised grammar, not just introductory material. They combine structured explanations, exercises, and practical grammar presentation for foreign learners of Norwegian.

Polly Rust Server

Built a Rust-based HTTP server for Amazon Polly TTS generation with async request handling, AWS SDK integration, configurable voice selection, and deployable API structure for speech-serving workflows.

Officially confirmed university-level coursework in Natural Sciences — Hellenic Open University

Current academic status. Completed 11 of the 12 required modules and all laboratory requirements for the Natural Sciences programme at the Hellenic Open University (222 ECTS completed). One module remains before the Bachelor's degree can be awarded. Plans to complete the remaining module beginning in September 2026.

222 ECTS of university coursework completed (registry-confirmed): Mathematics I–II, Physics I–II, General & Inorganic Chemistry, Physical Chemistry, Organic Chemistry, Cell Structure & Function, Genetics, Introduction to Natural Sciences, and Science Education — plus six completed laboratory courses.

• Physics Laboratory Course I & II
• Chemistry Laboratory Course I & II
• Biology Laboratory Course I & II