Projects an employer can open and judge.

A working self-organizing agent framework with dynamic role negotiation, prefix-cached MCP tool bindings, and an isolated microVM verification harness.

• Replaces static multi-agent DAGs with dynamic agent role allocation and intermediate step audits.
• Implements inline tool binding that preserves prompt cache hits across multi-turn interactions.
• Enforces execution/governance separation by isolating code execution in a secure microVM sandbox.

A complete, production-grade asynchronous agent platform with remote container sandboxes, a semantic-routing JIT Context Hub, and an automated verification harness with a web-based approval interface.

• Harness Design: Clear isolation between execution (inner loop) and verification (outer loop).
• HITL Guardrails: Effective state machine management that pauses execution for human intervention on high-risk actions.
• Resource Management: Efficient context handling, semantic routing, and prompt caching to minimize token costs.
• Security: Proper implementation of isolated sandboxes and secure transport layers for remote code execution.

A publicly hosted inference service with a stable URL and a clean playground UI, plus a public repo: the batching scheduler and KV-cache manager, an autoscaling deployment, CI/CD on every commit, production observability dashboards, a load-test harness, a benchmark report comparing static versus continuous batching across concurrency levels, a marketing landing page, a 10-slide pitch, a recorded demo, and a README explaining the memory, scheduling, and scaling design.

• An OpenAI-compatible HTTP API (chat/completions, streaming) so the service is a drop-in for existing clients.
• A paged KV-cache manager that eliminates memory fragmentation and supports prefix sharing across requests.
• Iteration-level continuous batching so new requests join the running batch without waiting for it to drain.
• A request scheduler with configurable priority and a tunable time-to-first-token versus throughput policy.
• Token-level response streaming over server-sent events or WebSocket.
• A clean playground UI to send prompts, watch streaming output, and see live latency and throughput.
• A live metrics dashboard: tokens-per-second, time-to-first-token, queue depth, GPU memory, and KV-cache utilization.
• Autoscaling across replicas driven by queue depth, with health and readiness probes.
• A built-in load-test harness that sweeps concurrency and emits a static-vs-continuous-batching benchmark report.
• API-key authentication and per-key rate limiting on the endpoint.
• Graceful degradation and request shedding when the GPU is saturated, instead of timeouts.

• The server implements paged KV-cache management and iteration-level continuous batching.
• A request scheduler is present and its time-to-first-token versus throughput tradeoff is documented.
• The service is deployed publicly with a clean playground UI, CI/CD on every commit, and autoscaling across replicas.
• Production observability tracks tokens-per-second and latency percentiles, and the endpoint is secured.
• A load-test report shows throughput and latency percentiles across concurrency levels, with continuous batching measurably compared against a static-batching baseline.
• GPU memory usage and KV-cache fragmentation are reported with the design that controls them.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The service is publicly reachable and reproducible, with a clear benchmark methodology.

An optimized mlx_lm or local inference server cluster achieving high tokens-per-second, utilizing 4-bit quantized layers, speculative drafting, and local node orchestration.

• 4-bit quantization
• Speculative decoding
• Local RDMA clustering

• Model quantized to 4-bit representation with minimal loss in perplexity
• Multi-node local cluster handles speculative decoding correctly across Thunderbolt 5 RDMA/local interfaces
• Inference server matches or exceeds baseline CPU-only token throughput by 10x

A publicly hosted product with a stable URL and a hyper-usable demo UI, plus a public repo and a published model card: the data pipeline, the QLoRA training configuration and run logs, an autoscaling serving deployment, CI/CD on every commit, production observability, an evaluation comparing base versus fine-tuned on a held-out set, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting data sourcing, the contamination check, the scaling design, and the cost of the run.

• A dataset builder that ingests raw domain documents and turns them into cleaned, deduplicated instruction data.
• An automatic train/eval contamination check that flags and removes overlap before training.
• A LoRA/QLoRA training workflow with a reproducible config file and full run logging.
• An experiment view comparing runs across hyperparameters, with loss curves and eval scores.
• A held-out evaluation harness reporting target-task accuracy for the base model versus the fine-tuned model.
• A catastrophic-forgetting check that scores the fine-tuned model on general tasks, not just the target task.
• Adapter management: deploy one base model and hot-swap LoRA adapters per request.
• An OpenAI-compatible serving API for the fine-tuned model, with autoscaling.
• A hyper-usable demo UI where a domain user can try the specialist model on real prompts.
• An auto-generated model card documenting data sourcing, intended use, limitations, and run cost.
• Production observability and a secured, rate-limited endpoint.

