Rob Newman

Typed multi-step request workflows

Ten distinct request types (new line, port-in, SIM replacement, hardware change, hotspot, tablet, smartwatch, change of responsibility, and more), each implemented as its own React form component with client-side validation and a shared submission pipeline feeding a central request store.

Request lifecycle state machine

Every submission is assigned a unique request ID and tracked through Pending, In Progress, Completed, and Rejected states, with status surfaced to both the requester's dashboard and the admin queue from a single source of truth.

Role-based portals on shared infrastructure

Separate employee and admin route groups under the Next.js App Router share a common layout system, sidebar navigation, and component library, while rendering role-specific views for requests, billing, users, and settings.

Per-line billing engine

A billing module computes each employee's monthly cost from a centralized pricing model, itemizing base plans, add-ons, and employee-benefit lines per device with payroll-deduction summaries. Currently mock-backed, with live carrier billing data as the next integration milestone.

T-Mobile API integration layer

Planned direct integration with T-Mobile's business APIs to pull per-line call logs and usage data, enable user self-management of plans and add-ons without IT involvement, and process payments through an integrated payment system rather than payroll deduction alone.

Server-side notification layer

API route handlers deliver transactional email (Nodemailer with reusable HTML templates) and SMS status alerts on request state changes, plus SIM inventory tracking with configurable low-stock thresholds surfaced on the admin overview.

Streaming conversation pipeline with barge-in

Push-to-talk audio flows through faster-whisper STT, a token-streaming self-hosted LLM (Ollama), and phrase-buffered TTS so speech synthesis begins before the LLM finishes its sentence. Users can interrupt mid-reply and the session state machine (IDLE/LISTENING/THINKING/SPEAKING) recovers cleanly.

Hybrid dual-engine avatar rendering

A real-time keypoint-warping engine (LivePortrait, ~50-80 ms/frame) drives idle, listening, and reaction states via composable procedural generators (blink, breathing, head drift, lip-sync), architected to crossfade with an audio-driven diffusion renderer (Hallo3 + CogVideoX) for photoreal speech. Both engines are driven from a single source image so identity persists across states.

Embedding-based identity systems

512-dimensional ArcFace face embeddings power identity preservation (cosine-similarity loss terms in a multi-objective training loss), near-duplicate detection in the dataset hygiene pipeline, and per-character appearance features stored AES-256-encrypted at rest in PostgreSQL.

Low-latency WebRTC delivery

Avatar video is encoded to H.264 and published as live tracks through a LiveKit SFU, with Socket.IO signaling and frame-level fallback. A public avatars API lets third-party sites embed live avatar sessions on their own pages.

Zero-shot voice cloning with hybrid TTS routing

A routing layer dispatches preset voices to CPU-based Piper and user-cloned voices to GPT-SoVITS zero-shot cloning from short reference clips, with per-voice stability/similarity tuning surfaced through the API.

Diffusion image generation at production quality

Programmatic ComfyUI orchestration across two engine families (Qwen3-VL-conditioned Krea 2 and SDXL/PonyXL), with automatic cataloguing of a 64-LoRA library, custom conditioning-rebalance nodes, sampler selection (er_sde), GGUF-quantized weights for speed, and prompt-engineered appearance-locking for cross-scene character consistency.

GPU-aware orchestration on consumer hardware

A VRAM-budgeting optimizer targets an RTX 4070 Ti (12 GB), capping concurrent sessions, quantizing model weights, and using temporal caching and ROI compositing to hit 3-4 s conversational response targets without datacenter GPUs.

Microservice inference fleet

Ten containerized GPU services (Whisper, Piper, GPT-SoVITS, LivePortrait, MuseTalk, MusePose, WAN 2.2 video, LiveKit) behind thin typed HTTP clients, with health monitoring, graceful degradation, and per-service model weight management.

Developer platform engineering

Auth0 session auth for the portal plus hashed, scoped sk_live_/sk_test_ API keys with tiered rate limiting for the public REST API; usage analytics, billing, webhooks, and an API playground, all on PostgreSQL/Redis with Drizzle ORM schema migrations.

Provenance and content-safety tooling

Invisible watermark embedding on generated media, an automated data-hygiene pipeline (face-embedding dedup, quality gates) for training data, and a policy-enforcement safety system in the generation path.

A native Slate chat panel bridges to the Claude Code CLI over a custom streaming-JSON stdio protocol, closing the loop end-to-end: a natural-language request in the editor spawns an agent that calls back into the editor's own tools, creates real assets, and supports one-click rollback of everything it did. The system was verified live: an AI agent built and opened working Blueprint assets from a single chat message.

MCP server implemented from scratch in C++ inside the UE editor

