Archive
1290 posts · Page 87 of 108. ← Blog
You can't average an infinite stream, or count "all" the events in something that never ends. Windowing is how stream processing carves the unbounded flow into finite, computable chunks — the last minute, each hour, each user session — so that aggregations become meaningful. It's the single most-used concept in practical stream processing, and understanding the window types is understanding how most real streaming logic is expressed.
You can't aggregate an infinite stream, so windowing carves it into finite chunks. Tumbling, sliding, and session windows; triggers that control when a window emits; and how windowing sits on event time and watermarks to produce correct, finite results — the dominant pattern in real stream processing.
To a computer, an image is just a grid of numbers — millions of pixel values with no inherent meaning. Turning that raw grid into something a model can understand (this is a dog, that's a face, here's text on a sign) is the problem of computer vision, and the way it's solved has changed dramatically. The field moved from hand-crafted feature detectors, to convolutional networks that learn features, to — most recently — the surprising discovery that the transformer architecture behind language models works remarkably well for images too. Understanding how models see is the foundation of the vision side of multimodal AI.
To a computer, an image is just a grid of numbers with no inherent meaning. Turning that raw grid into understanding is computer vision, and the field moved from hand-crafted features, to convolutional networks, to the surprising discovery that the transformer architecture behind language models works remarkably well for images too.
This lesson teaches how to build a two-executor pipeline and watch it run as a live stream of typed events.
Your first Agent Framework Go workflow: two string executors wired by an edge, run with RunStreaming and watched as a stream of typed events, fully offline.
I built memory, communication, security, governance, and evals from scratch first. Then I deleted most of it and used the Microsoft Agent Framework-native packages. Here is the audit table and what survived.
Post 2 ended on a hard problem: you need event-time results, but events arrive late and out of order, so you never know when you've seen everything for a given time. Watermarks are stream processing's elegant answer — a running estimate of how far event time has progressed, letting you decide when it's safe to produce a result. They're the mechanism that makes correct event-time computation possible over a messy, unbounded stream.
Watermarks are stream processing's answer to late, out-of-order events: a running estimate of how far event time has progressed, letting you decide when it's safe to emit a result. How they make the completeness-vs-latency tradeoff explicit and tunable, and how to handle late events.
For most of the deep-learning era, an AI model did one thing with one kind of data: this model classifies images, that one translates text, another transcribes speech. Multimodal AI breaks that separation. A single model can now look at an image and describe it, answer questions about a chart, generate a picture from a sentence, or transcribe and reason about audio — because it works across modalities rather than being confined to one. This shift, from single-modality specialists to models that bridge vision, language, audio, and more, is one of the most important developments in modern AI.
For most of deep learning, a model did one thing with one kind of data. Multimodal AI breaks that separation: a single model can look at an image and describe it, generate a picture from a sentence, or transcribe and reason about audio — working across modalities rather than being confined to one. It's one of the most important developments in modern AI.
Compose three kinds of Agent Skill — code-defined, struct-based, and file-based — into a single agent through one skills context provider.
One skills ContextProvider blending three origins: in-memory volume and temperature skills plus a file-based unit-converter, unified behind one tool surface for the model.
Single-turn evals check one decision. Multi-turn evals check the whole trajectory. A Python harness with three evaluators, an offline test suite, and the judge prompt that actually works.
Stream processing has a small, elegant core model: everything is an event, events form streams, and time is a first-class concern. Getting these three ideas precise — especially the subtle and crucial distinction between when an event happened and when you process it — is what makes the rest of stream processing (windowing, state, correctness) comprehensible. This post builds the core vocabulary that everything else depends on.
The core model: events, streams, and time as first-class. The crucial, most-misunderstood distinction between event time (when it happened) and processing time (when you handle it), why correct answers depend on event time, and why that makes time the central problem of streaming.
The demo is easy; the production agent is hard. An agent that works impressively in a demo can fail unpredictably in the real world — looping, hallucinating, taking wrong actions, or racking up huge costs — because the same flexibility that makes agents powerful makes them unreliable. Building agents that actually work in production is a discipline of managing that unreliability: adding guardrails, evaluating rigorously, and, most importantly, knowing when not to use an agent at all. This closing post is about that discipline.
The demo is easy; the production agent is hard. The same flexibility that makes agents powerful makes them unreliable — looping, hallucinating, taking wrong actions, racking up costs. Building agents that actually work is a discipline of managing that unreliability, and knowing when NOT to use an agent at all.
An Agent Skill — on-demand instructions, resources, and scripts — defined entirely in Go, with no SKILL.md files on disk.
An Agent Skill built from Go closures: instructions, a static and a runtime-generated resource, and a convert script that runs in-process with no SKILL.md files.
OpenTelemetry through the Microsoft Agent Framework's configure_otel_providers, custom workflow spans, custom metrics for runs/duration/agent selection, Jaeger + Prometheus + Grafana wiring, and the set-once latch gotcha.