• A training dataset is built, cleaned, and deduplicated, with sourcing documented.
• Parameter-efficient fine-tuning (LoRA or QLoRA) is run with a reproducible configuration.
• A held-out evaluation shows a measured improvement of the fine-tuned model over the base, with train/eval contamination explicitly checked and catastrophic forgetting measured.
• The fine-tuned model is served behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• The serving architecture holds under concurrent load and the scaling design is documented.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, a model card documents intended use and limitations, and the product is publicly reachable.

A publicly hosted product with a stable URL and a hyper-usable demo UI, plus a public repo and a published student model: the distillation data pipeline, the student training and preference-optimization configuration, an autoscaling serving deployment, CI/CD on every commit, production observability, a benchmark comparing teacher, student, and base on the target task, a cost-and-latency comparison, a marketing landing page, a 10-slide pitch, a recorded demo, and a README on the distillation method and scaling design.

• A teacher-labeling pipeline that uses a frontier model to generate or label distillation data for a chosen task.
• Synthetic-data generation with quality filtering so the student trains on clean, diverse examples.
• A student-training workflow producing a small (0.6B-8B) model, with reproducible configs and run logs.
• Optional preference optimization (DPO) to align the student where the task needs it.
• A three-way benchmark — teacher, student, and base — reporting capability retained on the target task.
• A cost-and-latency comparison computing the serving-cost reduction versus the teacher.
• An accuracy-floor gate that blocks shipping a student that drops below a configured retention threshold.
• An OpenAI-compatible serving API for the student model with autoscaling and scale-to-zero.
• A hyper-usable demo UI letting a buyer try teacher and student side by side on real prompts.
• An auto-generated model card with the distillation method, retention numbers, and intended use.
• Production observability and a secured, rate-limited endpoint.

• A teacher model is used to generate or label distillation data with a documented method.
• A smaller student is trained and the capability retained on the target task is measured against the teacher.
• Preference optimization (DPO or RLHF) or alignment of the student is applied where appropriate and justified.
• The student is served behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint that holds under concurrent load.
• A cost and latency comparison shows the student is materially cheaper to serve, with the accuracy-versus-cost tradeoff reported honestly.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, the student model is published with a model card, and the product is publicly reachable.

A dockerized, query-active vector service and structured context database with live tracing and a production CI/CD evaluation gate.

• Contextual retrieval
• Automated EDDOps trace evaluations
• Continuous integration regression gates

• Vector retrieval latency is under 50ms at scale with structured indices
• EDD regression test suite executes automatically on mock context drift
• LLM-as-a-judge correctly rates context relevance and faithfulness with >85% alignment to human golden labels

A hardened monitoring and governance gateway with granular cache telemetry, automated multi-turn jailbreak/exploit test suites, and cryptographic emergency halt controls.

• Captures OpenTelemetry GenAI traces with granular KV-cache hit/miss metrics and token cost attribution.
• Executes automated red-team suites testing for agent privilege escalation and prompt injection vulnerabilities.
• Provides an instantaneous, auditable kill-switch mechanism that revokes credentials and terminates agent loops.

A public repo, a benchmark report, and a publicly hosted product with a stable URL and a hyper-usable demo UI serving the trained model: the distributed training configuration, the parallelism strategy, the checkpoint-and-resume logic, a live training-metrics dashboard, an autoscaling serving deployment, CI/CD on every commit, production observability, a scaling report across GPU counts, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the communication pattern, the failure-recovery design, and the serving-scale design.

