The data pipeline for artificial intelligence, shown rather than described.

Retrieval on a real vector database, a volume that outlives its pod, an agent held to a scope it cannot widen, and the content that explains all of it. Built and measured on my own hardware, with the boundaries stated.

John Collins. Senior artificial-intelligence learning engineer, media producer, tool builder.

Press N to show or hide presenter notes. Press P to print the evidence sheet. Web edition: the walkthroughs stream at full resolution and the live demos open from this site.

See the centerpiece Ten supporting builds

Performance figures carry a label naming the run: measured — my laboratory, run file named Counts (tests, commits, templates) come straight from the repositories. No vendor claims appear on this page. Sources for every figure.

Find the Shot

A measured media retrieval pipeline, and the argument it produces.

Twelve files of my own footage, twenty-five minutes, turned into something you can ask a question of: type it in English and get the clip, the timecode, the frame, and the line that was actually spoken. That part works. The point is the stopwatch on every stage, and what it says about where the storage conversation really is.

Find the Shot, act one: a question typed in plain English returns the clip, the timecode, the still, and the spoken line, with both retrieval paths shown.

94%of the pipeline's wall clock is data preparation: decode, speech, stillsmeasured · run 2026-09-06

6%is the vector database: embedding plus the index write, the only part with a vendormeasured

0.015%index size relative to the media it describes: 0.26 MiB against 1.69 GiBmeasured

81 hwhere 4K camera raw on ten-gigabit Ethernet stops fitting a 24-hour rebuild windowmeasured per minute, projected linearly

Act five: the recorded protocol session showing seven read-only tools, a clamped scope request, and a refused write.

An agent held to a scope it cannot widen

A Model Context Protocol server, written out in 138 lines so the boundary is readable: seven read-only tools advertised, the write tool absent rather than hidden, a scope request clamped with a plain note, every call in an audit trail. The session is recorded by driving the real server.

Act four: the corpus slider and density selector, with the panel turned red where the read path becomes the wall.

The rebuild window, with a slider

A vector index is derived data; a new model, new chunking, or a new modality makes every vector stale. The crossover formula has no compute term. Drag the corpus to ten thousand hours and switch the format, and the architecture moves by a factor of about 290.

Act six: the field kit list — reference architecture, bill of materials, runbook, evaluation report, article, video script, objections.

A field kit generated from the run

Reference architecture, bill of materials, deployment runbook, evaluation report with its limits, a 1,200-word article, a ninety-second video script, fifteen objections with honest answers, and annotated Kubernetes manifests. Regenerated from the measured run, so it cannot drift from the system it describes.

Open the Test Drive Watch the ninety-second cut One file, no server, no model, no network. 52 tests. Milvus, FastEmbed, Whisper on Apple Silicon. A pod-loss experiment on kind: the collection answered 21 seconds after its pod was deleted, and never on an emptyDir.

Presenter notes — Say: I could not find a twelve-second clip in twenty-five minutes of my own footage, so I built the smallest honest retrieval pipeline over it and put a stopwatch on every stage. The vector database was six percent of the work and 0.015 percent of the bytes. The expensive part is data preparation, and a vector index is derived data, so the rebuild window is the storage conversation. Numbers in order: 94, 6, 0.015, 81 hours, 21 seconds. If asked about the build: yes, with an assistant, extensively; what I own is the design, the measurements, the decision not to move the threshold, and every number's provenance — change anything in it in front of me.

Ten supporting builds

Each one answers a line of the job: control planes and agents, evaluation, interactive experiences, inference, retrieval, containers, content operations, and the production discipline to ship it live.

StudioFleet

A local control plane for media and artificial-intelligence workloads.

Placement policy with transactional reservations, a Model Context Protocol server and a REST interface generated from one operation registry, a read-only client that launches Everpure's official Fusion server binary and permits two inventory tools, and semantic search over a source library on Milvus Lite with local transcription behind a review gate. The one mutating tool is withheld unless the server is started with a flag.

1 commandno dependencies, no key, no network

59 / 61tests passing; two blocked by macOS telemetry measured

2 surfacesREST and the protocol server, one policy

See it: python3 -m studiofleet demo, or python3 -m studiofleet.web for the workspace

More about StudioFleet

