I build production AI systems — and the instruments that catch them failing silently.

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, spanning 13 languages, 15 human speakers plus 2 synthetic voices, and 6 emotional states with metadata conditioning — three independent spans, not a crossed grid. 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 spanning 13 languages, 15 human speakers plus 2 synthetic voices, and 6 emotional states — three independent spans, not a crossed grid
• 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 an adversarial eval gate (answerability, refusal, prompt injection, credential traps), and a self-maintaining pipeline re-validates and redeploys it only when it still passes. Retrieval runs on one of three interchangeable vector backends, and the whole answer path is traced span by span.

• 32/32 on the adversarial eval suite — answerability, refusal, prompt injection and credential traps; retrieval hit@6 20/20 (hybrid retrieval: static embeddings + BM25). Re-run in full as a gate on every corpus change
• Three vector backends benchmarked, the simplest one shipped — brute-force NumPy 0.86 ms, FAISS 0.035 ms, Qdrant over gRPC 1.3 ms and over REST 12.4 ms, so transport cost 9× the database itself. The crossover where FAISS wins by 302× is measured and written down, not guessed
• Request p50 12.41 → 2.91 ms after tracing found the agent was constructing a new model client on every single answer — 8.27 ms at p50, more than twice the cost of all retrieval combined
• A deliberately broken approximate index that finds only 14% of correct neighbours still produced right answers 97% of the time, because the keyword half of the retriever silently carried it — which is why the index is monitored directly against an exact baseline rather than by watching answer quality
• 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)

The Evidence Stack — One Agent Architecture Where Every Layer Separates “No” From “I Don’t Know”

The five systems below are not five projects. They are one stack, built to a single rule: at every layer, an absent value must never be able to read as a good one. A retrieval agent answers from six chunks of a thousand and reports it exactly as it would report reading all of them. A gateway returns HTTP 200 to a caller who gave up two seconds ago. A tool server changes a field name and the client keeps parsing. Each of those is the same failure wearing different clothes, and each layer here is instrumented to make it visible instead of silent.

The layers talk over MCP, which is the part that makes it an architecture rather than a collection: one client, several servers, one contract, and a boundary where what crosses it is checked rather than trusted. The client discovers a server’s tools at runtime and validates every later call against what that server actually advertised — not against what the client assumed when it was written.

• Retrieval — the grounded agent. Hybrid cosine + BM25 over a 1,000-chunk corpus with per-page scope, and a deploy gate that refuses to ship a corpus no evaluator has scored. The proof is fingerprinted on corpus, questions, prompt and model, so a cached pass cannot certify changed behaviour
• Coverage — the accounting layer. An answer grounded in six retrieved chunks scores a perfect faithfulness 1.0 and can still be false about the 997 nobody read. Coverage is recorded per claim, and the required coverage is set by the shape of the sentence: “the policy says X” needs only the chunk it cites; “there is no policy about X” needs all of them
• Contracts — the MCP client. Eight distinct failures, each with its own remedy, because an agent’s next move differs for every one: the server never started, the tool is gone, the arguments changed, the deadline passed, the reply parsed but broke the contract. A surface digest pins tool names, schemas and the declared meaning of each field, so a silent rename fails a test instead of a user
• Traffic — the model gateway. Per-key quota and token metering, bounded admission, deadline-aware retry and failover. Load shedding took usable answers from 1 to 6 out of 32 — without it, 32 callers all got HTTP 200 and 31 had already gone
• Observation — the sensor lookup. One address in, what was actually observed out. Lookup, never listing; observation, never accusation. Read-only to the production host by contract and by test

Every evaluation framework in this space measures whether an answer is faithful to what was retrieved. None measures whether what was retrieved was enough to support the shape of the claim being made. That gap is the reason the coverage layer exists, it is measured on a live system rather than argued from theory, and it is published as an open-source library so the accounting can be checked rather than taken on trust.

Model Gateway — Admission Control, Deadlines and Failover in Front of Several LLM Backends

A single OpenAI-compatible endpoint sitting in front of multiple inference backends, with per-key authentication and spend quota, token metering to SQLite, bounded admission, deadline-aware retries, failover and streaming. Every backend is one file and they speak entirely different protocols, so the layer above the engine does not know or care which engine is underneath. I was asked to put vLLM on the box and did not: the GPU already carries a live production text-to-speech service holding 7.4 of 16 GB, vLLM has no Windows build, and its default configuration reserves 90% of the card. That decision is recorded as an ADR rather than hidden, along with what it costs — continuous batching is what vLLM is for, and I did not measure it.