• A job launcher that takes a model and dataset and spreads training across multiple GPUs from a simple config.
• Data parallelism plus at least one model-parallel strategy (tensor, pipeline, or fully-sharded).
• Gang scheduling so every worker in a job starts together, preventing partial scheduling that idles GPUs.
• Periodic distributed checkpointing with clean resume after a simulated node failure, losing no completed steps.
• A live training dashboard: loss curves, throughput, GPU utilization, and inter-node communication overhead.
• A scaling report that sweeps GPU counts and reports throughput and parallel efficiency.
• Automatic detection and recovery from a stalled or crashed worker mid-run.
• Spot/preemptible-instance support with checkpoint-driven recovery to cut training cost.
• Serving of the trained model behind an OpenAI-compatible API with autoscaling.
• A hyper-usable demo UI where a user can try the trained model on real prompts.
• Production observability and a secured, rate-limited serving endpoint.

• Training runs across multiple GPUs using data plus at least one model-parallel strategy, with correct collective communication and the parallelism decomposition documented.
• Checkpointing is implemented and the run resumes correctly after a simulated node failure.
• A scaling report shows throughput and efficiency across GPU counts, and communication-versus-computation overhead is measured and discussed.
• The trained model is served as a directly deployable product behind a real public API with a hyper-usable demo UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• A live training-metrics dashboard is provided, and the serving layer holds under concurrent load.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible with a clear benchmark methodology and the product is publicly reachable.

A publicly hosted platform with a stable URL and a hyper-usable real-time dashboard plus query UI, plus a public repo: the streaming ingestion and inference pipeline, the at-scale vector index, the autoscaling and backpressure design, CI/CD on every commit, fleet observability, a load-and-failure test report, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting delivery semantics, fault tolerance, security, and capacity planning.

• Ingestion of a high-rate live event stream (transactions, clicks, logs) from a streaming log such as Kafka.
• Per-event low-latency inference with a documented end-to-end latency budget (target sub-100ms).
• Stated delivery semantics — exactly-once, or at-least-once with idempotent processing — enforced in the pipeline.
• A feature layer that assembles per-event features within the latency window for the model.
• Inference results indexed into a vector store serving real-time similarity and nearest-neighbor queries.
• Backpressure and autoscaling that keep the platform healthy through a sudden traffic burst.
• Node-failure recovery with graceful degradation, demonstrated via injected failure.
• A real-time dashboard of event throughput, inference latency percentiles, and fleet health.
• A query UI for similarity search and recent-event lookup, usable without instruction.
• Alerting on latency-SLO breaches, lag buildup, and anomalous event rates.
• Multi-tenant isolation and a secured, rate-limited query API.

• A live event stream is consumed and inference runs per event with measured low latency.
• Delivery semantics (exactly-once or at-least-once with idempotency) are stated and justified.
• Inference results are indexed into a vector store that serves real-time similarity queries.
• Backpressure and autoscaling keep the platform healthy under a simulated traffic burst, and an injected node failure is recovered with graceful degradation.
• The platform is deployed to real public hosting with CI/CD on every commit, fleet observability, and security hardening.
• A fast, WCAG 2.2 AA accessible real-time dashboard and query UI lets a stranger use the platform without instruction.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The platform is publicly reachable and fully reproducible from the repo.

A publicly hosted visual-assistant product with a stable URL and a fast, accessible image-upload-and-chat UI, plus a public repo and a published model card: the image-text dataset pipeline, the LoRA/QLoRA fine-tuning configuration and run logs, an autoscaling serving deployment, CI/CD on every commit, production observability, an evaluation comparing the base versus fine-tuned VLM on a held-out set including a hallucination measurement, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the architecture, data sourcing, and scaling design.

• Image upload supporting documents, charts, screenshots, and photos, with a chat thread per image.
• A fine-tuned open-weight vision-language model adapted to a chosen domain with LoRA or QLoRA.
• A domain dataset builder that turns raw images and annotations into cleaned image-text training pairs.
• Grounded answers that reference regions or content of the uploaded image, with an explicit decline when the image cannot support the question.
• A held-out evaluation harness reporting target-task accuracy for the base versus the fine-tuned model.
• A visual-hallucination check that scores how often the model asserts content not present in the image.
• An OpenAI-compatible multimodal serving API so the assistant is a drop-in for existing clients.
• A fast, accessible chat UI with streaming answers, image thumbnails, and conversation history.
• A cost-and-latency dashboard tracking image-token usage and per-request timing.
• Autoscaling with health and readiness probes, and a secured, rate-limited endpoint.
• An auto-generated model card documenting data sourcing, intended use, and measured limitations.