Presenter notes — Say: control plane versus data plane. Inventory, placement, and audit are control plane; media reads and model loads are data plane. Making metadata faster through a protocol server does not move one frame of video. The line: the assistant expresses intent, the service decides what is valid; the one mutating tool is withheld unless the server is launched with a flag. Answers: integration showcases, agents interacting securely.

Instructor email

Triage: archetype match, feasibility and security flags, a draft reply.

Prompt, version N

Generated from a hardened archetype; immutable; linted against two golden rules.

Simulated students

Seven personas and scripted attacks play the bot; a judge model grades every assertion with quoted evidence.

Scorecard, report, transcripts

Diff them, re-run them after a model update, revert them.

Real transcript import

The same judge grades sessions from the deployed bot, closing the gap with a platform that has no application programming interface.

CourseBotForge

A chatbot factory for a university course-design team.

The method behind the tools I have shipped to instructors: every bot runs against simulated students before anyone sees it, and every conversation is saved so a result can be re-read. The battery caught a tutor that was willing to extend sample code into a threshold-selection loop for the student, before release.

72offline tests, no key needed

3production bots the method was validated on

11 / 11checks on the delivered evaluation tutor measured

See it: the one-page delivery brief for the machine-learning evaluation tutor, written in the instructor's own language.

More about CourseBotForge, with a transcript

Presenter notes — Say: every bot plays against simulated students before an instructor sees it; the battery caught a tutor willing to extend sample code into a threshold loop for the student. Real transcripts go through the same judge. Numbers: 72 offline tests, three production bots, 11 of 11 on the delivered tutor. Answers: translate feature logic into value, with a test battery attached; the fifty-five tools.

WindTwin's live map: turbines over terrain with wake footprints and live status.

Anatomy of a Wind Turbine: the nacelle cutaway chapter rendered live in the browser.

WindTwin and Anatomy of a Wind Turbine

A config-driven digital twin, and a scroll-driven film of the machine.

One site file yields a live map, a three-dimensional turbine with a nacelle cutaway, in-browser anomaly detection, and an alert engine. A recording rig drives the real application through 74 timed beats and regenerates a seven-minute captioned tour whenever the interface changes, timing the narration script against the final cut and flagging any line that no longer fits its shot. The film takes the turbine apart in eleven chapters; one array of chapters is the entire story.

27test files in the twin

74timed beats in the self-recording tour

45,000triangles, live, eleven chapters

See it: the seven-minute walkthrough, or scroll the film.

Watch the walkthrough · 7:15

Presenter notes — Say: one site file, a whole cockpit. The rig drives the real application through 74 beats and flags narration that no longer fits its shot: regenerate, don't record. That is how a large demo library stays current. The film: chapters as data, eleven of them, 45,000 triangles live. Answers: interactive digital experiences, the Pure360 and Test Drive bullet.

A quantpilot report: variants with size, perplexity, KL divergence, top-1 agreement, and tokens per second, and the recommendation inside the quality budget.

comfi: same prompt, same seed, every model, laid out as a grid on an Apple Silicon laptop.

quantpilot and comfi

Measured inference on one Apple Silicon laptop: a quantization autotuner, and an image-model workbench with a judge.

Give it a model and a quality budget. It quantizes several ways across two engines, measures perplexity, KL divergence, top-1 agreement, and HellaSwag on your own hardware, and recommends the smallest artifact inside the budget. Its memory-fit calculator counts the key-value cache at a given context length, which is why the right answer changes with the context, not the weights. comfi is the same discipline applied to image models: two engines on one queue with one model resident at a time, every render carrying a manifest it can be re-run from, a local vision model as judge, blind A/B, and regression runs after every library upgrade. One of its findings: on this chip, bf16 weights beat 8-bit by about a quarter for these matrix shapes, so quantization buys memory, not speed.

0.04%gap between the two engines' baselines, the fairness check measured

8k vs 32kthe recommended artifact flips with context on 16 GB measured

32 sa 1024-pixel image from a 4-billion-parameter model, bf16 beating 8-bit by a quarter measured

See it: quantpilot fit reports/Qwen3-8B-BF16.json --ram 16 --ctx 8192

Watch the terminal demo · 0:46, and comfi