JSON-RPC 2.0 over Streamable HTTP per the 2025-03-26 spec, with resources, auth tokens, CORS, rate limiting, request-size limits, and input sanitization.

A 566-tool agent toolset with zero-registration architecture

Tools self-describe with JSON Schema and are auto-discovered via UClass reflection (TObjectIterator), organized across 25+ subsystems from Blueprint graph authoring to multiplayer replication.

Reverse-engineered bridge to the Claude Code CLI's streaming-JSON protocol

A stdio process bridge with newline-delimited frame parsing, session resume across turns, and full tool-call round-tripping, so the agent's tool calls execute inside the live editor.

Transactional plan executor with diff capture and rollback

Every file/asset mutation is recorded and reversible, wrapped in editor transactions for one-click undo, with an audit log behind it.

Defense-in-depth security hardening

A canonical path sandbox (closing the FPaths::IsRelative cross-platform trap), protected-rails deny-lists ahead of every tool call, and Python injection-pattern screening, all covered by dedicated attack-vector tests.

Local image-to-3D pipeline

A self-hosted Hunyuan3D-2 inference server (PyTorch/CUDA, VRAM-adaptive with automatic CPU offload) feeding generated GLB/FBX meshes through Interchange import with automatic LOD chain generation.

Vision-to-scene: a playable Unreal level from a single reference image

Object detection with bounding boxes, three-tier mesh resolution (asset registry, then generative 3D, then fallback), and a PBR material library scanner that auto-wires Quixel/Poliigon texture sets into complete material graphs, including packed ORM channel detection.

Retrieval-augmented project memory

Vector store with neural embeddings, semantic search, tiered memory, dependency graphs, and a context assembler that keeps the agent grounded in the actual project state across sessions.

Low-level infrastructure written by hand where dependencies weren't worth it

A clean-room PKZIP reader/writer (EOCD/central-directory parsing, CRC-32) and SHA-256 content integrity verification for the content-pack pipeline.

Shipped with real engineering discipline

~357 automation tests across 36 suites, genre-recipe acceptance tests (64 game presets), external-service smoke tests, GitHub Actions CI on a self-hosted UE 5.7 runner with strict-includes builds, and lint-enforced conventions.

DeepBlender is not a chatbot bolted onto Blender. It is a tool-using agent architecture: the LLM never emits freeform code into the user's scene. Instead it plans against a typed registry of validated tools, previews every plan with per-step risk levels, executes non-destructively with undo-safe checkpoints, and validates the result against production Unreal Engine standards before export. The system is designed so a complete beginner can type "create a low-poly dragon, game-ready for Unreal" and get a rigged, UV-unwrapped, LOD'd, collision-ready FBX, while a technical artist can drive the same pipeline for batch automation.

~390 Python modules across the addon and backend, a 130-case headless unit test suite, and a multi-process architecture that keeps heavy ML dependencies out of Blender's embedded interpreter.

Tool-using agent over code generation

Every AI action routes through a versioned tool registry where each tool declares its required Blender mode, object types, and side effects. This gives the planner machine-checkable preconditions, enables per-step risk classification, and eliminates the entire class of "LLM wrote bad bpy code" failures.

Pluggable LLM backend abstraction

A common interface with interchangeable Anthropic API, GitHub Models, and deterministic mock backends; OAuth 2.0 device flow so no secrets are embedded.

Deterministic prompt-assembly pipeline

System prompt, project memory, live scene snapshot, RAG context, few-shot examples, and history composed as independently testable stages under an explicit token-budget manager.

Custom RAG pipeline

Purpose-built chunker, embedder, vector store, query expansion, and caching, ingesting Blender API docs, workflow playbooks, and Epic's Lyra UE5 sample, grounding the model in Blender 5.1 / Python 3.13 reality instead of stale training data.

Scene-aware planning with a repair loop

Structured scene snapshots diffed before/after execution; failures feed a self-healing loop (diagnose, categorize, fix, re-execute) with crash recovery and plan resumption.

Multi-step planner with human-in-the-loop approval

Intent classification and task decomposition produce plans the user can approve, modify, reorder, or skip per step, non-destructive and undo-safe throughout.

Production UE pipeline encoded as validators

Asset health scoring plus enforced SM_/UCX_ naming, sockets, LOD0-3, lightmap UVs, texel density, and per-profile FBX presets (hero, environment, foliage, Nanite). Validation is part of creation, not an afterthought.

Local ML inference sidecar

Auto-spawned FastAPI service in its own process/venv, async job queue with Server-Sent Events progress, and a VRAM state machine sequencing Hunyuan3D-2 / SDXL / ControlNet within a 12 GB GPU budget.