• A domain image-text dataset is built, cleaned, and documented, with a train/eval split that is contamination-checked.
• A base open-weight VLM is fine-tuned with a parameter-efficient method (LoRA or QLoRA) using a reproducible configuration.
• A held-out evaluation shows a measured improvement of the fine-tuned VLM over the base model, and visual hallucination is measured and reported honestly.
• The VLM is served behind a real public API with a fast, WCAG 2.2 AA accessible image-upload-and-chat UI, autoscaling, CI/CD on every commit, observability, and a secured endpoint.
• Answers are grounded in the uploaded image, and the assistant declines or flags questions the image cannot support instead of fabricating.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo.
• The repo is reproducible, a model card documents intended use and limitations, and the product is publicly reachable.

A publicly hosted generative image studio with a stable URL and a hyper-usable creative UI, plus a public repo: the diffusion generation and editing pipeline, an autoscaling generation queue, content-safety filtering, CI/CD on every commit, production observability, a quality-and-latency report across guidance and step settings, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the conditioning design, the safety design, and the scaling design.

• Text-to-image generation with a latent diffusion model and tunable classifier-free guidance.
• Image-to-image and inpainting so a user can edit and refine an uploaded or generated image.
• A prompt workspace with generation history, versioning, and one-click re-run of a past generation.
• An autoscaling generation queue that accepts bursts of jobs and reports position and estimated wait.
• Content-safety filtering on prompts and outputs, with a documented policy and a clear refusal path.
• A quality-and-latency panel comparing step count and guidance settings on real prompts.
• A creative UI with live previews, thumbnails, and a gallery of past generations.
• Negative prompts and seed control so a creator can reproduce or steer a result deterministically.
• Export to common image formats and a shareable public gallery URL.
• A cost-and-throughput dashboard tracking generations, queue depth, and per-image compute.
• Autoscaling with health and readiness probes and a secured, rate-limited generation API.

• A latent diffusion pipeline generates images from text prompts with classifier-free guidance, and the guidance-versus-quality tradeoff is documented.
• Controllable editing is implemented — at least inpainting and image-to-image — and works on user-supplied images.
• The studio runs on an autoscaling generation queue that absorbs bursts without dropping jobs, and the scaling design is documented.
• Content-safety filtering screens prompts and outputs, and the policy and its enforcement are documented.
• The product is deployed to real public hosting with CI/CD on every commit, production observability of generation latency and queue depth, and a secured endpoint.
• The creative UI is fast, WCAG 2.2 AA accessible, and usable by a non-technical creator without instruction.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo — and is publicly reachable and reproducible.

An interactive auditing dashboard and CLI tool that intercepts, visualizes, and dynamically patches J-space activations to prevent unauthorized model behaviors.

• Demonstrate detection of faked evaluations / deceptive alignment in J-space prior to token generation.
• Show successful patching of J-space activations to restore constitutional alignment dynamically.
• Deliver clear visualization of dense activations and Sparse Autoencoder features mapped to the privileged subspace.

A publicly hosted product with a stable URL and a hyper-usable safety-and-governance dashboard, plus a public repo: the safety-evaluation pipeline with capability, propensity, honesty, and red-team batteries, the auto-generated model card and risk-classification layer, CI/CD on every commit, production observability, a marketing landing page, a 10-slide pitch, a recorded demo, and a README documenting the evaluation methodology, the governance mapping, and the scaling design.

• A safety-evaluation runner with capability, propensity, honesty, and sycophancy batteries against a target model.
• An adversarial red-team suite covering jailbreaks, prompt injection, and indirect injection, with a continuously updated attack library.
• Structured, reproducible scoring so the same evaluation can be re-run and compared across model versions.
• An auto-generated, audit-ready model card capturing intended use, evaluation results, and limitations.
• A risk-classification layer that maps results to the NIST AI RMF Govern-Map-Measure-Manage functions and the EU AI Act risk tiers.
• A benchmark-overfitting check that runs novel held-out prompts alongside public benchmarks to expose inflated scores.
• A safety dashboard showing per-category results, risk status, and trend across evaluation runs.
• CI integration so a safety regression in a new model version fails the release gate.
• Exportable compliance reports suitable for an internal audit or external review.
• Role-based access so safety engineers, compliance leads, and reviewers see scoped views.
• Production observability and a secured, rate-limited evaluation API.