Presenter notes — Say: two engines, four quality signals, baselines 0.04 percent apart so the comparison is fair. The memory-fit calculator counts the key-value cache at the context length, and the recommendation flips between 8k and 32k on sixteen gigabytes. Sizing starts from the context, not the weights, which is the same argument as tiering the cache to flash. Answers: the lifecycle, inference.

600,000 chunks	Exact flat scan	Graph index, defaults
Query	~12 ms	—
Recall	1.0	0.71
Build	none	60 s
Reader effect on the same retrieval	62% → 89%, a 27-point swing

Retrieval held constant. The reader changed the score by 27 points.engram README; LongMemEval and LoCoMo runs, result files in the repository. Graph-index query time is not reported; its recall is. measured

engram and memory-bench

Where the latency budget of local memory actually goes.

A measurement harness and the memory system it produced. An exact threaded flat scan answers in about 12 milliseconds over 600,000 chunks at recall 1.0, where a graph index took 60 seconds to build and reached recall 0.71 at default settings. Asked about things it was never told, the system abstained thirty times out of thirty. The results table is regenerated from the result files, so the document cannot drift from the data.

54 + 16tests across the two repositories

30 / 30abstentions when the answer was absent measured

2,486benchmark questions with labelled evidence

The position it earns: size the index from measurement; below a certain scale the index is the small part, and the storage conversation is the rebuild.

More about the measurements

Presenter notes — Say the caveat first: competitor numbers in the README table were measured with a different reader. Then: flat scan 12 milliseconds over 600,000 chunks at recall 1.0; graph index 60 seconds to build, recall 0.71 at defaults; same retrieval, two readers, 62 versus 89 percent. The position: measure before you size; below a certain scale the index is the small part and the storage conversation is the rebuild. Answers: vector databases, honest benchmarks.

Marketing Intelligence OS

A containerized intelligence platform with an evidence-backed recommendation engine.

Five services in Docker Compose with health-check-gated startup: PostgreSQL 16, Redis 7, an application programming interface, a worker, and a web front end, with Alembic migrations. Model calls go through a provider abstraction with a labelled mock, each logged with tokens and latency. Recommendations carry a priority of impact × confidence × urgency ÷ effort, and every forecast is scored against what actually happened.

5services, one compose file

15test files, make test and make lint

3error metrics per model: mean absolute, root mean square, mean absolute percentage

See it: docker compose up --build, then the narrated walkthrough.

Watch the narrated walkthrough · 0:51

Presenter notes — Say: five services in Compose with health-check-gated startup, migrations, a provider abstraction with a labelled mock, every call logged with tokens and latency, every forecast scored against what happened. Say aloud before they find it: the trend connectors run in a labelled demo mode and authentication is a placeholder. Answers: cloud-native fluency.

The module landing page for five widgets on hallucinations and bias.

The Risk Meter widget: toggle the factors in a query and watch the hallucination and bias risk shift.

Twenty-one interactive explainers

Single files. No server. No network.

Twenty single-file exercises built for a university course on artificial-intelligence literacy — Spot the Hallucination, Four Failure Modes, Risk Meter, Sort by Sensitivity, Should I Share This With AI, and fifteen more — plus an industry workshop with a drag-to-rank exercise and buzzword bingo. Each is one file a learner opens and works through: a scenario, a choice, a checked answer, a next step. It is the shape a guided lab needs, proven across four modules.

20 + 1self-contained exercises, and a workshop

4course modules, each with a landing page

0dependencies to install

See it: double-click any file.

More, and open the exercises

Presenter notes — Say: twenty single-file exercises and a workshop: a scenario, a choice, a checked answer, a next step. No server, no network; double-click any of them. This is the Test Drive lab pattern at volume, and the audience-education job the posting describes. Answers: digital technical experiences.

A rendered explainer frame: four verification levels rising as cards, from a reasonableness check to expert review.

The explainer kit

Motion graphics for explaining models, agents, and retrieval, packaged so someone else can make them.

More than fifty composition templates — token streams, agent loops, a retrieval explainer, an attention explainer, an evaluation scoreboard, metric sparklines — with a five-step playbook from document to rendered 1080p explainer and a seven-part study pack for handing the method to a colleague. Rendered from code, so a corrected number re-renders the film instead of re-editing it.