• Load shedding took usable answers from 1 to 6 out of 32. With no admission control, 32 callers on a 700 ms deadline all received HTTP 200 — and 31 of those arrived after the caller had already given up. A 100% success rate with one usable answer. Bounded, with a fast 429: eight answered, twenty-four refused in milliseconds, and the success rate fell to 25% while goodput rose six-fold
• Failover 0 → 8 in time, p50 3001 → 1046 ms. A backend made slow rather than dead had the gateway logging eight successes without ever calling the healthy backend once, because a retry budget counted attempts instead of watching the clock. The deadline now belongs to the request, and time is reserved for the backend being failed over to
• Gateway overhead 3.47 → 0.60 ms. I predicted the quota check was the hotspot and was wrong — it was 0.146 ms, about 4%. Three quarters of the overhead was one metering row flushing to disk before answering
• Admission limit set at 8 because that is where the knee is — measured saturation of 189 tok/s at one concurrent request, 433 at eight, then flat: 474 at thirty-two for 3.3× the latency

Agent Framework Evaluation — CrewAI Measured Against a LangGraph Pipeline in Production

I built the same real task four ways and ran all four against eight fault scenarios, to decide on evidence whether to move my live content-automation pipeline to CrewAI. The LangGraph arm is not a rewrite — it calls the production graph builder itself, with only the image picker and the model call swapped, and both arms are graded by the live validator and rendered by the live publishing renderers. The answer was no, and it is supported by numbers rather than preference.

• Plain CrewAI returned success while publishing content that violates my own rules, in two of eight scenarios, with nothing a machine could act on. The graph stopped and said why
• Made strict, CrewAI costs 4 model calls and 9,466 characters of prompt against the graph's 3 and 2,319; it installs 683 MB across 143 packages against 32 MB and 36, and imports in 2 s against 0.6 s. Its own cost meter reports three times the truth when several agents share one model object
• The finding that mattered most: I reproduced a real production failure and all four implementations passed it, because the output had the right shape. A framework decides what happens when a step misbehaves; it never decides whether that step should have been a model call at all. The real fix was removing the model call from the send path entirely
• 77 tests plus one deliberate xfail in ten seconds with zero API calls — and the zero is proven, by a scripted local stub and a test that makes every outbound connection fail

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

Web Control — Gated Browser Automation for AI Agents

A browser-control platform exposed to AI assistants over MCP (Model Context Protocol), built around the question most agent tooling skips: what stops an agent from doing something irreversible, and what stops a web page from telling it to? Interactive tools handle exploration and page-local work, but anything that changes the world outside the machine runs only inside a workflow, behind an approval gate that cannot be satisfied non-interactively — there is no auto-approve path in the codebase. Every piece of web-derived text enters agent context explicitly wrapped as untrusted data rather than instructions, with extraction caps and paging so a hostile page cannot flood the context window. Layered so the browser engine is usable as a plain Python library with no MCP involved.

• Prompt-injection boundary by construction — page text is framed as untrusted at the tool-result level, not left to the model to infer, with explicit truncation markers reporting the full size
• Credential-exfiltration primitive closed — arbitrary JavaScript execution is disabled whenever a persistent logged-in profile is active; ephemeral sessions keep it
• Auditable by default — domain allowlist, append-only audit log with redaction of sensitive typed text, stdio-only transport, and local identity stores that are never copied, synced or logged
• Real workflows shipped — sitemap resubmission, indexing requests and article publishing, each emitting a documented result-file contract that downstream tooling reads

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); published releases behind a 470-test suite, exposing 98 stable rule IDs, and a core that declares no runtime dependencies at all, 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

notchecked — Coverage Accounting for Validators (GitHub, MIT)

A schema and accounting layer for tools that check things. It answers the question a validator usually cannot: how much of what you claim to have judged did you actually judge? Three states instead of two — what was checked, what could not be checked, and what was never in scope — and eight once you account for who owns each gap and whether it can ever change. Zero dependencies, standard library only. It grew out of the same defect found in four unrelated systems: an ML training linter, a directory walk, an infrastructure-compliance report and a retrieval evaluation harness, every one of them rendering absence of evidence as a positive result.