• A safety-evaluation pipeline runs capability, propensity, honesty, and adversarial red-team batteries against a target model and produces structured, reproducible scores.
• The red-team battery includes jailbreaks, prompt injection, and indirect injection, and the report shows which behaviors held and which failed.
• An auto-generated model card documents intended use, evaluation results, and limitations in an audit-ready format.
• A risk-classification layer maps the model and its results to the NIST AI RMF functions and the EU AI Act risk tiers, with the mapping justified.
• The platform is deployed to real public hosting with CI/CD on every commit, production observability, and a secured endpoint, and the evaluation path is hyperscalable under load.
• A fast, WCAG 2.2 AA accessible dashboard lets a safety or compliance lead read results and risk status at a glance.
• The project ships complete marketing — a landing page, a 10-slide pitch, and a recorded demo — and is publicly reachable and reproducible.

A publicly hosted portfolio product with a stable URL and a polished, fast, accessible UI, plus a public repo: the portfolio site, deep writeups of a curated set of AI projects each with a live demo link and real metrics, CI/CD on every commit, observability, security headers, a README documenting the build and design decisions, and a short pitch of the portfolio itself as a product.

• A landing view that communicates who the builder is and the strongest project within seconds.
• A curated set of deep project pages, each with a live demo link, a public repo, and an honest writeup.
• Real metrics on each project — usage, performance, or evaluation numbers — presented without inflation.
• A fast, accessible, responsive UI with semantic HTML, keyboard navigation, and security headers.
• CI/CD that rebuilds and redeploys the portfolio on every commit.
• An honest limitations section per project, so the portfolio reads as credible rather than marketed.
• A contact and links section that makes it frictionless for a recruiter to reach out.
• Lightweight observability or analytics so the builder sees how the portfolio performs.
• A documented build so the portfolio itself doubles as a reproducible engineering artifact.

• The portfolio presents a curated, small set of deep AI projects, each with a live demo, a public repo, an honest writeup, and real metrics.
• The site is deployed to real public hosting with CI/CD on every commit, observability, and security headers on every response.
• The UI is fast, WCAG 2.2 AA accessible, and communicates the value of each project to a non-expert within seconds.
• Each project writeup states what was built, the result, and the limitations honestly, without inflation.
• The portfolio is hyperscalable and reachable globally, with the build and design decisions documented in the repo.
• The portfolio ships with a clear narrative and presentation polish, defensible as a real product.
• The product is publicly reachable and fully reproducible from the repo.

A publicly hosted technical writeup with a stable URL and a fast, accessible reading experience, plus a public repo: the writeup itself with a clear claim, method, results, ablations, and limitations, the code and data needed to reproduce the central result, CI/CD on every commit, and a README pointing to the reproduction steps.

• A clear claim stated upfront, with the method and results structured so a reader can follow the argument.
• A reproducible experiment — code and data public — that a reader can run to confirm the central result.
• At least one ablation that isolates the cause of the result, with the experiment design explained.
• Honest, explicit limitations so the writeup reads as credible research rather than marketing.
• Clear figures and, where it helps, interactive or visual explanation to the standard set by Distill.
• Experiment tracking linked so the runs behind the numbers are inspectable.
• A fast, accessible reading experience with semantic structure and keyboard navigation.
• CI/CD that rebuilds and republishes the writeup on every commit.
• A stable public URL suitable for sharing in an application or with a referral.

• The writeup makes a clear, specific claim and supports it with a reproducible method and honest results.
• At least one ablation is reported that isolates what actually caused the result, with the experiment design described.
• Limitations are stated explicitly, and no claim is overstated beyond the evidence.
• The code and data needed to reproduce the central result are public and the reproduction steps are documented.
• The writeup is published on real public hosting with a stable URL, CI/CD on every commit, and a fast, WCAG 2.2 AA accessible reading experience.
• The writeup is written and presented to a standard a frontier-lab engineer would take seriously, with clear structure and figures.
• The product is publicly reachable and the result is independently reproducible from the linked repo.