50+templates in the gallery

5steps from document to film

1080prendered by script, re-runnable

See it: the template gallery, or one rendered module.

Watch a rendered module · 1:38

Presenter notes — Say: more than fifty templates, a five-step playbook from document to rendered film, and a study pack to hand the method to a colleague. Films render from code, so a corrected number re-renders the film instead of re-editing it. Answers: video content mastery and enablement; the content roadmap's production line.

An episode page: each cut piece with a preview, first and last frames, and trim controls that nudge the in and out points.

BCB Studio

A production and distribution desk for an interview podcast: transcribe, assemble, break down, cut, pack, schedule.

Built for an accounting firm's interview show that had thirteen finished recordings waiting and a missed release. One command per stage: local Whisper transcription with word timestamps; an assembly that trims dead air, adds the stingers, and normalizes loudness; a language-model breakdown into chapters, clips, Shorts, and a teaser; cuts snapped to sentence boundaries; and a metadata pack for every platform. The front end opens on the next release and its two-week package, slot by slot, and the deliverables calendar exports two alarms per post to any calendar. Shorts run through Higgsfield's Model Context Protocol server. The interface was redesigned this week as a production desk.

8pieces per episode: teaser, full, three clips, three Shorts

90 sto transcribe a 36-minute episode locally measured

14 daysone package, one rhythm, every date derived

See it: bin/bcb gui; the walkthrough here runs on a fictional show.

Watch the walkthrough · 0:40

Presenter notes — Say: a content roadmap is a rhythm, a package, and a cost per step, and this is what one looks like when an engineer owns it: every date derives from the release day, every piece has a slot and a state, and the calendar carries the alarms. The redesign: the first interface looked like every dashboard kit; this one looks like a production desk, and I can say why each choice was made. Boundary: a real client, shown here as a fictional show. Answers: the content roadmap, content mastery, and MCP used as a client.

T−7 dRig audit, firmware, spares; simulator run against two virtual cameras with per-axis watchdogs

T−3 hReadiness go or no-go: every node answers, every lease expires when the network drops

ShowState is read back, not assumed; any single thing can fail and the ceremony continues

AfterA post-mortem that lists every issue found and how the next version fixed it

"Nothing in this system has run a live ceremony. It cannot lose you the show if it is not carrying the show."The day-of note for 2026-08-29, stating exactly what was real

Grad Cam Control

A software-defined multi-camera production rig, documented so someone else can run the show.

Fourteen design documents, a series of decision records, a risk register, and an event-day runbook written to be executable by someone who did not build the system. Every continuous camera or gimbal motion carries a roughly 250-millisecond lease, so a dead network can never leave a lens moving. The riskiest item in version one, reverse-engineering a gimbal, was killed in favour of a supported interface, and the record says why.

29commits; rehearsed on a ceremony day, not yet carrying the show

13test files, simulator-driven

250 msmotion lease, the fail-safe

The same instinct runs every live demonstration here: recording, then terminal, then published link, and say which one you are on.

More about the runbook

Presenter notes — Say: fourteen documents, decision records, a risk register, and a runbook executable by someone who did not build it. Every motion carries a 250-millisecond lease. The day-of note says the system was not carrying the show, and lists exactly which paths were real. The instinct: recording, then terminal, then published link, and say which one you are on. Answers: live webcasts and production discipline.

The posting, line by line

Ten lines: five things the role will do, five things it asks for. Each maps to work on this page.

