In one line. Watch & Learn is an event-driven, multi-agent pipeline that converts long-form video into structured markdown, and a working sandbox for the Kubernetes platform patterns (multi-region failover, policy-as-code, eBPF observability) that production teams need but rarely get to rehearse.
Knowledge captured on video, talks, recordings, walkthroughs, is some of the least searchable knowledge an organization owns. You cannot grep an hour of footage, and skimming to find the one part you need is expensive. Watch & Learn is a pipeline that watches video and emits structured markdown you can search, link, and review. It is also, deliberately, a place to exercise the harder operational questions: how a multi-agent workload behaves on Kubernetes, how it survives a region failure, and how you observe it without instrumenting every line by hand.
Figure 1. Left: video knowledge that cannot be searched. Right: the same content as structured markdown a person or a tool can query.
📌 Honest scope, up front. Watch & Learn is a private research sandbox, not an open-source release, unlike the rest of the in8 work, its source is not public. This write-up describes the architecture and intent at a high level; the specific models, agent graph, and infrastructure details are intentionally not enumerated here, because the goal is honesty about what is and is not being claimed.
Terms in 30 seconds
Domain engineers: skip ahead, this is orientation for everyone else.
- Multi-agent pipeline: instead of one model doing everything, several specialized agents (e.g. transcription, segmentation, summarization) pass work between them, each handling one step.
- LangGraph: a framework for building stateful, multi-step agent workflows as a graph of nodes, used here to coordinate the agents. (LangGraph)
- Event-driven: stages communicate by emitting and consuming events rather than calling each other directly, so the pipeline scales each stage independently and tolerates bursts.
- Active-active multi-region: the system runs in more than one geographic region at once, so the loss of a whole region degrades capacity rather than causing an outage.
- eBPF: a Linux kernel technology that lets you observe and trace what running programs actually do, without modifying their code. (ebpf.io)
Why this matters
- For teams sitting on video archives: recorded knowledge that cannot be searched is knowledge that effectively does not exist; turning it into markdown makes it a first-class, linkable asset.
- For platform engineers: multi-agent AI workloads are landing on Kubernetes faster than the operational playbooks for running them; a sandbox that exercises failover and observability for that specific shape of workload is worth more than another demo.
- For anyone adopting agentic systems: the hard part is rarely the model; it is the event flow, the back-pressure, and the failure modes around it. This project treats those as the main event.
🧭 If you only read this far: Watch & Learn makes video searchable, and uses that real workload as an excuse to get the Kubernetes operational patterns for multi-agent systems right.
The problem, for engineers who don't live in this space
Imagine a library where every book is sealed shut and the only way to find a passage is to sit and read each book end to end. That is what a folder of recordings is: the information is there, but there is no index, no search, no way to jump to the part that matters. Now add the twist that makes it an engineering problem, you do not want to transcribe one video, you want a system that ingests many, continuously, and keeps producing clean output as load spikes and components fail.
Here is the concrete version. A single transcription-and-summarization run is straightforward to script. Doing it as a service, many videos in flight, each moving through several agent stages, on a cluster that must keep working when one region goes down, is a different problem, and it is a platform problem more than a model problem.
Why this is genuinely hard. Chaining a few agents on a laptop is easy; running them as an event-driven workload that scales each stage independently, survives a region loss without dropping in-flight work, and stays observable, is where the real engineering is, and that is the part this sandbox exists to get right.
How it works
At a high level the pipeline ingests video, moves it through a graph of specialized agents coordinated by LangGraph, and emits structured markdown, all event-driven, on Kubernetes.
- Ingest & events: video sources feed an event queue so each downstream stage scales and retries independently.
- Multi-agent graph: a LangGraph workflow coordinates the per-stage agents (transcription, segmentation, summarization, and structuring into markdown).
- Platform layer: the workload runs on Kubernetes as the testbed for active-active multi-region infrastructure-as-code and eBPF-based observability.
Figure 2. Video in, an event queue, a LangGraph multi-agent pipeline, structured markdown out, all inside the Kubernetes cluster that doubles as the platform sandbox.
Why this is significant
The narrow claim. The contribution here is not a new model, it is treating a real multi-agent AI workload as a forcing function for the operational patterns (event-driven scaling, multi-region active-active failover, kernel-level observability) that the broader industry is still working out for this class of system. The novelty is in the integration and the rehearsal, not in any single component.
Why it matters to the field. Running agentic workloads in production is an open, actively-discussed problem across the cloud-native community; the CNCF ecosystem is converging on patterns for it now. A sandbox that exercises those patterns against a genuine workload, rather than a hello-world, is the kind of practical groundwork the field needs.
📌 Honest scope. This is exploratory and not open source. No adoption, benchmark, or availability numbers are claimed here. The specific infrastructure, models, and results are intentionally left undetailed until they can be shared accurately; treat this page as a statement of architecture and intent.
What's next
Near-term: harden the multi-region failover story and the eBPF observability surface, and decide which parts, if any, can be opened. Watch & Learn sits at the intersection of the two threads that run through the rest of in8's work, agentic systems and the platform engineering needed to run them safely, and exists to make sure the second keeps pace with the first.
Appendix / references
- Status: private research sandbox (not open source).
- Built with: Kubernetes · LangGraph · event-driven architecture · eBPF · multi-region IaC.
- Related in this series: the agentic tooling (better-call-claude, dear-claude, tickettok) and the zero-trust trilogy (forgeseal, svidmint, assayward).