• Eight terminal states, each with a distinct owner — a test enforces that no two states share both an owner and a remediation, because two gaps in one bucket hand the reader a to-do they cannot action. WAIVED is in scope and deliberately unevaluated by a named person; PREREQUISITE_FAILED points at the upstream target that blocked it; OUT_OF_SCOPE/DATA_PERMANENT is nobody's to fix, ever.
• Coverage and verdict are orthogonal, and the constructor enforces it — CHECKED is not a result; it says a determination was made, not what it was. A gap cannot carry a verdict and a checked record cannot carry a skip reason. Collapsing those two axes is how a training run that learned nothing once returned PASS alongside a list of the checks that had “cleared” it.
• Two denominators, and only one is quotable — a percentage over everything that exists is a claim about the framework you named; a percentage over what was mechanically checkable is a claim about your own evidence. The library computes only the second, and returns no value rather than zero when nothing was evaluable, because an absence of coverage is not a coverage of zero.
• Hardened by two attacks on its own design, before release — an API attack found five holes, two of which were the library committing its own thesis error one level up: declaring every target out of scope produced a clean exit, and a target that never became a record was invisible. A taxonomy attack then put 24 realistic cases from ML training, compliance, RAG evaluation, CI/CD and production monitoring against the model: twelve fit exactly one state, five fit none, four fit two. Two new states came out of it, plus three tie-break rules — including unreachable is not unhealthy, which was one commit from shipping as a feature.
• Every finding is a regression test named for the attack that found it — 112 tests, no dependencies, MIT.
• Worked out in public, against a second domain — the abstraction was settled in a technical exchange with an infrastructure engineer who had hit the identical shape in compliance reporting, and who is credited by name in the README. Two unrelated domains agreeing is what makes it a primitive rather than one person's preference.

External Review & Adoption — Who Else Has Used or Corrected This Work

The hardest thing for a solo engineer to evidence is not that the code works — it is that anyone outside his own projects has looked at it, argued with it, and changed his mind. This is that record. Every item happened in public and every name is used only where the person stated their own affiliation.

Boris Teplitsky — by his own public description an IBM Certified Expert IT Architect with 21 years at IBM, creator of Merlin Studio, and lead architect of a real-time public-transport ticketing system on GCP for the Israel Ministry of Transport — replied to my trainproof write-up saying he had hit the identical failure in infrastructure compliance, a domain I have never worked in. Two independent domains hitting one shape is what turned it from a preference into a design.

He then reviewed the schema twice before it was tagged and gave three corrections, all accepted, all schema-level rather than wording: permanence must name the target it is relative to, or two reports on the same framework disagree and both are correct; the excluded corpus must enter the denominator, so excluding 412 of 415 reports 99% instead of a flattering silence; and the taxonomy must state that it begins after the unit exists, because turning prose into checkable requirements is a judgment call it does not govern. He asked to be credited by his real name rather than his handle, and is credited individually per correction.

His review also found a defect in my code within a minute of landing: the renderer printed “413 out of scope (100% of all targets)” while one target had in fact been checked — 99.5% rounded to 100. A reader takes that as “nothing was measured”, which is exactly the failure the library exists to remove, committed by its own reporter one layer above the schema it protects.

After ttsproof was released, the maintainer of SpeechSDK (speechsdk.dev, by Jellypod) — a commercial unified API covering more than 17 TTS providers — asked whether ttsproof could benchmark engines through it. The integration shipped. It means ttsproof’s 817-case edge-case corpus can be run against closed-source commercial engines — OpenAI, ElevenLabs, Google and the rest of that roster — from one command, which was not previously possible. ttsproof has also taken a community fix for a real number-formatting bug.

• Three schema corrections accepted from a 21-year IBM Certified Expert IT Architect — including two that broke my own tests on the first run
• An integration requested by an external commercial maintainer, not pitched to them — shipped and documented
• trainproof is the schema’s first production adopter, shipped additively so nothing reading the existing report changed behaviour
• Adopting it caught a distinction I had collapsed in my own code: “no learning-rate column in the log” and “no finite gradient norms in the log” are one word apart and opposite instructions to a human

An IBM architect reviewed this as an individual. IBM endorsed nothing, and no claim is made that it did. Jellypod is a company with a commercial product; its size was never verified and is not claimed. Nothing here is described as proven — it is a record of who engaged and what changed as a result.

2D Finite Element Solver Written From Scratch — Validated Against a 128-Year-Old Exact Result