The posting	The evidence here
Architect the technical content roadmapdeep-dive blogs, interactive digital experiences, live webcasts	Find the Shot's field kit (article, video script, reference architecture), the explainer kit, BCB Studio as a content pipeline with a rhythm and a cost per step, and Anatomy of an AI Factory as the first roadmap item; the ballroom build notes, a deep-dive post as written
Pioneer integration showcasesModel Context Protocol servers; agents interacting securely with the data plane	Find the Shot, Act 5: scope clamp, absent write tool, audit trail. StudioFleet's second server and its read-only client for the official Fusion server
Orchestrate the technical bill of materialsreference architectures and deployment guides for the field	The field kit's bill of materials and runbook, generated from the measured run; StudioFleet's role-demo plan with a validation-status column; Grad Cam Control's fourteen documents
Drive digital technical experiencesPure360 demonstrations, Test Drive environments, a virtual sandbox	The Test Drive itself: one file, six acts, resettable. WindTwin and the turbine film. Twenty interactive explainers. The ballroom as a walkable scene and a Vision Pro build
Translate feature logic into market valuethe primary liaison between product and marketing	CourseBotForge's delivery brief in the instructor's language; the reference architecture's "where products sit, as placement not claim" section; quantpilot's one result written for four audiences
Expertise in the artificial-intelligence lifecyclestorage and infrastructure with training, fine-tuning, and inference	quantpilot and comfi for inference and sizing on an accelerator with a fixed memory budget; Find the Shot's lifecycle table of what each stage reads and writes
Technical content masterywritten, video, and presentation formats	The 1,200-word article and ninety-second cut in the field kit; the explainer kit; BCB Studio's eight-piece package per episode; the ballroom's promo cut and build notes; the exercises; this page
Cloud-native and data-pipeline fluencyKubernetes and containers; stateful applications; data preparation bottlenecks	The pod-loss experiment (21 seconds with a claim, never without); Marketing Intelligence OS's five-service Compose; the measured 94 percent data-preparation finding
Hands-on technical proficiencyretrieval-augmented generation, vector databases, object storage, high-performance networking	Find the Shot on Milvus with an object-storage layout; engram and memory-bench; StudioFleet's semantic search
Collaborative leadershipalign product, engineering, and sales behind one story	CourseBotForge: instructors, designers, and a platform with no interface held to one test battery; Grad Cam Control's runbook for people who did not build the system

How I work

Three habits, each with a receipt.

Measure before claiming

Find the Shot's first read-rate figure was the speed of hashing bytes on one core, not the disk. The tell was that warm and cold passes agreed. The corrected number sits beside the wrong one on the page, because the gap is the lesson. A reranker I predicted would help was built, measured, and shown in red.

Regenerate, don't record

WindTwin's tour, Find the Shot's ninety-second cut, and the explainer kit's films are re-made from the product by script whenever a number changes. A field kit that drifts from the system it describes is worse than none, so the field kit is generated from the measured run.

Say what is not established

Every document ends with its boundaries: laptop measurements, linear projections, a Kubernetes result that proves the mechanism and not the product, a second machine marked unmeasured until it is measured. Architects trust the person who publishes the methodology with the number.

Anatomy of an AI Factory

What I would build first.

In production

A scroll-driven, three-dimensional walkthrough of how a storage platform serves an artificial-intelligence pipeline, built with the same pipeline as the turbine film and the ballroom below: geometry generated by scripts, chapters as data, a video re-made from the page, and every number labelled. The first of a series.

1The most expensive thing in the rack is the thing that waits
2Raw flash, managed globally
3Two controllers and a shelf
4Compute, network, and flash in one slot
5A million small files
6Take the processor out of the path
7The corpus of record
8Find it, classify it, move it
9Pods die. Volumes do not
10The cache spills to flash
11The agent asks; the server decides
12A vector index is derived data

The turbine film's closing chapter at night: the pipeline that will build the next film.

The HORIZON 2026 ballroom rendered in Cycles: twenty-four dressed tables under ring chandeliers, blue uplights scalloping the walls, and the LED wall lit behind the stage.

The method, already proven on a venue

A photoreal ballroom built entirely by scripts through Blender's Model Context Protocol bridge.

Nothing in the HORIZON 2026 ballroom was modelled by hand. Nine numbered scripts and a shared library rebuild the room from an empty file in the order a crew would load it in: materials, shell, furniture, layout, stage, lighting, cameras, the show state, then a nine-shot edit that switches cameras from timeline markers. Four free texture sets were downloaded and no models. One scene became a first-person walkthrough at eye height, a thirty-two-second flythrough, the promo cut, and a Vision Pro walkthrough with baked lighting. The racks and flash modules in the explainer above get the same treatment the chairs and chandeliers got.

11 scripts2,907 lines of Python; the whole venue and its Vision Pro pipeline as code counted

6.7 s · 95 sper film frame in Eevee; per hero frame in Cycles, from the render logs measured

