Field Artifacts

Selected work 33 specimens  ·  8 live

Engineering work with public source code. Every project states what was built, the evidence behind it, and its real status — prototypes are labelled as prototypes. The gold bar marks an artifact you can open and use today.


Engineering projects

  1. ServiceDesk Plus Cloud Readiness — Synthetic assessment report
    Synthetic assessment report
    P01 · Enterprise ITSM Released · v2.2.0

    ServiceDesk Plus Cloud Readiness

    A local, read-only assessment of ManageEngine ServiceDesk Plus on-premises before migration to Cloud. Discovers portals, collects inventory and metadata through reviewed API reads, and records coverage gaps instead of guessing.

    • Python
    • REST API
    • ServiceDesk Plus
    • Windows
    Problem, architecture & evidence
    Problem
    Teams planning a move to ServiceDesk Plus Cloud rarely have an accurate inventory of what their on-premises portals actually contain, configure and depend on.
    Architecture
    1. Operator prompt URL and API key; keys never saved
    2. Portal discovery One key, per-instance keys or credential file
    3. Read-only collection Reviewed HTTP GET operations only
    4. Analysis Configuration findings and coverage gaps
    5. Offline reports HTML, JSON, CSV and Markdown
    Implemented
    • Multi-portal discovery with single-key, per-instance or credential-file routing.
    • Collection restricted to reviewed HTTP GET operations; keys never accepted as CLI arguments or saved in reports.
    • Offline HTML, JSON, CSV and Markdown reports with explicit coverage gaps.
    • Python 3.10+ standard library only; Windows launchers and a portable .pyz release build.
    Verification
    Unit and integration tests with synthetic fixtures; committed synthetic and recovery assessment examples; an offline --demo mode that needs no credentials or network.

    Status & limits. Independent assessment tool — not a ManageEngine product or an automated migration engine. An assessment is not migration approval or proof of complete source visibility.

  2. PHP2Shell Exposure Checker — Synthetic sample report
    Synthetic sample report
    P02 · Security Released · v1.0.1

    PHP2Shell Exposure Checker

    Passive checker for CVE-2026-109618 and CVE-2026-109619. Reads the PHP version a website already advertises and compares it with the official upstream fix for each PHP branch, then produces branded CSV, JSON or HTML reports.

    • Python
    • HTTP
    • CVE analysis
    • HTML reports
    Problem, architecture & evidence
    Problem
    After a PHP security advisory, site owners need a fast, non-intrusive way to see which of their websites advertise an affected version.
    Architecture
    1. Authorised site list Text file or single domain
    2. robots.txt check Stops if the page is disallowed
    3. One GET request Verified TLS, honest User-Agent
    4. Header inspection X-Powered-By, Server, WordPress markers
    5. Fix comparison PHP 8.2–8.5 upstream thresholds
    6. Report CSV, JSON or branded HTML
    Implemented
    • One ordinary GET per page after checking robots.txt; no exploit payloads or crafted requests.
    • Version comparison against documented fixes for PHP 8.2–8.5.
    • Single offline HTML report with summary tiles, light/dark theme and custom branding.
    • Single-file Python with zero third-party runtime dependencies; bundled agent skill.
    Verification
    Local-only unit test suite in CI (no external websites contacted); thresholds checked against the PHP project advisories on 2026-10-21; synthetic sample report from reserved example.* domains.

    Status & limits. Passive exposure indicator, not exploitation verification. Hidden or vendor-patched versions are reported as unknown, never as safe.

  3. Agentic Business Services Skills — Sample orchestration document
    Sample orchestration document
    P03 · AI agents & integrations Open source · v1.1.0

    Agentic Business Services Skills

    A library of seven reusable AI agent skills covering the services lifecycle — discovery, proposal, contract, invoice, delivery and customer success — coordinated by a schema-driven orchestrator with explicit approval gates.

    • Python
    • Agent skills
    • YAML schemas
    • ReportLab
    Problem, architecture & evidence
    Problem
    Agents can draft business documents quickly, but commercial, legal and billing decisions must stay with the people who own them.
    Architecture
    1. Request or change Artifact, client change or new work
    2. Workflow adapter Schema-validated definition
    3. project_state Facts, approvals, blockers, artifacts
    4. Policy routing Selects the specialist skill
    5. Approval gate Owner or security review; else recovery
    6. Validated output Approved copy or release package
    Implemented
    • Orchestrator that loads a workflow definition, updates project_state, routes by policy and validates every transition.
    • Owner approval and optional security-review gates; blocked or stale approvals route to a recovery path.
    • Branded PDF generation for discovery briefs, proposals, agreements, invoices, delivery and QBR documents.
    • Event log and handoff state preserved across specialist skills.
    Verification
    Each repository ships a worked example rendered to PDF and PNG, Mermaid workflow sources and a universal workflow schema.
    Skill repositories
    Discovery Proposal Contract Invoice Delivery Customer success

    Status & limits. Local-only: the skills do not send email, call CRMs or contact external services. They prepare drafts; people authorise and send.

  4. TicketStub — AI Keepsake Studio — Live preview, demo mode
    Live preview, demo mode
    P04 · AI products Hackathon prototype

    TicketStub — AI Keepsake Studio

    Customer studio for personalised ticket-stub keepsakes: paste an event link, watch facts get researched while the stub prints, then edit, approve and export. The composition root for a multi-repository hackathon system.

    • Next.js
    • TypeScript
    • SQLite
    • LLM agents
    • Stripe
    Problem, architecture & evidence
    Problem
    Turning a single event link into a researched, personalised printed keepsake needs research, creative generation, approval, payment and fulfilment to cooperate.
    Architecture
    1. Event link Customer pastes a ticket or event URL
    2. Event research Fixtures by default; live providers opt-in
    3. Studio Edit, artwork, immutable review versions
    4. Signed approval Artwork approval and order authorisation
    5. Checkout Dodo (digital) or Stripe (physical)
    6. Export PNG export; fulfilment still pending
    Implemented
    • Next.js App Router studio with magic-link sign-in, SQLite storage and file-backed artwork.
    • Event intelligence and AI provider routing (Anthropic, OpenAI or OpenRouter) behind an opt-in live mode.
    • Immutable review versions, signed artwork-approval and order-authorisation records.
    • Front/back PNG export; Dodo (digital) and Stripe (physical) checkout code paths.
    Verification
    Published host verified on 2026-10-11/12: health check, real sign-in email and artwork surviving a redeploy. Offline verify:product suites cover routes, accessibility, degraded storage and backup/restore drills.

    Status & limits. Hackathon prototype. Demo research by default; live payment acceptance and physical fulfilment are not established; wallet passes and QR codes are simulated; integrated v1 acceptance is not met.

    Built with the Jevelopers neatHack 2026 team, including Lars van der Zande.

  5. PickYour.AI — AI Stack Builder — Live site, synthetic catalogue
    Live site, synthetic catalogue
    P05 · AI products Preview · synthetic data

    PickYour.AI — AI Stack Builder

    A PCPartPicker-style builder for complete AI systems: choose a workload and deployment mode, then models, infrastructure, data, tooling and deployment, with compatibility checked as you go.

    • React 19
    • TypeScript
    • Vite
    • JSON Schema
    Problem, architecture & evidence
    Problem
    Planning an AI system means reconciling models, providers, hosting and licensing constraints that rarely appear in one place.
    Architecture
    1. Research contract Versioned contracts/v1 from the research repo
    2. Generated types npm run contracts:types
    3. Compatibility rules pass, fail, unknown or skipped
    4. Builder UI React 19 layered stack builder
    5. Static build dist/ served by Apache
    Implemented
    • Layered builder (requirements, models, infrastructure, retrieval, agents, training, operations).
    • Contract-first compatibility evaluation from a vendored, versioned research contract.
    • Unknown information is never treated as compatible; results use explicit pass, fail, unknown and skipped states.
    • Static React SPA aimed at WCAG 2.2 AA.
    Verification
    CI requires format, lint, typecheck, contract verification, unit, end-to-end and visual-baseline tests before merge.

    Status & limits. Engineering preview. Every component, price and compatibility result on the site today is synthetic demonstration data, labelled as such.

    Contributions by @karutoil.

  6. Self-Hosted QR Code Toolkit — Local build, example data
    Local build, example data
    P06 · Web applications Open source · single-user

    Self-Hosted QR Code Toolkit

    Self-hosted QR code generator with customisable SVG designs, PNG export, editable dynamic destinations and optional YOURLS short-link integration.

    • React
    • TypeScript
    • Express
    • Vite
    • YOURLS
    Problem, architecture & evidence
    Problem
    Small businesses need branded QR codes whose destinations can change after printing, without handing scan data to a third-party SaaS.
    Architecture
    1. React UI Payload builders and SVG designer
    2. Express API /api/qr and protected record routes
    3. Renderer Styled SVG and standard PNG
    4. Local store JSON records, uploads, audit history
    5. Redirects Local fallback or optional YOURLS
    Implemented
    • Payload builders for URL, text, email, phone, SMS, vCard, MeCard, Wi-Fi, events, maps and more.
    • SVG designs with colours, gradients, module shapes, templates and logos.
    • Saved records with editable dynamic destinations, local redirects and audit history.
    • Optional YOURLS short URLs and statistics; REST API for programmatic generation.
    Verification
    Typecheck, unit tests, production build and a QR smoke test are part of the documented development checks.

    Status & limits. Single-user, single-process application with JSON storage — not a multi-tenant hosted service. PNG exports omit SVG styling.

  7. Mautic Control for OpenClaw — Architecture diagram
    Architecture diagram
    P07 · AI agents & integrations Pre-1.0 · v0.1.14

    Mautic Control for OpenClaw

    OpenClaw plugin that lets an AI agent operate a Mautic CRM through typed, policy-gated tools: API entities, webhook discovery, allowlisted console maintenance and guarded file staging.

    • JavaScript
    • OpenClaw
    • Mautic API
    • Webhooks
    Problem, architecture & evidence
    Problem
    Giving an agent CRM access is useful only if that access is narrow, auditable and off by default.
    Architecture
    1. Operator Natural-language request
    2. OpenClaw agent Gateway and dashboard
    3. Typed tools mautic_status, request, entity, console
    4. Policy gates Off-by-default switches, HTTPS rule
    5. Mautic REST API, private console bridge, workspace
    Implemented
    • Typed tools for status, API requests, entities, webhook triggers, console and workspace files.
    • Conservative defaults: maintenance, automation jobs and workspace read/write start disabled.
    • Credentials only from environment or secret store; refuses to send them to routable plain-HTTP hosts.
    • Private console bridge limited to allowlisted commands; filesystem bounded to one workspace root.
    Verification
    Verified against Mautic Community 7.1.1 with OpenClaw 2026.5.22+. CI lint, tests, package and readiness checks; published to ClawHub with OIDC trusted publishing.

    Status & limits. Pre-1.0 (v0.1.14). Validate against your exact Mautic instance before broad rollout.

  8. NYC 311 — AI-Assisted Heatmaps — Generated heatmap, real data
    Generated heatmap, real data
    P08 · Data & AI research Research demonstration

    NYC 311 — AI-Assisted Heatmaps

    Downloads a bounded slice of NYC 311 service requests, evaluates complaint descriptions with typed JEV decisions, aggregates results on a 500-metre grid and renders interactive Folium maps and print-ready PNGs.

    • Python
    • NYC Open Data
    • JEV
    • Folium
    • SQLite
    Problem, architecture & evidence
    Problem
    Raw 311 volume shows where people report problems, not how serious those reports might be. Typed model evaluation adds a second, inspectable signal.
    Architecture
    1. NYC 311 API Bounded date slice
    2. Validate records Drop missing or invalid coordinates
    3. Deduplicate One evaluation per distinct description
    4. JEV + cache Typed answers, local SQLite cache
    5. Grid aggregation 500-metre projected cells
    6. Maps Interactive HTML and PNG layers
    Implemented
    • Public open-data ingestion with record validation and description de-duplication.
    • Typed model evaluation with response validation and a persistent local cache.
    • Projected grid aggregation for count, coverage, severity, concern and ambiguity layers.
    • Interactive HTML maps plus PNGs with borough shorelines.
    Verification
    Published run for 1 September 2026: 9,903 reports downloaded, 9,698 mapped across 2,043 cells, 634 API calls with no retries. 32 offline tests; run metadata records the query and input hash.

    Status & limits. Research demonstration. Maps show model-estimated potential impact, not verified hazards or harm. Blank cells are not evidence of no problem.

    Data: NYC Open Data and NYC Department of City Planning.

  9. Cockpit Intel Arc Pro B60 Monitoring — Illustration
    Illustration
    P09 · Infrastructure Single-host validation

    Cockpit Intel Arc Pro B60 Monitoring

    Cockpit extension that surfaces Intel Arc Pro B60 GPU telemetry from xpu-smi: a dedicated GPU page, GPU and GPU-memory rows in the Overview usage card, and a GPU card on the Metrics page.

    • JavaScript
    • systemd
    • Cockpit
    • xpu-smi
    • Linux
    Problem, architecture & evidence
    Problem
    Cockpit shows CPU and memory out of the box but nothing for Intel discrete GPUs used for local AI workloads.
    Architecture
    1. xpu-smi Intel GPU telemetry source
    2. systemd exporter Root-owned poller (MEI access)
    3. JSON in /run metrics.json and minute history
    4. Cockpit package GPU page, Overview and Metrics cards
    5. Cockpit Sensors lm-sensors temperatures and fans
    Implemented
    • Root-owned systemd exporter polling xpu-smi into read-only JSON with minute history.
    • Cockpit package with GPU page, Overview and Metrics cards.
    • Integration with the upstream Cockpit Sensors package via lm-sensors.
    • Installer that backs up the Cockpit files it modifies, plus an uninstaller.
    Verification
    Running on the host it was written for: an Arc Pro B60 on an apt-based Linux system.

    Status & limits. Validated scope is a single Intel Arc Pro B60 host. Other hardware and distributions are not covered.

  10. TypeCheck — AI Discord Moderation — Offline preview, synthetic data
    Offline preview, synthetic data
    P10 · AI products Implementation candidate

    TypeCheck — AI Discord Moderation

    Discord text and image moderation bot with an embedded management Activity. Text rules, image-content rules and reference-image matching feed one deterministic policy engine that applies at most one user sanction per message.

    • TypeScript
    • Node.js
    • Discord
    • PostgreSQL
    • MySQL
    Problem, architecture & evidence
    Problem
    Community moderators need automated help with scams and abuse without handing irreversible actions to an unreviewed model.
    Architecture
    1. Discord Gateway Text and image creates and edits
    2. Durable jobs Stored in PostgreSQL or MySQL
    3. Exact hash match Normalised SHA-256 before any model call
    4. Jev evaluation Text, image content or reference rules
    5. Policy engine Deterministic, one sanction per message
    6. Action + ledger REST action and audit record
    Implemented
    • Gateway ingestion, durable jobs and REST actions from log-only to ban.
    • Exact normalised-hash matching before model comparison; per-action thresholds and second verification.
    • Administrator Activity: moderation packs, rules and tests, permissions, settings and credential rotation.
    • Cost and usage analytics with coverage warnings instead of invented totals.
    Verification
    155 unit/HTTP tests, PostgreSQL integration and 104 MySQL integration assertions, and an offline Compose recovery/restore drill passed.

    Status & limits. Implementation candidate (v0.1.0). Real Discord acceptance, representative model accuracy, public TLS and independent security sign-off remain open. Text moderation and enforcement start disabled.

  11. JEV Learning Lab — Auditable AI Decisions — Course notebook (HTML export)
    Course notebook (HTML export)
    P11 · Data & AI research Course · offline-ready

    JEV Learning Lab — Auditable AI Decisions

    A self-contained Jupyter course on building auditable agents from typed decisions: 42 lessons, 50 executable code cells, 42 exercises with hints and an end-to-end incident-copilot capstone.

    • Python
    • Jupyter
    • JEV
    • Evaluation
    Problem, architecture & evidence
    Problem
    Most agent tutorials blur where the model decides and where code enforces. This course keeps that boundary explicit in every lesson.
    Architecture
    1. Trusted code Prepares state and bounded candidates
    2. Typed question JEV answers; fixtures when offline
    3. Validate & gate Code combines and checks answers
    4. Authorised act Simulated host action
    5. Observe & verify Audit receipts and replay
    Implemented
    • Lessons spanning extraction, ITSM, moderation, RAG, games, PLC simulation, caching, retries and audit receipts.
    • Evaluation, drift monitoring, active learning and cost-aware tool selection.
    • Offline mode by default with an optional, capped live mode.
    • Pre-executed notebook plus a static HTML copy readable without Jupyter.
    Verification
    Distributed notebook is executed; execution, verification and test reports are committed alongside it.

    Status & limits. Saved model-shaped answers are author-written fixtures, not live model responses, and do not measure accuracy, latency or cost.

  12. LibreEvolve — Reproducible Code Evolution — Workflow diagram
    Workflow diagram
    P12 · Data & AI research Engineering preview

    LibreEvolve — Reproducible Code Evolution

    Open-source workbench for inspectable code-evolution experiments. Starts from a simple Python bin-packing heuristic, searches a bounded space of changes and saves every candidate and evaluation for review.

    • Python
    • LLM search
    • Evaluation
    • Reproducibility
    Problem, architecture & evidence
    Problem
    AI-assisted optimisation claims are hard to trust when intermediate candidates and evaluations are summarised away.
    Architecture
    1. Seed Simple bin-packing heuristic, offline preflight
    2. Bounded search Codex OAuth lane within local limits
    3. Saved run Every candidate, evaluation and call
    4. Freeze selection Choose before held-out reporting
    5. Fresh export check Training and held-out cases re-run
    Implemented
    • Bounded runs with local call, evaluation and runtime limits.
    • Every candidate workspace, evaluation, archive event and model call saved to a run directory.
    • Run status, validity, quality, retention and usage kept as separate dimensions.
    • Reports and exports re-run the chosen candidate in fresh subprocesses on training and held-out cases.
    Verification
    Offline task/evaluator preflight and focused offline tests; fresh export checks record candidate identity.

    Status & limits. Engineering preview limited to bounded Python bin-packing. No improvement is guaranteed — “no improvement” is a valid result. Candidate execution is not a security sandbox.

  13. Organization Time Tracking — Microsoft 365 Evidence — Synthetic sample report
    Synthetic sample report
    P13 · Enterprise automation Open source · v1.0.0

    Organization Time Tracking — Microsoft 365 Evidence

    Agent skill that accounts for time spent with one organization from the operator’s own Outlook, Teams and calendar evidence, then produces an Excel workbook and a branded HTML report backed by a redacted evidence tree.

    • Python
    • openpyxl
    • JavaScript
    • Microsoft 365
    • Agent skill
    Problem, architecture & evidence
    Problem
    Time spent with one client is scattered across mail, chats and meetings, so “how much time, on which days, and what is the evidence?” is hard to answer.
    Architecture
    1. Rules & consent Billing parameters set by the operator
    2. Evidence Outlook, Teams and calendar collectors
    3. Redaction Secrets removed per day
    4. Lapses & meetings Held meetings and activity lapses
    5. Workbook Billed time per day; recalculated and tied
    6. Hours report Branded HTML, light and dark
    Implemented
    • Parameterised browser collectors for Outlook search results, Teams messages and calendar events, written to a redacted per-day evidence tree.
    • Billing rules as parameters: minimum per lapse, billing increment, meeting-day minimum and a held-meeting rule.
    • Excel workbook with formula totals, daily time, a month-grid calendar view and day detail tracing every minute to its source.
    • Single-file HTML report in light and dark themes with a heat calendar and date-range controls that recompute every figure.
    Verification
    Committed sample report, workbook and screenshot rendered from a fictional Northwind Trading Co. fixture; 16 package-contract tests in CI on Ubuntu, Windows and macOS, plus ruff and pyright checks.

    Status & limits. Hours are estimates from evidence, not invoices; task effort is shown as low/high/likely estimates. Zero-result months may reflect search limits, meeting recaps and transcripts are not collected, and the workbook needs Excel or LibreOffice to recalculate.

  14. Jraphyte — TRACE-GC Evidence-Bound GraphRAG — Architecture diagram
    Architecture diagram
    P14 · Data & AI research Reference implementation

    Jraphyte — TRACE-GC Evidence-Bound GraphRAG

    Python reference runtime that compiles source evidence into typed graph mutation plans, admits changes only through an approved transaction boundary, and feeds the resulting graph back into retrieval as source-cited GraphRAG context.

    • Python
    • SQLite
    • JSON Schema
    • Ed25519
    • Docling
    Problem, architecture & evidence
    Problem
    Model-built knowledge graphs tend to lose track of which source justified which edge, and retrieval over them can quietly treat adjacency as proof.
    Architecture
    1. Source evidence Immutable sources with exact spans
    2. Mutation plan Typed, hashed graph changes
    3. Approval Policy branch and scoped Ed25519 signature
    4. Atomic commit SQLite transaction with rollback
    5. GraphRAG context Source-cited, ACL-filtered retrieval
    Implemented
    • Immutable source and claim records with exact evidence spans and per-field provenance.
    • Typed mutation plans with immutable hashes, policy branches, scoped Ed25519 approvals and atomic SQLite commits with rollback.
    • Upstream GraphRAG context for synthesis and a downstream query service returning ACL-filtered, source-cited contexts.
    • Experimental first-page PDF evidence validation comparing six extraction pipelines on 200 papers.
    Verification
    Validation report for 0.4.0: 1,402 tests run, 1,396 passed, 6 skipped, no live provider calls; CI on Python 3.11–3.13 plus Windows. On the 200-paper test, the best extractor reached 94.8% precision (91 of 96 proposals).

    Status & limits. Reference implementation, not a production service. The 91-run benchmark uses synthetic fixtures and claims no real-model accuracy gain. Only SQLite and in-memory adapters are tested; Neo4j and pgvector are interface designs. PDF references await independent human review.

  15. AI Usage Ledger — What Coding Agents Really Cost — Dashboard, synthetic fixture data
    Dashboard, synthetic fixture data
    P15 · AI agents & integrations Beta · v1.6.0

    AI Usage Ledger — What Coding Agents Really Cost

    Agent skill that compiles every locally recorded AI coding-agent model call into one append-only, de-duplicated ledger, prices it at list API rates and splits it by subscription account.

    • Python
    • SQLite
    • HTML/CSS
    • Agent skill
    Problem, architecture & evidence
    Problem
    Agent tools log tokens in incompatible formats, replay history into child threads and delete transcripts after weeks, so naive totals are wrong and nobody can say which account paid for what.
    Architecture
    1. Disclosure Operator choices and consent
    2. Source scan Selected agent logs and databases
    3. Append-only store Stable event IDs, duplicates removed
    4. Price & attribute List rates, accounts, validation
    5. Reports Dashboard, study package, documents
    Implemented
    • Parsers for Claude Code, Codex, Gemini CLI, Copilot CLI, aider, Cline and other tools, normalised into one event stream.
    • Append-only SQLite, JSON or CSV store keyed on stable event IDs, with replay and streamed-duplicate removal.
    • Rule-based account and billing-plan attribution with a confidence level per rule and an explicit unattributed row.
    • Light/dark dashboard, study package and ledger documents in Markdown, HTML, PDF and DOCX.
    Verification
    Synthetic fixtures for ten tools and five GitHub Actions workflows. Per-call records, tool counters and priced estimates are kept as separate evidence classes, and totals are checked against each tool’s own counters.

    Status & limits. Dollar figures are API-equivalent estimates at list price, not invoices. Claude Code deletes transcripts after 30 days by default, so those totals are a lower bound; unpublished models are priced at a stated sibling and marked assumed.

  16. Jev Prune Kit — Pruning Repeated File Reads — Architecture diagram
    Architecture diagram
    P16 · Infrastructure Experimental · v0.1.0

    Jev Prune Kit — Pruning Repeated File Reads

    Experimental installer and assessment engine for coding agents. Exact repeated file-read results are left out of outgoing requests and replaced with a one-line marker naming the retained copy; the native transcript is never edited.

    • Python
    • Node.js
    • Agent harnesses
    • SHA-256
    Problem, architecture & evidence
    Problem
    Long agent sessions re-read the same files, and every identical result body is sent again with each later request.
    Architecture
    1. Snapshot Explicit Pi, OpenCode or OpenAI message list
    2. Candidates Exact repeated reads outside recent turns
    3. Assessment Opt-in TypeSafe check, bounded request
    4. Receipts SHA-256 source and witness proofs
    5. Projection Marker replaces the older body per request
    Implemented
    • Request projection: only a copy of the outgoing messages changes; nothing is summarised or rewritten on disk.
    • Exact-repeat detection outside the last 16 messages and the current turn, with credential and error-text vetoes.
    • SHA-256 receipts re-verified on every request; a stale proof keeps the original body.
    • Experimental native adapters for Pi, OpenCode and Hermes, plus a coordination bus shared with JEV Context Fabric.
    Verification
    Repository suite of 107 Python and 15 Node tests. A fresh Windows run for the write-up passed all 15 Node tests and 100 of 107 Python tests; the six errors came from environment-dependent installer and config tests. No token-savings measurements exist.

    Status & limits. Experimental v0.1.0, not tested against a live harness session or the live TypeSafe service. Pruning needs an opt-in remote assessment, and host token counters may still reflect the original history.

  17. Clean Drop — Gemma 4 Water Field Reports — App screenshot; analysed image is AI-generated
    App screenshot; analysed image is AI-generated
    P17 · Data & AI research Hackathon prototype

    Clean Drop — Gemma 4 Water Field Reports

    Built by Team Clean Drop for the Gemma 4 Good hackathon: a photo-first field-report workflow for water points in Somalia — capture, time and location, Gemma 4 triage and human review — shown in a demo video, interface screenshots and a Kaggle notebook.

    • Gemma 4
    • llama.cpp
    • Python
    • Jupyter / Kaggle
    Problem, architecture & evidence
    Problem
    Water-point failures in low-connectivity areas go unreported or arrive without context responders can act on.
    Architecture
    1. Capture Field photo and note
    2. Time & location Confirmed timestamp and district
    3. Triage Severity, category and actions
    4. Human review Reporter edits the draft
    5. Export Reviewed report as JSON and CSV
    Implemented
    • Four-step report flow: capture image, confirm time and location, Gemma 4 triage, review the draft report.
    • Structured triage: summary, severity, category, observed issues, recommended actions, escalation and confidence.
    • Field Report API design that keeps the raw llama.cpp endpoint private and validates JSON output.
    • Kaggle notebook that exports reviewed reports as JSON and CSV.
    Verification
    Public demo video and interface screenshots. The notebook ran offline end to end for the write-up and produced its JSON, JSONL and CSV outputs.

    Status & limits. Hackathon prototype; the entry missed the submission window. App and API source are not published. The notebook runs deterministic keyword triage, not Gemma 4 inference. The demo field image is AI-generated.

    Team Clean Drop: frymatic, 1Soph, GalaxyRuler, GODFATHER and CompleteTech.

  18. Lean 4 Computer Vision — Architecture Atlas — Architecture atlas, detail
    Architecture atlas, detail
    P18 · Data & AI research Upstream contribution

    Lean 4 Computer Vision — Architecture Atlas

    Architecture atlas contributed to a small Lean 4 library for RGB/YCbCr colour conversion and EMVA 1288-style sensor characterisation: an overview, twelve Mermaid views and light and dark renders, merged upstream.

    • Lean 4
    • Lake
    • Mermaid
    • Documentation
    Problem, architecture & evidence
    Problem
    A first-project Lean 4 library had working definitions but no map of its types, calculations, failure paths or review limits.
    Architecture
    1. Upstream library Lean 4 colour and sensor modules
    2. Source reading Types, functions and imports
    3. Views Overview plus twelve Mermaid diagrams
    4. Review view Unchecked shapes and unguarded maths
    5. Merge Upstream PR #1, archived release
    Implemented
    • Overview plus twelve views covering every type and function, the calculations, failure paths and build/CI.
    • Light and dark PNG renders of each view with a reproducible render script.
    • A review view recording unchecked image shapes, unguarded division and log10, and demo-only values.
    • Contribution merged upstream as PR #1 and included in the archived release.
    Verification
    Merged upstream PR #1 (2026-09-23); Lean Action CI on the upstream repository; release archived on Zenodo as DOI 10.5281/zenodo.22908982, credited to the library author.

    Status & limits. Documentation contribution only — the library is the upstream author’s work. The source has no formal proofs or assertion tests, and the atlas does not establish EMVA 1288 compliance.

    Library by Kim Lien Vu (@vukimlien4706-cpu), Hanoi University of Science and Technology.