A complete 2D linear-elasticity FEM solver with no FEA library and no scipy: the Delaunay mesher (Bowyer–Watson), the mesh generator, the quadrature rules, the linear and quadratic isoparametric elements, the element-by-element assembly and the preconditioned conjugate-gradient solver are all hand-written. It is pointed at a problem with a known exact answer — a stretched plate with a circular hole, where the stress at the hole edge is exactly three times the far-field stress, a result published by Kirsch in 1898. The code is given the geometry, the material and the load, and never the number three. The validation criteria were written into a literature audit, with their thresholds, before any code existed.

• Recovers the analytic answer it was never given — the stress concentration factor comes out at 3.00002 against an exact 3 (0.0005%) on a domain where the analytic field is the exact solution, and 2.99970 (0.0101%) by a second, independent route on a finite plate extrapolated to zero width. That the target is not an input is made checkable rather than asserted: grepping the source for the value returns only hits that never feed the computation.
• Convergence orders match the theory, which is the real proof — linear elements converge at 2.026 and 1.019 against a predicted 2 and 1; quadratic isoparametric elements at 3.249 and 2.013 against a predicted 3 and 2. Landing on one number can be luck; reproducing the predicted rates across two element families cannot.
• Ten gates pre-registered, nine pass, and the failure is published — a variational crime committed on purpose (approximating the curved hole by straight edges) was predicted to cost energy-norm order. It cost a full order in L2 and none in the energy norm, so that gate FAILED. Two candidate explanations were then tested and both refuted, and all of it is in the record rather than removed.
• A passing gate criticised for passing — the quadratic L2 rate cleared its band by 0.001. The record states that a two-sided band was the wrong shape for a one-sided theorem and that the gate would have failed on a coarser mesh family: a flaw in the gate, not the code, written down with nobody forcing it.
• Degeneracy handled where it actually bites — every node on the hole boundary lies exactly on one circle, so exact co-circularity is the normal case for the in-circle predicate, not a rare accident. The mesher keeps only the connected component of the bad-triangle set, and the empty-circumcircle property is then measured on every finished mesh after four rounds of smoothing: worst violation zero at all five refinement levels.
• Reproducible in one command — python fem_003.py, about fifty seconds, shipping its own evidence: the full gate log, convergence tables, hoop-stress data and figures. Largest system solved is 21,220 degrees of freedom.

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. The output is platform-neutral, and a thin publisher adapter per target ships it live every day to Bluesky, Mastodon and Tumblr — each with its own character budget, media rules and link semantics, each keeping a separate ledger so one dead platform never blocks or double-posts another. A second set of connectors reads the engagement back and reports who replied.

The publishing stage is deliberately model-free. Generation uses an LLM; the daily write path does not. It draws from a pre-written ordered queue in which every entry carries the source citation for each fact it states, so on a channel nobody reviews there is no surface on which a model can invent anything. The safety property comes from the architecture rather than from a reviewer. The engagement side is tiered the same way: counts are verified, but “this person is waiting for you” never is — an incomplete view raises incomplete and suppresses the signal entirely, because a stale snapshot that asserts a negative sends a human to redo work that was already done.

• Runs unattended on a daily schedule, fully decoupled over HTTP (Docker-to-host bridge)
• Publishes live to three platforms from one package contract — adding a fourth touches nothing existing
• Model-free write path: citation-backed queue, so the unreviewed channel cannot hallucinate
• Evidence-tiered engagement reporting across four surfaces, with an explicit incomplete-view rule
• 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.

Aether — Real-Time Aerospace Telemetry Engine (Rust)

Built a live aerospace surveillance and state-estimation engine in Rust: asynchronous ADS-B ingestion over Tokio, WGS84 → ENU coordinate transformation, a constant-velocity Kalman filter per axis, innovation gating, track lifecycle management, closed-form closest-approach screening against ICAO separation minima, and a C ABI so the estimator can be called from existing C/C++ systems. Running it against live traffic exposed two real defects. The engine was stamping every measurement with the time it arrived rather than the time it was observed, and a controlled A/B against the same feed measured the cost: 16.1% of good observations rejected before the fix, 1.9% after. The same work revealed that the earlier build had been silently failing two-thirds of its polls and never ageing a single track out. A second defect — the ENU “Up” axis is not altitude, and reads 19,233 ft below the tangent plane for an aircraft truly at 36,089 ft at 463 km — was corrected in the display without disturbing the validated screening geometry, because the curvature error is common-mode across a pair. Surveillance and estimation only: no targeting, engagement or weapon functionality.

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