4 · 0texture sets downloaded; models downloaded counted

See it: renders/horizon_2026_promo_cut_v2.mp4, or open the scene and press Shift and backtick to walk it

More about the ballroom

Presenter notes — Say: this is why the roadmap above is a plan and not a wish. The bridge that placed twenty-four tables will place the racks; geometry is code, chapters are data, and the film is re-rendered when the script changes. The line: "nothing here was clicked into place." Honesty: the summit and the ballroom are fictional; the textures are free Poly Haven scans; the frame times are the last logged frame of each render, not an average. Answers: technical content in video form, digital experiences, the digital-twin pipeline.

Sources for every figure

Measured figures name the run file. Counts are taken from the repositories on 2026-09-06. Paths are relative to each project's folder.

Figure	Kind	Where it lives
94% · 6% · 0.015% · 111.49 s	measured	Find the Shot, `data/runs/run-2026-09-06-0408.json`; summarised in `fieldkit/04-evaluation-report.md`
81 h · 23,651 h · ×290	measured per media minute, projected linearly	Find the Shot, crossover section of `fieldkit/04-evaluation-report.md`; formula in `findtheshot/sizing.py`
21 s · never	measured on kind (Kubernetes 1.37, Milvus 2.6.17, local-path class)	Find the Shot, `data/k8s-recovery.json`; proves the mechanism, not any vendor's product
7 read-only tools · 0 write · 138 lines	measured; counted	Find the Shot, Act 5 transcript in `testdrive/run.js`; `findtheshot/mcp_server.py`
52 tests	counted, run 2026-09-06	Find the Shot, `tests/test_findtheshot.py`
59 of 61 tests	measured 2026-09-06	StudioFleet, verification section of `PROJECT.md`; two tests blocked by denied macOS memory telemetry
72 · 3 · 11 of 11	counted; delivered	CourseBotForge, `tests/`, `docs/golden-rules.md`; the evaluation-tutor delivery brief
27 · 74 · 11 · 45,000	counted	WindTwin, `src/*/.test.ts`, `demo/walkthrough.mjs`; turbine film `src/story/chapters.ts` and README
46 · 0.04% · 8k vs 32k	counted; measured on Apple M1 Max	quantpilot, `tests/`, `examples/qwen3-8b-gguf-vs-mlx.md`, `reports/`
12 ms · 1.0 · 0.71 · 60 s · 62% → 89% · 30 of 30 · 2,486	measured on Apple Silicon	engram README decision table and `results/`; memory-bench `results/` (500 LongMemEval + 1,986 LoCoMo questions)
5 services · 15 test files	counted	Marketing Intelligence OS, `docker-compose.yml` (postgres, redis, api, worker, web), `apps/api/tests/`
20 + 1 · 4 modules	counted	`ai-110-interactive-tools/tools-m4…m7` (20 exercises, 4 index pages); `AVFutureMissionControl.html`
8 pieces · 90 s · 14 days · ~3 h	counted; measured; stated	BCB Studio, `bcb.toml` release package; the handover brief's production-workflow table (mlx-whisper on the M1 Max); the human-time figure is the handover's estimate, not a measurement
11 · 2,907 · 38 · 24 · 4 · 0 · 768	counted	HORIZON ballroom, `scripts/` (nine numbered steps, `venue_lib.py`, `flythrough_prep.py`; line count across all Python files), `HOW_THIS_WAS_BUILT.md` (materials, tables, downloads), `renders/flythrough/` (frames)
6.7 s · 95 s	measured, last logged frame	HORIZON ballroom, `renders/flythrough_render.log` (Eevee, 64 samples, motion blur) and `renders/cycles_stills.log` (Cycles, denoised)
32 s · 150 s · ~25% · 5 s	measured on Apple M1 Max, 32 GB	comfi, README timing table and the judge section; the launch post
50+ templates · 5 steps · 7 parts	counted	Remotion kit, `remotion/assets/templates`, `references/explainer-from-document.md`, the study pack
29 · 13 · 14 · 250 ms	counted; design value	Grad Cam Control, git log, `tests/`, `docs/01…14`, `docs/08_Safety_and_Failsafes.md`, `EVENT_TODAY.md`