More from the lab

  • Signal STT

    Secure Next.js speech-to-text app with live microphone (WebRTC) and file upload; the API key stays server-side.

    Early prototype Next.js · TypeScript · OpenAI
  • England Crime Atlas

    Interactive map of recorded crime in England on a 2 km grid, with a deliberately separate view of court-outcome demographics, built from Police.uk, MoJ and ONS open data.

    Research demonstration Python · Open data · Leaflet
  • JEV Integration Evaluator

    Read-only, offline scanner that finds decision points in a codebase where a typed AI decision might help, then tests them with evidence before anything changes.

    Pre-release · 1.3.0.dev Python · Static analysis · Agent skill
  • USPTO SB/16 Patent Lifecycle Client

    Browser-only prototype that parses USPTO PTO/SB/16 cover-sheet PDFs into structured JSON and a patent-matter lifecycle. The PDF never leaves the browser.

    Prototype React · TypeScript · pdf-lib
  • JEV Context Fabric

    Local-first, source-backed memory layer for coding agents: canonical text with SHA-256 provenance, budgeted retrieval and an installer for eight agent harnesses.

    Alpha · v0.1.0 Python · SQLite FTS5 · Agent tooling
  • AI Self-Replication Study

    Small Python agent that lets a language model run shell commands and answer questions from a command line, in direct, API or Ollama mode. Commands run without confirmation, so it is meant for disposable environments.

    Experimental prototype Python · Ollama · Shell agent
  • LoL OBS Overlay

    Python command-line tool for League of Legends streamers. Reads ranked data and recent matches from the Riot Games API, detects the active account in the local client and writes auto-updating HTML overlays for an OBS Browser Source.

    Early prototype Python · Riot Games API · OBS
  • ML Breakout

    Reinforcement-learning experiment on Atari Breakout: a PyTorch PPO agent with an IMPALA-style CNN and LSTM, plus a Random Network Distillation module for exploration, with manual-play examples and tests. Archived August 2025; no README or published results.

    Archived experiment Python · PyTorch · Gymnasium