GPU-drawn viewport overlays

Real-time texel-density, polygon-density, normals, and validation overlays written against Blender 5.1's gpu module post-BGL-removal, with a 5.1 / Python 3.13 compatibility layer.

Multi-surface delivery

One backend powering three front ends: the in-Blender sidebar, a VS Code @blender chat participant, and a GitHub Copilot Extension server, kept protocol-compatible via shared schemas.

True multi-tenant SaaS architecture

Subdomain-per-tenant isolation on a unified schema, with a separate operator control plane so platform administration never touches customer traffic.

~30 domain-driven backend services in a TypeScript monorepo

Incidents, changes, assets, on-call, compliance, procurement, projects, and more, cleanly separated behind a single API gateway serving four frontend applications.

Agentic AI throughout the product

An AI assistant that triages, categorizes, and acts on tickets; a generative support chatbot; and natural-language analytics that turn plain-English questions into live dashboards. All engineered with graceful degradation, so the platform stays fully functional even if AI services go down.

Sandboxed custom script execution

Customers write their own automation scripts inside the workflow engine, executed in an isolated sandbox. Arbitrary user code, run safely — a feature most SaaS teams avoid entirely.

Proven performance under load

1,700 requests per second with a 23ms p99 and zero errors, powered by a Redis caching layer with automatic in-memory fallback.

Disaster recovery that's been rehearsed, not just written

Scripted backup and restore with a full restore drill executed and verified before launch.

Security-first by design

Fail-fast secret validation (production refuses to boot on weak credentials), enforced operator MFA, SSO/IdP integration, and JWT auth with refresh-token rotation.

Fully internationalized

Every page and component localized in English, Spanish, French, and German, built into the architecture rather than bolted on.

Deep quality engineering

A 575-test end-to-end smoke suite plus a dedicated backend unit-test layer, covering the full ITIL feature surface on every release.

Complete operational maturity

Containerized dev and production environments, a launch runbook, production-readiness audit, embeddable live-chat widget, and per-tenant billing portal.

A single static Go binary agent with zero third-party dependencies

Standard library only, cross-compiled to five OS and architecture targets. Nothing to install on the endpoint, no runtime to maintain, and no dependency vulnerabilities inherited onto managed machines.

Content filtering enforced on the device by a purpose-built UDP DNS server

The agent parses queries in-process, answers blocked domains with genuine NXDOMAIN responses and forwards the rest upstream — so policy follows the device onto any network, home or corporate. Competitors route this to partners; OhKube owns the enforcement path.

Vulnerabilities ranked the way defenders actually triage them

Risk ordering runs CISA Known-Exploited first, then severity band, then CVSS, then EPSS exploit probability — drawing live from NVD, the CISA KEV catalogue and FIRST. Sorting by CVSS alone is the naive approach; this surfaces what is genuinely being exploited in the wild.

Threat detection matches cryptographic hashes, not just process names

The agent computes SHA-256 of every running executable, cached by resolved path so long-lived processes aren't rehashed on each cycle. Name matching catches renamed tooling; hash matching catches the binary itself, whatever it's called.

Short-lived processes don't slip through

A continuous watcher diffs the process table and buffers start events between reporting cycles, so a credential dumper that runs for two seconds between check-ins is still caught — the exact failure mode that snapshot-based telemetry misses.

Command delivery uses SELECT … FOR UPDATE SKIP LOCKED

Thousands of agents can poll concurrently, each receiving distinct work with no double-delivery and no lock contention — the correct Postgres work-queue pattern, and rarely the one reached for first.

Apple's Declarative Device Management implemented to spec

Content-hash-derived synchronisation tokens, correct JSON-over-check-in transport, and scope enforcement that refuses declarations a device isn't entitled to. The protocol layer also handles Apple's NotNow response correctly, requeueing with backoff instead of treating it as a failure.

The migration runner refuses to run against rewritten history

Every applied migration's SHA-256 is recorded, and the runner aborts if a previously-applied file has changed — each migration wrapped in its own transaction with rollback on failure. This is the safeguard most teams add only after being burned once.

Tenant isolation enforced by contradiction, not trust

Services derive tenant identity from the verified token claim and reject any request whose supplied tenant header disagrees with it — treating a mismatch as an attack signal rather than silently preferring one source over the other.

Windows management is deliberately agent-based rather than native OMA-DM

Microsoft owns the Windows enrolment funnel through Entra and Autopilot; competing there buys years of work for parity at best. NinjaOne — a Gartner Magic Quadrant Leader managing over 14 million endpoints — made the same call, as did JumpCloud. The judgment on display is knowing which battle not to fight.