Recognition & earlier artifacts

  1. 01 ▌ Live artifact

    VapeTM — Hardcoded AWS IAM Credentials

    Static APK analysis of a VapeTM Android vending application surfaced hardcoded long-lived AWS IAM credentials in builds v1.0.78 and v1.0.87.1. Disclosure ran private → public on a fixed timeline; no live AWS API activity was performed.

    • SEC
    • DISCLOSURE
    Read the disclosure →
  2. 02 ▌ Live artifact

    ClawExplorer.AI — OpenClaw Event Directory

    Community-demanded OpenClaw directory that turns scattered ClawCon event pages into a reviewed, searchable public index. The workflow combines source collection, normalization, dedupe, community submissions, PR review, static event pages, calendar output, and GitHub Actions deployment.

    • AI
    • OPENCLAW
    • DIRECTORY
    Explore the directory →
  3. 03 ▌ Live artifact

    Build AI Workflows in 5 Steps

    Provider-agnostic Jupyter lesson teaching a repeatable AI-workflow design method — from target output and source material into context priming, task automation, and validated outcomes.

    • AI
    • METHOD
    View the workflow →
  4. 04 ▌ Live artifact

    GPT Pilot Showcase Contest — Award

    Awarded in the GPT Pilot Showcase Contest and selected among the top entries for a WordPress plugin that adds an AI-powered Jeopardy game (specimen 05). Early public validation of CompleteTech’s applied-AI direction.

    • AI
    • AWARD
    • GPT PILOT
    View the announcement →
  5. 05 ▌ Live artifact

    AI-Jeopardy — Interactive Demo

    Interactive applied-AI game. Enter a category and clue; the model returns a Jeopardy-format question. A lightweight, demonstrable proof of concept for conversational generation.

    • AI
    • INTERACTIVE
    Be the host →
  6. 06

    ManageEngine User Conference — Dallas

    Conference presentation on Call Center Disaster Response — communication, problem-solving, and resource management strategies for high-pressure incident workflows.

    • ITSM
    • PRESENTATION
    Slides (Microsoft sign-in required) →
  7. 07 ▌ Live artifact

    Certifications & Credentials Ledger

    Microsoft Certified Professional (2006) and CompTIA A+, alongside dated Microsoft Learn and LinkedIn Learning completions in Azure and applied AI. Every entry links to its transcript, certificate or learning path.

    • MICROSOFT
    • COMPTIA
    • AZURE
    View the credentials →